LLM sebagai Endpoints Integrasi: Membangun Rute Camel Apache dengan LangChain4j Chat

Membangun fitur AI sederhana sampai Anda perlu mengintegrasikannya ke dalam sistem produksi. Dalam produksi, 'call a LLM' sederhana sering menjadi: Menggunakan HTTP / JMS / Kafka / File Input Menerapkan waktu, retreats, fallbacks menguraikan konteks yang diperoleh dari sumber data internal, Untuk melindungi rahasia, Agar dapat diuji tanpa membakar kredit API, dan memastikan sistem dapat diamati ketika masalah terjadi di malam hari. Dengan Camel 4.5 dan lebih baru, Anda dapat menangani panggilan LLM sebagai titik akhir integrasi standar menggunakan camel-langchain4j-chat, yang didukung oleh LangChain4j. Dalam tutorial ini, Anda akan membangun proyek Java 21 dan Gradle yang menunjukkan: Chat dengan pesan tunggal (Single Message Chat) Prompt template + variabel (CHAT_SINGLE_MESSAGE_WITH_PROMPT) Sejarah Chat (CHAT_MULTIPLE_MESSAGES) RAG dengan Content Enricher Camel (EIP + Aggregator Strategy) RAG melalui headers (pendekatan “inject context” sederhana) Mode mock sehingga semuanya berjalan di CI tanpa kunci API. Anda akan menyelesaikan dengan proyek yang dapat digunakan kembali sebagai dasar untuk aliran integrasi nyata, tanpa mengubah basis kode Anda menjadi "pabrik spaghetti cepat". Apa yang kita bangun Sebuah aplikasi CLI kecil yang dapat dijalankan yang memulai Camel Main (tidak diperlukan Spring) dan menjalankan lima demo: tunggal Cepat Sejarah Teman-teman Enri Pemimpin Header Anda dapat menjalankan mereka semua atau satu per satu dari baris perintah. Persyaratan Jawa 21 Pengetahuan dasar Apache Camel (routes, direct: endpoints, ProducerTemplate) Optional: OpenAI API key (tutorial berjalan sepenuhnya tanpa itu) Arsitektur dalam Satu Gambar Berikut adalah model mental: Untuk RAG, Camel memperkaya pertukaran sebelum memanggil LLM: Proyek Setup Teknologi Stack Jawa 21 Spesifikasi Apache Camel 4.17.0 LangChain4j 1.10.0 dari Kelompok 8.x OpenAI GPT-4o-mini (opsi) Struktur 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 Langkah 1: Mengatur menciptakan : 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() } dan : settings.gradle rootProject.name = 'camel-langchain4j-chat-demo' Langkah 2: Konfigurasi dan 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

Langkah 3: Produksi ramah “Mock Mode” (Tidak diperlukan API Key) Jika Anda ingin ini lebih dari sekedar demo mainan, Anda membutuhkan cara untuk melakukannya tanpa ketergantungan eksternal. Itulah sebabnya kami menerapkan 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(); } } Mengapa ini penting dalam produksi: CI / CD berjalan tidak memerlukan LLM. Unit pengujian stabil. Insinyur dapat bekerja secara offline. Anda dapat memvalidasi logika aliran (routing, RAG, template) sebelum menghabiskan uang. Langkah 4: Memilih Model di Runtime (OpenAI atau 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(); } } } Langkah 5: The Camel Routes (Di mana AI menjadi “Just Another Endpoint”) Komponen URI Camel terlihat seperti: langchain4j-chat:chatId?chatModel=#beanName&chatOperation=OPERATION ChatID hanyalah pengidentifikasi chatModel=#chatModel merujuk ke bean di registri Camel ChatOperasi mengendalikan perilaku 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; } } } Mengapa pendekatan Camel berguna Camel memberikan (Enterprise Integration Patterns) yang berlaku dengan indah untuk AI: EIPs Content Enricher dari RAG Pemblokiran sirkuit → Resilience LLM Pengendalian dan pengendalian biaya Dead Letter Channel → Routing gagal Idempotency: Jangan memproses permintaan yang sama dua kali Anda tidak membutuhkan arsitektur baru. Anda menggunakan kembali pola integrasi yang telah terbukti. Langkah 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); } } berlari itu Build + Run semua demo (mock mode) ./gradlew clean test ./gradlew run Menggunakan 1 Demo ./gradlew run --args="prompt" ./gradlew run --args="rag-enrich" Mengaktifkan mode OpenAI Pilihan A (property): app.mode=openai openai.apiKey=sk-... Opsi B (disarankan): variabel lingkungan Windows (PowerShell) setx OPENAI_API_KEY "sk-..." Kemudian dalam Anda dapat menggunakan tempat duduk: application.properties openai.apiKey=${OPENAI_API_KEY:} Contoh Output (Mock Mode) Anda akan melihat log seperti: === DEMO 1: CHAT_SINGLE_MESSAGE === Q: What is the capital of France? A: [MOCK] The capital of France is Paris. Praktek terbaik (Sesuatu yang akan Anda nikmati nanti) 1) Jangan pernah menggunakan hardcode API Gunakan variabel lingkungan atau pengelola rahasia. bahkan dalam demo, tetapkan pola. openai.apiKey=${OPENAI_API_KEY:} 2) Menambahkan timeout dan resiliensi lebih awal LLM adalah panggilan jaringan. perlakukan mereka seperti ketergantungan apa pun: timeout, retries, fallback. Di Camel, ini biasanya menjadi: timeout() / circuitBreaker() (Resilience4j) onException() untuk jalur kegagalan terkontrol throttle() untuk melindungi anggaran dan batas atas 3) Menjaga prompts versi dan eksternal Prompts adalah “logika bisnis”. jangan mengubur mereka sebagai string dalam metode acak. Setidaknya: toko template di dan mengunggah mereka, atau mengelola mereka sebagai aset versi. resources/ 4) Gunakan mode mock + tes untuk melindungi pipa Anda Kode LLM Anda harus dapat diuji tanpa panggilan jaringan. memberikan kepadamu MockChatModel Unit yang menguji rute 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: Dua Pendekatan (Kapan Gunakan Mana) 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 (Dengan ) Content Enricher enrich Camel menarik konteks dari satu atau lebih rute dan menggabungkannya Dynamic retrieval, banyak sumber Sedikit lebih banyak kode (strategi) (Dengan ) Header-based AUGMENTED_DATA Anda secara langsung menempelkan konteks yang diketahui sebagai konten terstruktur Konteks statik sederhana atau konteks yang sudah dipulihkan Kurang fleksibel untuk logika retrieval yang kompleks Dalam proyek nyata, RAG sering berkembang seperti ini: Mulai dengan berbasis header (cepat, mudah, dapat diprediksi) Pindah ke enrich() ketika pencarian menjadi alur kerja (vector DB, izin, reranking) Kasus penggunaan dunia nyata (di mana pola ini cocok) Jika Anda merasa nyaman dengan Kekuatan struktur yang sama: camel-langchain4j-chat Routing dukungan pelanggan (tickets → context → response) Pipa dokumen (ekstrak → meringkas → mengklasifikasikan → rute) Data memperkaya (peristiwa masuk → menjelaskan/label → bertahan) Asisten Ops (log / metrik → RAG → langkah perbaikan) Kunci adalah Camel: ia sudah tahu bagaimana menghubungkan dan mengoreksi segala sesuatu di sekitar panggilan AI. Kesimpulan: Memperlakukan LLM memanggil seperti integrasi, bukan "Special Snowflakes" Perubahan pikiran terbesar adalah ini: Itu adalah ketergantungan – seperti database, barisan, atau API. Itu adalah ketergantungan – seperti database, barisan, atau API. Dan jika Anda memperlakukannya dengan cara itu, Anda akan secara alami membangun: dengan cepat lebih aman, Mengatasi kesalahan yang lebih baik, Untuk pengujian, dan aliran integrasi yang dapat melampaui demos.