LLM come endpoint di integrazione: costruire rotte Apache Camel con LangChain4j Chat

La costruzione di funzionalità AI è semplice fino a quando non è necessario integrarle in un sistema di produzione. In produzione, un semplice 'chiama un LLM' diventa spesso: Connessione HTTP / JMS / Kafka / File Inputs per l’applicazione dei tempi, dei ritiri, dei fallbacchi, la sintesi del contesto ottenuto da fonti di dati interne, proteggere i segreti, rendendolo testabile senza bruciare crediti API, e garantire che il sistema sia osservabile quando i problemi si verificano durante la notte. Con Camel 4.5 e versioni successive, è possibile gestire le chiamate LLM come terminali di integrazione standard utilizzando camel-langchain4j-chat, alimentato da LangChain4j. In questo tutorial, costruirai un progetto Java 21 e Gradle che dimostra: Chat di singolo messaggio (Chat_SINGLE_MESSAGE) Prompt template + variabili (CHAT_SINGLE_MESSAGE_WITH_PROMPT) Storia della chat (CHAT_MULTIPLE_MESSAGES) RAG con il Content Enricher di Camel (strategia EIP + aggregatore) RAG via headers (approccio semplice “inject context”) Una modalità mock in modo che tutto si esegue in CI senza chiavi API. Si concluderà con un progetto che può essere riutilizzato come base per veri flussi di integrazione, senza trasformare la vostra base di codice in una "fabbrica di spaghetti pronta". Cosa stiamo costruendo Una piccola app CLI eseguibile che avvia Camel Main (nessuna primavera necessaria) e esegue cinque demo: singolo veloce Storia Il rag-enrich Il rag-header Puoi eseguire tutti o uno alla volta dalla riga di comando. Prerequisiti Giovanna 21 Familiarità di base con Apache Camel (routes, direct: endpoints, ProducerTemplate) Opzionale: OpenAI API key (il tutorial funziona completamente senza di esso) Architettura in un'immagine Ecco il modello mentale: Per RAG, Camel arricchisce lo scambio prima di chiamare il LLM: Progetto Setup Tecnica di Stack Giovanna 21 Apache Camel 4.17.0 per Mac LungoChain4j 1.10.0 Classe 8.x OpenAI GPT-4o-mini (opzionale) Struttura di Folder 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 Passo 1: Impostazione graduale creazione : 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() } e : settings.gradle rootProject.name = 'camel-langchain4j-chat-demo' Passo 2: Configurazione e 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

Passo 3: Modalità “Mock” amichevole alla produzione (non è richiesto alcun chiave API) Se vuoi che questo sia più di una demo giocattolo, hai bisogno di un modo per eseguire senza dipendenze esterne. Questo è il motivo per cui abbiamo implementato un : 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(); } } Perché questo è importante nella produzione: CI / CD corse non richiedono un LLM. I test di unità sono stabili. Gli ingegneri possono lavorare offline. Puoi valutare la logica del flusso (routing, RAG, template) prima di spendere denaro. Passo 4: Scegliere un modello in runtime (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(); } } } Passo 5: Le rotte dei cammelli (dove l'IA diventa "Just Another Endpoint") Il componente URI di Camel sembra: langchain4j-chat:chatId?chatModel=#beanName&chatOperation=OPERATION ChatId è solo un identificatore chatModel=#chatModel fa riferimento a un fascio nel registro Camel ChatOperazione controlla il comportamento 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; } } } Perché l'approccio di Camel è utile Camilla ti dà (Modelli di integrazione aziendale) che si applicano perfettamente all'IA: EIPs Contenuto Enricher → RAG Circuit breaker → LLM resilienza Controllare i costi Canale lettera morta → routing fallito Idempotenza: non eseguire la stessa richiesta due volte Non hai bisogno di una nuova architettura, riutilizzi modelli di integrazione comprovati. Passo 6: Bootstrapping Camel Main + Running Demos 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); } } Correre il Costruire + eseguire tutte le demo (mock mode) ./gradlew clean test ./gradlew run Gioca una demo ./gradlew run --args="prompt" ./gradlew run --args="rag-enrich" Attivare la modalità OpenAI Opzione A (proprietà): app.mode=openai openai.apiKey=sk-... Opzione B (consigliata): variabile ambientale Windows (PowerShell) setx OPENAI_API_KEY "sk-..." Poi in Puoi usare un posizionatore: application.properties openai.apiKey=${OPENAI_API_KEY:} Esempio di uscita (mock mode) Vedrete i log come: === DEMO 1: CHAT_SINGLE_MESSAGE === Q: What is the capital of France? A: [MOCK] The capital of France is Paris. Le migliori pratiche (la cosa che apprezzerai più tardi) 1) Non usare mai le chiavi API Utilizzare le variabili ambientali o un gestore di segreti. Anche in demo, impostare il modello. openai.apiKey=${OPENAI_API_KEY:} 2) Aggiungere timelines e resilienza in anticipo I LLM sono chiamate di rete. Trattali come qualsiasi dipendenza: timeouts, retries, fallback. In Camel, questo diventa tipicamente: timeout() / circuitoBreaker() (Resilience4j) onException() per percorsi di fallimento controllati throttle() per proteggere i limiti di budget e upstream 3) Mantenere i prompt versati e esternalizzati I prompt sono “logica aziendale”. non seppellirli come stringhe in metodi casuali. Al minimo: negozi di template in e caricarli, o gestirli come attività versate. resources/ 4) Utilizzare la modalità mock + test per proteggere la pipeline Il tuo codice LLM dovrebbe essere testabile senza chiamate di rete. Ti dà MockChatModel Unità che testano le strade 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: due approcci (quando usare il quale) 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 ( di ) Content Enricher enrich Camello attrae il contesto da uno o più percorsi e lo unisce Recupero dinamico, fonti multiple Un po’ di codice (strategia) ( di ) Header-based AUGMENTED_DATA Applicare direttamente il contesto conosciuto come contenuto strutturato Contesto statico semplice o contesto già recuperato Meno flessibile per la logica di recupero complessa In progetti reali, RAG spesso si sviluppa in questo modo: Iniziare con header-based (rapido, facile, prevedibile) Passare a arricchire() quando il recupero diventa un flusso di lavoro (vector DB, autorizzazioni, riassetto) Casi di utilizzo del mondo reale (dove questo modello si adatta) Una volta che sei a tuo agio La stessa struttura di potere: camel-langchain4j-chat Routing del supporto clienti (tickets → contesto → risposta) Trasporti di documenti (estratto → riassumere → classificare → percorso) L’arricchimento dei dati (eventi in arrivo → spiegare/etichettare → persistere) Assistenti Ops (log / metriche → RAG → passaggi di rimedio) La chiave è Camel: sa già come connettere e orchestrare tutto intorno alla chiamata AI. Conclusione: trattare LLM chiama come integrazioni, non "fiocchi di neve speciali" Il più grande cambiamento di mentalità è questo: Un LLM non è un'app. È una dipendenza - come un database, una coda o un'API. Un LLM non è un'app. È una dipendenza - come un database, una coda o un'API. E se lo tratti in questo modo, naturalmente costruirai: Più veloce di sicuro, migliorare la gestione degli errori, La sperimentazione, e flussi di integrazione che possono scalare al di là delle demo.