LLMs como puntos finales de integración: Construyendo rutas de camellos de Apache con LangChain4j Chat

Construir funciones de IA es sencillo hasta que necesite integrarlas en un sistema de producción. En la producción, un simple "llamar a un LLM" a menudo se convierte en: Conexión HTTP / JMS / Kafka / entradas de archivos. Enfrentamientos, retiros y fallbacks Contexto obtenido a partir de fuentes de datos internas, para proteger los secretos, hacer que sea probable sin quemar créditos de API, Y asegurarse de que el sistema es observable cuando los problemas ocurren durante la noche. Con Camel 4.5 y posteriores, puede manejar llamadas LLM como puntos finales de integración estándar usando camel-langchain4j-chat, alimentado por LangChain4j. En este tutorial, construirás un proyecto Java 21 y Gradle que demuestre: Chat de mensajes únicos (CHAT_SINGLE_MESSAGE) Prompt templates + variables (CHAT_SINGLE_MESSAGE_WITH_PROMPT) Historia del chat (CHAT_MULTIPLE_MESSAGES) RAG con Camel’s Content Enricher (EIP + estrategia de agregador) RAG a través de los encabezados (enfoque simple “inject context”) Un modo de mock para que todo se ejecute en CI sin claves de API. Acabarás con un proyecto que puedes reutilizar como una base para flujos de integración reales, sin convertir tu base de código en una “fábrica de espagueti rápida”. Lo que estamos construyendo Una pequeña aplicación CLI ejecutable que arranca Camel Main (no se requiere primavera) y ejecuta cinco demostraciones: solitario Rápido Historia Enriquecimiento Rápido Header Puedes ejecutarlos todos o uno a la vez desde la línea de comandos. Precondiciones Java 21 Familiaridad básica con Apache Camel (rutas, directo: endpoints, ProducerTemplate) Opcional: OpenAI API key (el tutorial se ejecuta completamente sin él) La arquitectura en una sola imagen Aquí está el modelo mental: Para RAG, Camel enriquece el intercambio antes de llamar al LLM: Proyecto Instalación Tecnología Stack Java 21 Apache Camel 4.17.0 y más LangChain4j 1.10.0 Grado 8.x OpenAI GPT-4o-mini (opcional) Estructura de follaje camel-langchain4j-chat-demo/ ├── build.gradle ├── settings.gradle ├── src/ │ ├── main/ │ │ ├── java/com/example/langchain4j/ │ │ │ ├── App.java │ │ │ ├── ChatRoutes.java │ │ │ ├── MockChatModel.java │ │ │ └── ModelFactory.java │ │ └── resources/ │ │ ├── application.properties │ │ └── logback.xml │ └── test/ │ └── java/com/example/langchain4j/ │ └── ChatRoutesTest.java └── README.md Paso 1: Instalación gradual Crear : build.gradle plugins { id 'java' id 'application' }

group = 'com.example' version = '1.0.0'

java { toolchain { languageVersion = JavaLanguageVersion.of(21) } }

application { mainClass = 'com.example.langchain4j.App' }

repositories { mavenCentral() }

dependencies { implementation 'org.apache.camel:camel-core:4.17.0' implementation 'org.apache.camel:camel-main:4.17.0' implementation 'org.apache.camel:camel-langchain4j-chat:4.17.0' implementation 'dev.langchain4j:langchain4j-core:1.10.0' implementation 'dev.langchain4j:langchain4j-open-ai:1.10.0' implementation 'ch.qos.logback:logback-classic:1.5.15' testImplementation 'org.junit.jupiter:junit-jupiter:5.11.4' testImplementation 'org.apache.camel:camel-test-junit5:4.17.0' testImplementation 'org.assertj:assertj-core:3.27.3' }

test { useJUnitPlatform() } y : settings.gradle rootProject.name = 'camel-langchain4j-chat-demo' Paso 2: Configuración y logging application.properties # Application Mode (mock or openai) app.mode=openai

# OpenAI Configuration (only used when app.mode=openai) openai.apiKey=sk-***** openai.modelName=gpt-4o-mini openai.temperature=0.3

# Apache Camel Configuration camel.main.name=camel-langchain4j-chat-demo camel.main.duration-max-seconds=0 camel.main.shutdown-timeout=30

# Logging Configuration logging.level.root=INFO logging.level.org.apache.camel=INFO logging.level.com.example.langchain4j=DEBUG logback.xml %d{HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n

Paso 3: Modo “Mock” amigable con la producción (no se requiere clave de API) Si quieres que esto sea más que una demostración de juguete, necesitas una forma de ejecutarlo sin dependencias externas. Es por eso que implementamos una : deterministic MockChatModel MockChatModel.java package com.example.langchain4j;

import dev.langchain4j.data.message.AiMessage; import dev.langchain4j.data.message.ChatMessage; import dev.langchain4j.model.chat.ChatModel; import dev.langchain4j.model.chat.request.ChatRequest; import dev.langchain4j.model.chat.response.ChatResponse;

/** * Mock implementation of ChatModel for testing and demo without API keys. */ public class MockChatModel implements ChatModel {

@Override public ChatResponse chat(ChatRequest request) { StringBuilder response = new StringBuilder("[MOCK] Responding to: "); if (request != null && request.messages() != null && !request.messages().isEmpty()) { ChatMessage lastMessage = request.messages().get(request.messages().size() - 1); // Use text() method which should exist String userText = ""; try { userText = (String) lastMessage.getClass().getMethod("text").invoke(lastMessage); } catch (Exception e) { userText = lastMessage.toString(); } // Generate deterministic response based on content if (userText.contains("recipe") || userText.contains("dish")) { response.append("Here's a delicious recipe with your requested ingredients!"); } else if (userText.contains("Apache Camel")) { response.append("Apache Camel is a powerful integration framework!"); } else if (userText.contains("capital")) { response.append("Paris is the capital of France."); } else { response.append("I understand your question about: ").append(userText.substring(0, Math.min(50, userText.length()))); } } else { response.append("Hello! I'm a mock AI assistant."); } return ChatResponse.builder() .aiMessage(new AiMessage(response.toString())) .build(); } } Por qué esto es importante en la producción: CI / CD no requiere un LLM. Las pruebas de unidad son estables. Los ingenieros pueden trabajar fuera de línea. Puede validar la lógica del flujo (routing, RAG, plantillas) antes de gastar dinero. Paso 4: Elegir un modelo en tiempo de ejecución (OpenAI o Mock) ModelFactory.java package com.example.langchain4j;

import dev.langchain4j.model.chat.ChatModel; import dev.langchain4j.model.openai.OpenAiChatModel; import org.slf4j.Logger; import org.slf4j.LoggerFactory;

import java.time.Duration;

/** * Factory to create ChatModel instances based on configuration. */ public class ModelFactory { private static final Logger log = LoggerFactory.getLogger(ModelFactory.class);

public static ChatModel createChatModel(String mode, String apiKey, String modelName, Double temperature) { if ("openai".equalsIgnoreCase(mode) && apiKey != null && !apiKey.isEmpty()) { log.info("Creating OpenAI chat model with model: {}", modelName); return OpenAiChatModel.builder() .apiKey(apiKey) .modelName(modelName) .temperature(temperature) .timeout(Duration.ofSeconds(60)) .build(); } else { log.info("Creating Mock chat model (API key not provided or mode is mock)"); return new MockChatModel(); } } } Paso 5: Las rutas de los camellos (donde la IA se convierte en “Just Another Endpoint”) El componente URI de Camel se ve como: langchain4j-chat:chatId?chatModel=#beanName&chatOperation=OPERATION ChatId es sólo un identificador chatModel=#chatModel hace referencia a un bean en el registro de Camel ChatOperation controla el comportamiento ChatRoutes.java package com.example.langchain4j;

import dev.langchain4j.data.message.AiMessage; import dev.langchain4j.data.message.ChatMessage; import dev.langchain4j.data.message.SystemMessage; import dev.langchain4j.data.message.UserMessage; import dev.langchain4j.rag.content.Content; import org.apache.camel.AggregationStrategy; import org.apache.camel.Exchange; import org.apache.camel.builder.RouteBuilder; import org.apache.camel.component.langchain4j.chat.LangChain4jChat;

import java.util.ArrayList; import java.util.List; import java.util.Map;

/** * Apache Camel routes demonstrating camel-langchain4j-chat component usage. */ public class ChatRoutes extends RouteBuilder {

@Override public void configure() throws Exception { // Demo 1: CHAT_SINGLE_MESSAGE - Simple question/answer from("direct:single") .log("Demo 1: Single message - Input: ${body}") .to("langchain4j-chat:demo?chatModel=#chatModel&chatOperation=CHAT_SINGLE_MESSAGE") .log("Demo 1: Response: ${body}");

// Demo 2: CHAT_SINGLE_MESSAGE_WITH_PROMPT - Using prompt template with variables from("direct:prompt") .log("Demo 2: Prompt template - Variables: ${body}") .process(exchange -> { // Set the prompt template in header String template = "Create a recipe for a {{dishType}} with these ingredients: {{ingredients}}"; exchange.getIn().setHeader("CamelLangChain4jChatPromptTemplate", template); }) .to("langchain4j-chat:demo?chatModel=#chatModel&chatOperation=CHAT_SINGLE_MESSAGE_WITH_PROMPT") .log("Demo 2: Response: ${body}");

// Demo 3: CHAT_MULTIPLE_MESSAGES - Chat with history/context from("direct:history") .log("Demo 3: Multiple messages with history") .process(exchange -> { // Build a conversation with system message, previous context, and user question List messages = new ArrayList<>(); messages.add(new SystemMessage("You are a helpful AI assistant specialized in Apache Camel.")); messages.add(new UserMessage("What is Apache Camel?")); messages.add(new AiMessage("Apache Camel is an open-source integration framework based on enterprise integration patterns.")); messages.add(new UserMessage("What are some key features?")); exchange.getIn().setBody(messages); }) .to("langchain4j-chat:demo?chatModel=#chatModel&chatOperation=CHAT_MULTIPLE_MESSAGES") .log("Demo 3: Response: ${body}");

// Demo 4: RAG using Content Enricher pattern with LangChain4jRagAggregatorStrategy from("direct:rag-enrich") .log("Demo 4: RAG with Content Enricher - Question: ${body}") .enrich("direct:rag-source", new LangChain4jRagAggregatorStrategy()) .to("langchain4j-chat:demo?chatModel=#chatModel&chatOperation=CHAT_SINGLE_MESSAGE") .log("Demo 4: Response: ${body}");

// RAG knowledge source route from("direct:rag-source") .log("Fetching RAG knowledge...") .process(exchange -> { // Simulate fetching relevant documents/snippets List knowledgeSnippets = new ArrayList<>(); knowledgeSnippets.add("Apache Camel 4.x introduced the concept of lightweight mode for faster startup."); knowledgeSnippets.add("The camel-langchain4j-chat component supports multiple chat operations including single message, prompt templates, and chat history."); knowledgeSnippets.add("LangChain4j integration allows Camel routes to interact with various LLM providers like OpenAI, Azure OpenAI, and more."); exchange.getIn().setBody(knowledgeSnippets); });

// Demo 5: RAG using CamelLangChain4jChatAugmentedData header from("direct:rag-header") .log("Demo 5: RAG with header - Question: ${body}") .process(exchange -> { String question = exchange.getIn().getBody(String.class); // Create augmented data content List augmentedData = new ArrayList<>(); augmentedData.add(Content.from("Apache Camel version 4.0 was released in 2023 with major improvements.")); augmentedData.add(Content.from("The LangChain4j component enables AI-powered integration patterns in Camel routes.")); // Set augmented data in header exchange.getIn().setHeader("CamelLangChain4jChatAugmentedData", augmentedData); // Reset body to the question exchange.getIn().setBody(question); }) .to("langchain4j-chat:demo?chatModel=#chatModel&chatOperation=CHAT_SINGLE_MESSAGE") .log("Demo 5: Response: ${body}"); } /** * Custom aggregation strategy for RAG pattern using Content Enricher. */ private static class LangChain4jRagAggregatorStrategy implements AggregationStrategy { @Override public Exchange aggregate(Exchange original, Exchange resource) { String question = original.getIn().getBody(String.class); List knowledgeSnippets = resource.getIn().getBody(List.class); // Build augmented prompt with context StringBuilder augmentedPrompt = new StringBuilder(); augmentedPrompt.append("Context:\n"); for (String snippet : knowledgeSnippets) { augmentedPrompt.append("- ").append(snippet).append("\n"); } augmentedPrompt.append("\nQuestion: ").append(question); original.getIn().setBody(augmentedPrompt.toString()); return original; } } } Por qué el enfoque de Camel es útil El Camino te da (Padrones de integración empresarial) que se aplican hermosamente a la IA: EIPs Contenido enriquecido RAG Interruptor de circuitos → LLM resiliencia El control de los costes Canal de letra muerta → Ruta fallida Idempotencia: no procesar la misma solicitud dos veces. Usted no necesita una nueva arquitectura. Usted reutiliza patrones de integración probados. Paso 6: Bootstrapping Camel Main + Demos de ejecución App.java package com.example.langchain4j;

import dev.langchain4j.model.chat.ChatModel; import org.apache.camel.CamelContext; import org.apache.camel.ProducerTemplate; import org.apache.camel.main.Main; import org.slf4j.Logger; import org.slf4j.LoggerFactory;

import java.util.HashMap; import java.util.Map;

/** * Main application class demonstrating Apache Camel LangChain4j Chat component. */ public class App { private static final Logger log = LoggerFactory.getLogger(App.class);

public static void main(String[] args) throws Exception { Main main = new Main(); // Configure Camel Main main.configure().addRoutesBuilder(new ChatRoutes()); // Initialize Camel context first (without starting routes) main.init(); CamelContext camelContext = main.getCamelContext(); // Read configuration from properties String mode = camelContext.resolvePropertyPlaceholders("{{app.mode}}"); String apiKey = System.getenv("OPENAI_API_KEY"); if (apiKey == null || apiKey.isEmpty()) { apiKey = camelContext.resolvePropertyPlaceholders("{{openai.apiKey}}"); } String modelName = camelContext.resolvePropertyPlaceholders("{{openai.modelName}}"); Double temperature = Double.parseDouble(camelContext.resolvePropertyPlaceholders("{{openai.temperature}}")); // Create and register ChatModel BEFORE starting routes ChatModel chatModel = ModelFactory.createChatModel(mode, apiKey, modelName, temperature); camelContext.getRegistry().bind("chatModel", chatModel); log.info("=".repeat(80)); log.info("Apache Camel LangChain4j Chat Demo"); log.info("Mode: {}", mode); log.info("=".repeat(80)); // Now start Camel main.start(); try { // Determine which demo(s) to run String demoMode = args.length > 0 ? args[0] : "all"; ProducerTemplate template = camelContext.createProducerTemplate(); switch (demoMode.toLowerCase()) { case "single": runSingleMessageDemo(template); break; case "prompt": runPromptTemplateDemo(template); break; case "history": runChatHistoryDemo(template); break; case "rag-enrich": runRagEnrichDemo(template); break; case "rag-header": runRagHeaderDemo(template); break; case "all": default: runAllDemos(template); break; } log.info("=".repeat(80)); log.info("Demo completed! Shutting down..."); log.info("=".repeat(80)); } finally { // Shutdown after demos complete main.stop(); } } private static void runAllDemos(ProducerTemplate template) { runSingleMessageDemo(template); runPromptTemplateDemo(template); runChatHistoryDemo(template); runRagEnrichDemo(template); runRagHeaderDemo(template); } private static void runSingleMessageDemo(ProducerTemplate template) { log.info("\n" + "=".repeat(80)); log.info("DEMO 1: CHAT_SINGLE_MESSAGE"); log.info("=".repeat(80)); String question = "What is the capital of France?"; String response = template.requestBody("direct:single", question, String.class); log.info("Question: {}", question); log.info("Answer: {}", response); } private static void runPromptTemplateDemo(ProducerTemplate template) { log.info("\n" + "=".repeat(80)); log.info("DEMO 2: CHAT_SINGLE_MESSAGE_WITH_PROMPT (Prompt Template)"); log.info("=".repeat(80)); Map variables = new HashMap<>(); variables.put("dishType", "pasta"); variables.put("ingredients", "tomatoes, garlic, basil, olive oil"); String response = template.requestBody("direct:prompt", variables, String.class); log.info("Template: Create a recipe for a {{dishType}} with these ingredients: {{ingredients}}"); log.info("Variables: {}", variables); log.info("Answer: {}", response); } private static void runChatHistoryDemo(ProducerTemplate template) { log.info("\n" + "=".repeat(80)); log.info("DEMO 3: CHAT_MULTIPLE_MESSAGES (Chat History)"); log.info("=".repeat(80)); log.info("Building conversation with context..."); String response = template.requestBody("direct:history", null, String.class); log.info("Final Answer: {}", response); } private static void runRagEnrichDemo(ProducerTemplate template) { log.info("\n" + "=".repeat(80)); log.info("DEMO 4: RAG with Content Enricher Pattern"); log.info("=".repeat(80)); String question = "What's new in Apache Camel 4.x?"; String response = template.requestBody("direct:rag-enrich", question, String.class); log.info("Question: {}", question); log.info("Answer (with RAG context): {}", response); } private static void runRagHeaderDemo(ProducerTemplate template) { log.info("\n" + "=".repeat(80)); log.info("DEMO 5: RAG with CamelLangChain4jChatAugmentedData Header"); log.info("=".repeat(80)); String question = "Tell me about the LangChain4j integration in Camel"; String response = template.requestBody("direct:rag-header", question, String.class); log.info("Question: {}", question); log.info("Answer (with augmented data): {}", response); } } Correrlo Construir + ejecutar todas las demostraciones (mock mode) ./gradlew clean test ./gradlew run Encuentra una demo ./gradlew run --args="prompt" ./gradlew run --args="rag-enrich" Activar el modo OpenAI Opción A (propiedades): app.mode=openai openai.apiKey=sk-... Opción B (recomendado): variable ambiental Windows (PowerShell) setx OPENAI_API_KEY "sk-..." Luego en Puedes utilizar un lugar: application.properties openai.apiKey=${OPENAI_API_KEY:} Ejemplo de salida (Mock Mode) Usted verá registros como: === DEMO 1: CHAT_SINGLE_MESSAGE === Q: What is the capital of France? A: [MOCK] The capital of France is Paris. Las mejores prácticas (la cosa que apreciarás más tarde) 1) Nunca las claves de API de código duro Utilice variables de entorno o un gestor de secretos. Incluso en las demostraciones, establezca el patrón. openai.apiKey=${OPENAI_API_KEY:} 2) Añadir temporadas y resiliencia temprano Los LLM son llamadas de red. Tratarlos como cualquier dependencia: temporadas, retries, fallback. En Camel, esto se convierte típicamente en: timeout() / circuitoBreaker() (Resilience4j) onException() para vías de error controladas throttle() para proteger el presupuesto y los límites de arriba 3) Mantener las prompts versionadas y externalizadas Los prompts son “lógica de negocios”. no los enterres como cadenas en métodos aleatorios. Al menos: tiendas de templos en y cargarlos, o gestionarlos como activos de versión. resources/ 4) Utilice el modo mock + pruebas para proteger su tubería Tu código LLM debe ser probable sin llamadas de red. Eso es lo que te lo da. MockChatModel Unidad que prueba las rutas ChatRoutesTest.java package com.example.langchain4j;

import dev.langchain4j.data.message.UserMessage; import dev.langchain4j.model.chat.request.ChatRequest; import dev.langchain4j.model.chat.response.ChatResponse; import org.apache.camel.CamelContext; import org.apache.camel.ProducerTemplate; import org.apache.camel.builder.RouteBuilder; import org.apache.camel.test.junit5.CamelTestSupport; import org.junit.jupiter.api.Test;

import java.util.HashMap; import java.util.List; import java.util.Map;

import static org.assertj.core.api.Assertions.assertThat;

/** * Unit tests for ChatRoutes using MockChatModel. */ public class ChatRoutesTest extends CamelTestSupport {

@Override protected CamelContext createCamelContext() throws Exception { CamelContext context = super.createCamelContext(); // Register MockChatModel for testing context.getRegistry().bind("chatModel", new MockChatModel()); return context; }

@Override protected RouteBuilder createRouteBuilder() { return new ChatRoutes(); }

@Test public void testSingleMessage() { ProducerTemplate template = context.createProducerTemplate(); String question = "What is the capital of France?"; String response = template.requestBody("direct:single", question, String.class); assertThat(response) .isNotNull() .isNotEmpty() .contains("MOCK") .contains("capital"); }

@Test public void testPromptTemplate() { ProducerTemplate template = context.createProducerTemplate(); Map variables = new HashMap<>(); variables.put("dishType", "pasta"); variables.put("ingredients", "tomatoes, garlic, basil"); String response = template.requestBody("direct:prompt", variables, String.class); assertThat(response) .isNotNull() .isNotEmpty() .contains("MOCK") .containsAnyOf("recipe", "dish"); }

@Test public void testChatHistory() { ProducerTemplate template = context.createProducerTemplate(); String response = template.requestBody("direct:history", null, String.class); assertThat(response) .isNotNull() .isNotEmpty() .contains("MOCK"); }

@Test public void testRagEnrich() { ProducerTemplate template = context.createProducerTemplate(); String question = "What's new in Apache Camel 4.x?"; String response = template.requestBody("direct:rag-enrich", question, String.class); assertThat(response) .isNotNull() .isNotEmpty() .contains("MOCK") .containsAnyOf("Camel", "Apache"); }

@Test public void testRagHeader() { ProducerTemplate template = context.createProducerTemplate(); String question = "Tell me about LangChain4j in Camel"; String response = template.requestBody("direct:rag-header", question, String.class); assertThat(response) .isNotNull() .isNotEmpty() .contains("MOCK"); }

@Test public void testMockChatModel() { MockChatModel mockModel = new MockChatModel(); ChatRequest request = ChatRequest.builder() .messages(List.of(new UserMessage("What is Apache Camel?"))) .build(); ChatResponse response = mockModel.chat(request); assertThat(response).isNotNull(); assertThat(response.aiMessage()).isNotNull(); assertThat(response.aiMessage().text()) .contains("MOCK") .contains("Apache Camel"); } } RAG: Dos enfoques (cuándo usar cuál) Approach How it works Best for Tradeoff ( ) Content Enricher enrich Camel pulls context from one or more routes and merges it Dynamic retrieval, multiple sources Slightly more code (strategy) ( ) Header-based AUGMENTED_DATA You directly attach known context as structured content Simple static context or already-retrieved context Less flexible for complex retrieval logic (en el ) Content Enricher enrich El camello extrae el contexto de una o más rutas y lo fusiona Recuperación dinámica, múltiples fuentes Un poco más de código (estrategia) (en el ) Header-based AUGMENTED_DATA Añadir directamente el contexto conocido como contenido estructurado Contexto estático simple o contexto ya recuperado Menos flexible para la lógica de recuperación compleja En proyectos reales, RAG a menudo evoluciona de esta manera: Comience con el encabezado (rápido, fácil, predecible) Mover a enriquecer() cuando la búsqueda se convierte en un flujo de trabajo (DB vector, permisos, rearrangamiento) Casos de uso del mundo real (donde este patrón se ajusta) Cuando te sientes cómodo con La misma estructura de poder: camel-langchain4j-chat Rutación del soporte al cliente (tickets → context → response) Document pipelines (extraer → resumir → clasificar → ruta) Enriquecimiento de datos (eventos entrantes → explicar / etiquetar → persistir) Asistentes de operaciones (logs/metrics → RAG → pasos de reparación) La clave es Camel: ya sabe cómo conectar y orquestar todo alrededor de la llamada de IA. Conclusión: Tratar LLM llama a integraciones, no a "flocos de nieve especiales" El mayor cambio de mentalidad es este: Un LLM no es una aplicación, es una dependencia, como una base de datos, una cola o una API. Un LLM no es una aplicación, es una dependencia, como una base de datos, una cola o una API. Y si lo tratas de esa manera, naturalmente construirás: más rápidos, mejor gestión de errores, La probabilidad, y flujos de integración que pueden escalar más allá de las demostraciones.