LLMs toy ny Integration Endpoints: Ny fanorenana ny Apache Camel Routes amin'ny LangChain4j Chat

Ny famoronana endri-javatra amin'ny AI dia tsotra mandra-pahatongavana amin'ny famoronana azy ireo ao amin'ny rafitra famokarana. Ao amin'ny famokarana, ny tsotra 'mampiantso LLM' matetika dia lasa: fandefasana ny HTTP / JMS / Kafka / rakitra entana, Ao anaty fitafiana vita amin'ny lamba. ny fametrahana ny fifandraisana avy amin'ny loharanom-baovao anatiny, Ny fiarovana ny tsiambaratelo, Izany dia ahafahan'ny mpamatsy fiaramanidina tsy handoro fiaramanidina, Ary miantoka fa ny rafitra dia azo jerena rehefa misy olana amin'ny alina. Amin'ny Camel 4.5 sy ny farany, azonao atao ny mandrindra ny antso LLM ho toy ny fototry ny integration amin'ny fampiasana camel-langchain4j-chat, miasa amin'ny LangChain4j. Amin'ity fampiofanana ity dia hanorina tetikasa Java 21 sy Gradle ianao izay mampiseho: Chat amin'ny hafatra tokana (CHAT_SINGLE_MESSAGE) Mifandray amin'ny endriky ny endriky ny endriky ny endriky ny endriky ny endriky ny endriky ny endriky ny endriky ny endriky ny endriky ny endriky ny endriky ny endriky ny endriky ny endriky ny endriky ny endriky ny endrika (CHAT_SINGLE_MESSAGE_WITH_PROMPT) Ny tantara amin'ny chat (CHAT_MULTIPLE_MESSAGES) RAG amin'ny Content Enricher amin'ny Camel (EIP + Aggregator Strategy) RAG amin'ny alàlan'ny lohateny (fomba tsotra "inject context") Ny fomba mock mba hanatanterahana ny zava-drehetra ao amin'ny CI tsy misy rakitra API. Ho tapitra ianao amin'ny tetikasa izay azo ampiasaina indray ho toy ny fototra ho an'ny fivoaran'ny integration tena, raha tsy manova ny codebase amin'ny "fabrika spaghetti haingana". Inona no ataontsika Ny fampiharana CLI kely izay manomboka amin'ny Camel Main (tsy ilaina ny Spring) ary mandeha amin'ny fampisehoana dimy: Ny tokantrano haingana Ny tantara Ny renivohiny Ny lohan'ny Azonao atao ny mihazakazaka azy ireo rehetra na ny iray amin'ny fotoana avy amin'ny andininy baiko. Ny fepetra Ny faha 21 Basic Apache Camel fahafantarana (routes, mivantana: endpoints, ProducerTemplate) Optional: OpenAI API key (ny fampiofanana dia mihazakazaka tanteraka raha tsy misy azy) Ny fanorenana ao amin'ny sary iray Ity ny modely ara-tsaina : Ho an'ny RAG, Camel manatsara ny fifanakalozan-kevitra alohan'ny hampiasa ny LLM: Ny tetikasa fametrahana Teknika amin'ny Stack Ny faha 21 Ny Apache Camel dia 4.17.0. Ny fidirana amin'ny fidirana amin'ny fidirana amin'ny fidirana amin'ny fidirana amin'ny fidirana amin'ny fidirana amin'ny fidirana amin'ny fidirana. Ny fahatongavan'ny 8.x OpenAI GPT-4o-mini (tsy misy safidy)' Ny rafitra 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 Ny dingana voalohany dia ny fametrahana Ny famoronana : 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() } Ary : settings.gradle rootProject.name = 'camel-langchain4j-chat-demo' Ny dingana faharoa dia ny fametrahana sy fametrahana 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

dingana 3: “Mock Mode” ho an'ny famokarana (tsy ilaina ny API Key) Raha tianao izany ho mihoatra noho ny lalao demo, dia mila fomba ahafahanao mihazakazaka izany raha tsy misy fitoviana ivelany. Izany no mahatonga ny fampiharana a : 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(); } } Nahoana izany no zava-dehibe amin'ny famokarana: Ny CI / CD dia tsy mitaky LLM. Ny fanandramana ny solosaina dia azo antoka. Ny injeniera dia afaka miasa offline. Azonao atao ny mamantatra ny logic flow (routing, RAG, templates) alohan'ny handany vola. dingana 4: Fisafidianana modely amin'ny fotoana mihazakazaka (OpenAI na 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(); } } } Ny dingana 5: ny Camel Routes (Ary ny AI dia lasa "Fantatra hafa ihany") Ny URI amin'ny singa Camel dia toa toy izao: langchain4j-chat:chatId?chatModel=#beanName&chatOperation=OPERATION ChatId dia tsy misy afa-tsy ny identifier chatModel=#chatModel mifandray amin'ny bean ao amin'ny fisoratana anarana Camel Ny chatOperation dia manara-maso ny fitondran-tena 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; } } } Nahoana ny fomba fiasan'i Camel dia mahasoa Camel dia manome anao (Integration Patterns Enterprise) izay mifanaraka tsara amin'ny AI: EIPs Content Enricher amin'ny RAG Mifanohitra amin'ny LLM Resilience Ny fanaraha-maso ny vidiny Dead letter fantsona → tsy fahombiazan'ny routing Ny fahazoan-dalana dia tsy mandrindra ny fangatahana mitovy indray mandeha Tsy mila rafitra vaovao ianao, fa mampiasa indray ny endriky ny integration. dingana 6: Bootstrapping Camel Main + mihazakazaka 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); } } Mihazakazaka izany Mamorona + mihazakazaka ny fampisehoana rehetra (mock mode) ./gradlew clean test ./gradlew run Mandeha amin'ny demo ./gradlew run --args="prompt" ./gradlew run --args="rag-enrich" Ampiasao ny modely OpenAI Ny safidy A (ny fananana): app.mode=openai openai.apiKey=sk-... Fahafahana B (manoro hevitra): fiovan'ny tontolo iainana Windows (PowerShell) setx OPENAI_API_KEY "sk-..." Avy eo ny Azonao atao ny mampiasa ny toerana: application.properties openai.apiKey=${OPENAI_API_KEY:} Ohatra Output (Mock fomba) Ho hitanao ireo horonantsary toy ny: === DEMO 1: CHAT_SINGLE_MESSAGE === Q: What is the capital of France? A: [MOCK] The capital of France is Paris. Ny fomba fanao tsara indrindra (ny zavatra ho tianao aorian'izay) 1) Tsy misy fehezan-dalàna amin'ny API Ampiasao ny habetsaky ny tontolo iainana na ny fitantanana ny tsiambaratelo. Na dia ao amin'ny demo aza, mametraka ny endrika. openai.apiKey=${OPENAI_API_KEY:} 2) Ampidiro ny fotoana sy ny fanoherana haingana Ny LLM dia antso amin'ny tambajotra. fitsaboana azy ireo toy ny fitoviana rehetra: ny fotoana, ny retries, ny fialan-tsasatra. Ao amin'ny Camel, dia mahazatra izany: Timeout() / circuitBreaker() (fampihorohoroana4j) onException() ho an'ny lalana tsy fahombiazan'ny fanaraha-maso throttle() mba hiarovana ny teti-bola sy ny fetra ambony 3) Hitandrina ny fangatahana versioned sy outsourced Ny famantarana dia “logika raharaham-barotra”. Aza mamono azy ireo toy ny taratasy amin'ny fomba am-bava. Amin'ny kely indrindra: fivarotana templates ao ary Salmona niteraka an'i Boaza tamin-dRahaba ; ary Boaza niteraka an'i Obeda tamin-dRota ; ary Obeda niteraka an'i Jese ; resources/ 4) mampiasa ny fomba mock + fitsapana mba hiarovana ny pipeline Ny LLM code dia tokony ho azo jerena tsy misy antso amin'ny tambajotra. Manome anao izany. MockChatModel Manao fanandramana ny lalana 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: Fomba roa (raha ny hampiasa izay) 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 Ny ) Content Enricher enrich Camel mitondra kontekst avy amin'ny iray na maromaro ny lalana ary mampifandray izany Dynamic retrieval, loharanom-baovao maromaro Ny kely kokoa ny code (strategia) Ny ) Header-based AUGMENTED_DATA Mifandray mivantana amin'ny fifanarahana fantatra ianao toy ny votoaty voajanahary Fifanarahana tsotra na mifandray amin'ny fifanarahana efa nahavita Tsy dia mora loatra amin'ny famerenana logic sarotra Ao amin'ny tetikasa tena izy ireo, ny RAG matetika dia miova toy izao: Manomboka amin'ny header-based (haingana, mora, azo antoka) Mandeha any amin'ny enrich() rehefa lasa workflow ny fikarohana (vector DB, fahazoan-dalana, famerenana indray) Ny fampiasana an'izao tontolo izao amin'ny ankapobeny (izay mety amin'ity endrika ity) Rehefa mahazo fifaliana ianao amin'ny Ny fahefana mitovy amin'izany: camel-langchain4j-chat Ny fandefasana ny tolotra mpanjifa (tickets → context → response) Ny fandaharam-potoana amin'ny dokam-barotra (extract → summarize → classify → route) Ny fanamafisana ny angon-drakitra (mitranga any ivelany → mampahafantatra / marika → mitohy) Ops mpanampy (logs/metrics → RAG → fitsaboana dingana) Ny fanalahidy dia Camel: efa mahalala ny fomba mifandray sy mifandray ny zava-drehetra manodidina ny antso AI. Fanapahan-kevitra: Ny fitsaboana LLM dia miantso toy ny integrations, fa tsy "Special Snowflakes" Ny fiovan'ny hevitra lehibe indrindra dia izao: Ny LLM dia tsy fampiharana. dia miankina - toy ny angon-drakitra, ny fiara, na ny API. Ny LLM dia tsy fampiharana. dia miankina - toy ny angon-drakitra, ny fiara, na ny API. Ary raha mampiasa izany amin'ny fomba toy izany ianao, dia hanorina mazava ho azy ianao: Ny fiarovana haingana kokoa. Tsara kokoa ny fitantanana ny fahadisoana. Ny fitsapana, ary ny fivoaran'ny integration izay afaka mihoatra noho ny fampisehoana.