This is an automated email from the ASF dual-hosted git repository. davsclaus pushed a commit to branch chore/llms-txt-refresh in repository https://gitbox.apache.org/repos/asf/camel-website.git
commit 8d8fd7c9ec998a5a34d440056adf2c2440d7bc1b Author: Claus Ibsen <[email protected]> AuthorDate: Thu Nov 19 22:53:43 2026 +0100 chore: llms.txt - remove Wanaku, add Camel 4.24 (in development), link recent blog posts - Remove Wanaku (Tier 2 governed proxy) from the AI integration section and key facts - Java 21 is the minimum from Camel 4.24 - Add a "Coming in Camel 4.24" section: faster CLI on aesh with an exit-code contract, Chaos, Test DST, Sanitizer, AI Prompt, Cedar, Semantic OpenAI/Micrometer, new connectors, removed OGNL and WASM languages - Link new CLI manual pages (exit codes, Java API, TUI ways to use AI, TUI recording) and the `camel status` command - Tooling: IDE plugins, Maven plugins, hawt.io - Link recent blog posts on testing, RAG, Camel 4.23, security advisories and CI Co-Authored-By: Claude Opus 5.5 <[email protected]> --- llms-txt-template.md | 58 +++++++++++++++++++++++++++++++++------------------- 1 file changed, 37 insertions(+), 21 deletions(-) diff --git a/llms-txt-template.md b/llms-txt-template.md index e782140e..211af71f 100644 --- a/llms-txt-template.md +++ b/llms-txt-template.md @@ -44,7 +44,7 @@ The `catalog/` JSON files contain machine-readable metadata for every connector/ - 350+ connectors included out of the box: Kafka, REST, JDBC, AWS (S3, SQS, Lambda), Azure, GCP, Salesforce, MongoDB, AMQP, FTP/SFTP, and many more - 65+ Enterprise Integration Patterns (EIPs) for routing, transformation, and error handling - Write routes in Java DSL, YAML DSL, or XML DSL — same routes, same connectors, your choice of syntax -- Install the Camel CLI with `curl -fsSL https://camel.apache.org/install.sh | sh` (needs Java 17+; Windows: `irm https://camel.apache.org/install.ps1 | iex`), or with JBang: `jbang app install camel@apache/camel` +- Install the Camel CLI with `curl -fsSL https://camel.apache.org/install.sh | sh` (needs Java 17+, and Java 21+ from Camel 4.24; Windows: `irm https://camel.apache.org/install.ps1 | iex`), or with JBang: `jbang app install camel@apache/camel` - YAML DSL + Camel CLI lets non-Java developers build integrations without writing or compiling Java - The Camel CLI gives developers a complete development experience in the terminal — hot-reload, live tracing, message sending, test execution, and the TUI developer dashboard — with zero project setup, no IDE, and no Java compilation - `camel dev` provides instant hot-reload: edit a YAML route, save, and the running integration updates in seconds — the same live-reload experience as modern web frameworks (Next.js, Vite) @@ -53,7 +53,7 @@ The `catalog/` JSON files contain machine-readable metadata for every connector/ - Spring Boot is the most popular runtime (~55% of Camel usage), Quarkus is the cloud-native option - Camel is the runtime engine behind SAP Integration Suite (Gartner iPaaS Leader) - Zero vendor lock-in — switch runtimes, clouds, or vendors without rewriting routes -- Two tiers of AI agent connectivity: Camel routes exposed as MCP tools (`camel-ai-tool` + `camel-mcp-server`) and as A2A agents for developers, plus Wanaku, a governed action proxy that sits between AI agents and backend systems and publishes Camel routes as tools under policy, identity, and audit controls +- AI agent connectivity built into the route: expose Camel routes as MCP tools (`camel-ai-tool` + `camel-mcp-server`) and as A2A agents, with workload identity, authorization policies and GenAI observability on every tool call - Supports both MCP (Model Context Protocol) and A2A (Agent-to-Agent) protocols — expose any Camel route as an AI agent tool or as an A2A agent - LangChain4j and OpenAI components for calling LLMs from Camel routes - Measured, not claimed: with the Camel CLI as tools, a frontier model built all 13 beginner examples from the Camel CLI examples repository from a one-line description each; a 22 GB local model on a 64 GB Mac mini (`qwen3.6:35b-a3b` via Ollama) went from 0 of 13 with a bare prompt to 12 of 13 with the Camel MCP server, so the catalog, validation and error messages work for small local models as well as frontier models — see [the benchmark](https://camel.apache.org/blog/2026/09/camel-loc [...] @@ -328,6 +328,7 @@ This is the recommended starting point for all developers, including those who a - [`camel cmd send`](https://camel.apache.org/manual/camel-jbang-devtools.md): Send a test message to any endpoint in a running integration. Test routes interactively without writing test code — send a message and watch it flow through `camel trace`. - [`camel test`](https://camel.apache.org/manual/camel-jbang-test.md): Run integration tests directly from the CLI with the Citrus test framework, including infrastructure services started for the test. - [`camel validate`](https://camel.apache.org/manual/camel-jbang-validation.md): Check YAML, Java and XML routes and `application.properties` against the Camel catalog before running them — endpoint options, Simple expressions, bean references, and `direct:`/`seda:` endpoints no route consumes. +- [`camel status`](https://camel.apache.org/manual/jbang-commands/camel-jbang-status.md): The state of a running integration in one call — routes, health, last errors and reload, JVM, and the end of its log. With `--json` it is the quickest way for an AI agent to check an integration (since Camel 4.24). - [`camel run --example`](https://camel.apache.org/manual/camel-jbang-getting-started.md): Run a built-in example by name; without a name it lists the examples by group, from quick start to showcase. Bundled examples run offline. - [`camel overview`](https://camel.apache.org/manual/camel-jbang-ai.md): A high-level view of a project read from its route sources — entry points, flows between routes, external systems, findings — optionally explained by an LLM into `camel-summary.md`. - [`camel export`](https://camel.apache.org/manual/camel-jbang-projects.md): **Bridge from development to production.** Export any CLI-developed route to a full Spring Boot or Quarkus project with a Maven build, ready for CI/CD pipelines and container deployment. Start fast with the CLI, ship to production on an enterprise runtime. @@ -345,12 +346,14 @@ This is the recommended starting point for all developers, including those who a - [AI Tools](https://camel.apache.org/manual/camel-jbang-ai.md) (`camel ask`, `camel explain`, `camel overview`, `camel harden`) and [AI Providers and Local Models](https://camel.apache.org/manual/camel-jbang-ai-providers.md) (Ollama and OpenAI-compatible servers) - [Export to Maven](https://camel.apache.org/manual/camel-jbang-projects.md): Spring Boot, Quarkus or Camel Main projects, plugins, version management - [Kubernetes Plugin](https://camel.apache.org/manual/camel-jbang-kubernetes.md): run your routes on Kubernetes or OpenShift with `camel kubernetes run`, or export a project with the manifest ([advanced options](https://camel.apache.org/manual/camel-jbang-kubernetes-advanced.md): traits, CronJob, Knative) +- [Exit Codes and Output](https://camel.apache.org/manual/camel-jbang-exit-codes.md): the contract scripts, CI jobs and AI agents can rely on — exit codes, errors on stderr, one JSON document on stdout with `--json`, and `--timeout` (since Camel 4.24) +- [Java API for Export and Run](https://camel.apache.org/manual/camel-jbang-java-api.md): run and export from an IDE, a visual designer or an AI agent without starting the `camel` command (since Camel 4.24, preview) - [Configuration](https://camel.apache.org/manual/camel-jbang-configuration.md), [Tips and Recipes](https://camel.apache.org/manual/camel-jbang-tips.md), [Command Reference](https://camel.apache.org/manual/jbang-commands/camel-jbang-commands.md) ### TUI — Terminal Dashboard for Developers - [Camel TUI](https://camel.apache.org/manual/camel-jbang-tui.md): A terminal dashboard for developing, prototyping and understanding Camel integrations. Browse the source with inline documentation, see the route topology, watch messages flow through each step, and check error rates, endpoint status and health checks — all without a web browser. Works in any terminal, including over SSH and tmux. -- TUI pages: [Getting Started](https://camel.apache.org/manual/camel-jbang-tui-getting-started.md), [Source Editor](https://camel.apache.org/manual/camel-jbang-tui-source-editor.md), [Diagram](https://camel.apache.org/manual/camel-jbang-tui-diagram.md), [Observing Integrations](https://camel.apache.org/manual/camel-jbang-tui-observe.md), [AI Panel](https://camel.apache.org/manual/camel-jbang-tui-ai.md), [Local Models](https://camel.apache.org/manual/camel-jbang-tui-local-models.md), [AI [...] +- TUI pages: [Getting Started](https://camel.apache.org/manual/camel-jbang-tui-getting-started.md), [Source Editor](https://camel.apache.org/manual/camel-jbang-tui-source-editor.md), [Diagram](https://camel.apache.org/manual/camel-jbang-tui-diagram.md), [Observing Integrations](https://camel.apache.org/manual/camel-jbang-tui-observe.md), [Ways to Use AI](https://camel.apache.org/manual/camel-jbang-tui-ai-ways.md), [AI Panel](https://camel.apache.org/manual/camel-jbang-tui-ai.md), [Local [...] - The TUI gives developers a visual, interactive view of the integrations they are building: route topology diagrams, live log tailing, message history with drill-down, OpenTelemetry spans, and circuit breaker status. - The TUI is a development tool. It is not for monitoring integrations in production: it has no security and no user permissions, and the developer who runs it, or an AI agent connected to it, has full control over the local integrations. For production, use the observability options below (Micrometer, Prometheus, OpenTelemetry). @@ -361,6 +364,7 @@ This is the recommended starting point for all developers, including those who a - The CLI and TUI are designed for AI pair programming. An AI coding agent can generate a YAML route, the developer runs it with `camel dev`, traces messages with `camel trace`, sends test messages with `camel cmd send` — all in the terminal, all in the same workflow. The MCP server connects the AI agent to the Camel catalog so generated routes use correct syntax and valid options. - The tooling is benchmarked against real models, and Camel is what gets fixed when a model fails. In [the local model benchmark series](https://camel.apache.org/blog/2026/10/camel-local-model-benchmark-round-4/), every message a small local model could not act on became a fix in Camel, and the fixes help humans just the same: parser, loader and runtime messages that say what to write instead of only what was wrong; Java, XSLT and XML files compiled or parsed at write time; a validator t [...] - Since Camel 4.23 every route example in the documentation (YAML, XML and Java, in the EIP, component, data format and language pages and the user manual) is checked at build time, so an example copied from the documentation is correct. The Camel MCP servers serve the same validated examples (`camel_catalog_sample`). +- Since Camel 4.24 the CLI is built for an agent that calls it 50 or 100 times per task: a command takes about 125 ms instead of more than a second, and the [exit codes and output](https://camel.apache.org/manual/camel-jbang-exit-codes.md) are a contract an agent can act on. See [The Camel CLI in Camel 4.24](https://camel.apache.org/blog/2026/11/camel-cli-424/). - Projects created with `camel export` or the Camel Maven archetypes include an `AGENTS.md` file for AI coding assistants that points to this file, the Camel CLI and the Camel MCP server. ### CLI Examples @@ -397,8 +401,11 @@ Camel provides multiple levels of error handling. Understanding when to use each - **[CamelTestSupport](https://camel.apache.org/manual/testing.md)** — base class for JUnit 5 tests. Provides a `CamelContext`, `ProducerTemplate`, and `MockEndpoint` setup out of the box. - **[Mock Component](https://camel.apache.org/components/next/mock-component.md)** — assert that endpoints receive the expected number of messages with the expected content. Use `getMockEndpoint("mock:result").expectedMessageCount(1)`. - **[AdviceWith](https://camel.apache.org/manual/advice-with.md)** — modify routes for testing without changing production code. Replace endpoints, add interceptors, or simulate errors. Essential for testing routes that talk to external systems. -- **[`camel test`](https://camel.apache.org/manual/camel-jbang-test.md)** — integration tests from the Camel CLI with the Citrus test framework, written in YAML, with infrastructure services started for the test. +- **[`camel test`](https://camel.apache.org/manual/camel-jbang-test.md)** — integration tests from the Camel CLI with the Citrus test framework, written in YAML, with infrastructure services started for the test. See [Fast and easy integration testing with the Camel CLI Test Plugin](https://camel.apache.org/blog/2026/10/camel-yaml-dsl-testing/). - **[Test Infra](https://camel.apache.org/manual/test-infra.md)** — Testcontainers-based test infrastructure for databases, message brokers, and cloud services. Use `@RegisterExtension` with service factories (e.g., `KafkaServiceFactory`, `JDBCServiceFactory`). +- **[Chaos](https://camel.apache.org/components/next/others/chaos.md)** — turn on faults in a running application during development ("fail 30% of the sends to `kafka:orders` for one minute") and get a report of how `onException`, redelivery and the dead letter channel coped; `camel cmd chaos-explore` lets an AI explore the faults by itself. Development only (since Camel 4.24). +- **[Test DST](https://camel.apache.org/components/next/others/test-dst.md)** — deterministic simulation testing for consumers: a seeded virtual-time scheduler, fault injection, invariants and seed replay (since Camel 4.24). The [Sanitizer](https://camel.apache.org/components/next/others/sanitizer.md) checks during development and tests that processors keep the `AsyncProcessor` contract and that consumer commits run exactly once. +- **[Camel Integration Testing Pitfalls](https://camel.apache.org/blog/2026/10/camel-testing-pitfalls/)** — common mistakes when testing Camel routes and how to avoid them. ## Observability @@ -447,6 +454,8 @@ Both runtimes use the same Camel routes, components, and EIPs — only the depen ### New in Camel 4.23 +See [Apache Camel 4.23 What's New](https://camel.apache.org/blog/2026/10/camel423-whatsnew/) for the full overview. + - [Switch EIP](https://camel.apache.org/components/next/eips/switch-eip.md): evaluates a selector once and dispatches to a fixed endpoint by literal value — a decision table, simpler than `choice` when every branch compares the same value. - [Cache EIP](https://camel.apache.org/components/next/eips/cache-eip.md): read-through caching of a block of steps; on a cache hit the block is skipped and the body comes from the cache. - [Semantic language](https://camel.apache.org/components/next/languages/semantic-language.md) and [TypeSafe AI](https://camel.apache.org/components/next/typesafe-ai-component.md): ask named questions about message content to get decisions, categories and scores — classify, score, validate and route by meaning. Jev, TypeSafe AI's System One model, answers these as fast, structured decisions instead of generated text, and the Wolf Defender expert detects prompt injection locally (see [sem [...] @@ -455,15 +464,26 @@ Both runtimes use the same Camel routes, components, and EIPs — only the depen - Connectors: [OData](https://camel.apache.org/components/next/odata-component.md), [HiveMQ](https://camel.apache.org/components/next/hivemq-component.md), [State Store](https://camel.apache.org/components/next/state-store-component.md) (pluggable key-value store), [REST Postman](https://camel.apache.org/components/next/rest-postman-component.md) (a Postman collection as REST contract), and Alibaba Cloud (OSS, MNS, FC, SMS, KMS, EventBridge, SLS, Tablestore). - Languages and data formats: [Python 3](https://camel.apache.org/components/next/languages/python3-language.md), [QuickJS](https://camel.apache.org/components/next/languages/quickjs-language.md) (JavaScript), [TOON](https://camel.apache.org/components/next/dataformats/toon-dataformat.md) (Token-Oriented Object Notation), [UBL](https://camel.apache.org/components/next/dataformats/ubl-dataformat.md) (UBL 2.1 business documents). +### Coming in Camel 4.24 (in development) + +The `next` documentation is the main branch, which becomes Camel 4.24. Check the [4.24 upgrade guide](https://camel.apache.org/manual/camel-4x-upgrade-guide-4_24.md) before relying on these in a released version. + +- **Java 21** is the minimum runtime version; Java 17 is no longer supported. +- **Camel CLI**: about 10 times faster per command, now built on aesh instead of picocli, with [exit codes and output](https://camel.apache.org/manual/camel-jbang-exit-codes.md) as a contract, `camel status`, `camel get timeline`, and `camel cmd reload --wait --json`. See [The Camel CLI in Camel 4.24](https://camel.apache.org/blog/2026/11/camel-cli-424/). +- **Chaos and simulation testing**: [Chaos](https://camel.apache.org/components/next/others/chaos.md), [Test DST](https://camel.apache.org/components/next/others/test-dst.md) and [Sanitizer](https://camel.apache.org/components/next/others/sanitizer.md). +- **AI**: [AI Prompt](https://camel.apache.org/components/next/ai-prompt-component.md) (a route as an MCP prompt template), [Cedar](https://camel.apache.org/components/next/cedar-component.md) (embedded authorization policies), the [OpenAI decisions expert](https://camel.apache.org/components/next/others/semantic-openai.md) and [Semantic Micrometer](https://camel.apache.org/components/next/others/semantic-micrometer.md) for the Semantic language. +- **Connectors**: [Apicurio Registry](https://camel.apache.org/components/next/apicurio-registry-component.md), [AWS Parameter Store](https://camel.apache.org/components/next/aws-parameter-store-component.md), [Azure Event Grid](https://camel.apache.org/components/next/azure-eventgrid-component.md), [Azure IoT Hub](https://camel.apache.org/components/next/azure-iothub-component.md), [Hibernate](https://camel.apache.org/components/next/hibernate-component.md), [MTConnect](https://camel.ap [...] +- **Removed**: the OGNL and WASM languages. `camel-observability-services` and `camel-lra` are promoted to Stable; `camel-openstack` is deprecated. + ## AI Integration -Apache Camel supports two tiers of AI agent connectivity: an embedded mode, where the Camel route itself exposes, identifies, authorizes and observes every agent tool call, and a governed proxy (Wanaku) in front of many routes across teams. +Camel routes connect to AI agents directly: the route itself exposes, identifies, authorizes and observes every agent tool call. -### Tier 1: Embedded AI protocols (developer mode) +### Embedded AI protocols Expose Camel routes as AI agent tools directly from the Camel process — one command, zero infrastructure. This is the fastest way to make an integration AI-accessible. -- [AI Tool](https://camel.apache.org/components/next/ai-tool-component.md) and [MCP Server component](https://camel.apache.org/components/next/others/mcp-server.md): define a tool once as a Camel route (`from: ai-tool:...`) and it works with LangChain4j, Spring AI and OpenAI; tag it and the built-in MCP server (Stable since Camel 4.22, configured with `camel.server.mcp-*` properties) exposes it to any MCP client. A tool can return structured output (`outputSchema`), and the [AI Resource] [...] +- [AI Tool](https://camel.apache.org/components/next/ai-tool-component.md) and [MCP Server component](https://camel.apache.org/components/next/others/mcp-server.md): define a tool once as a Camel route (`from: ai-tool:...`) and it works with LangChain4j, Spring AI and OpenAI; tag it and the built-in MCP server (Stable since Camel 4.22, configured with `camel.server.mcp-*` properties) exposes it to any MCP client. A tool can return structured output (`outputSchema`), and the [AI Resource] [...] - [Camel MCP Server for coding assistants](https://camel.apache.org/manual/camel-jbang-mcp.md): a different MCP server, in the Camel CLI (`camel mcp`), for building integrations: it serves the Camel catalog — 350+ component schemas, EIP metadata, validated samples and YAML validation — so AI coding assistants (Claude Code, GitHub Copilot, Cursor, Gemini CLI) can generate correct, validated Camel routes. - [Camel A2A](https://camel.apache.org/components/next/a2a-component.md): Agent-to-Agent (A2A) protocol component — expose Camel routes as A2A agents or call remote A2A agents. Supports HTTP+JSON and JSONRPC bindings, OAuth/OIDC/API-key auth, and SSE streaming. @@ -472,26 +492,17 @@ Expose Camel routes as AI agent tools directly from the Camel process — one co The model is not a security boundary, so the decision about what an agent may do sits below it, on the tool call itself, evaluated in-process by the Camel route that does the work. No extra gateway is needed for this. - **Who is calling:** [SPIFFE](https://camel.apache.org/components/next/spiffe-component.md) gives every workload a cryptographic identity from the local SPIRE agent, plus rotating mutual TLS for the components that already support TLS. See [Workload identity with SPIFFE and SPIRE](https://camel.apache.org/blog/2026/09/camel-spiffe-workload-identity/). -- **What they may do:** set an `authorizationPolicy` on an `ai-tool:` route and every tool call is authorized before it runs; a denied call is returned to the model as a short refusal it can relay. Policies with [Open Policy Agent](https://camel.apache.org/components/next/opa-component.md) (Rego) or [OpenFGA](https://camel.apache.org/components/next/openfga-component.md) (relationship-based). See [Authorizing what an AI agent may do](https://camel.apache.org/blog/2026/09/securing-ai-agen [...] +- **What they may do:** set an `authorizationPolicy` on an `ai-tool:` route and every tool call is authorized before it runs; a denied call is returned to the model as a short refusal it can relay. Policies with [Open Policy Agent](https://camel.apache.org/components/next/opa-component.md) (Rego) [OpenFGA](https://camel.apache.org/components/next/openfga-component.md) (relationship-based), or, from Camel 4.24, embedded [Cedar](https://camel.apache.org/components/next/cedar-component.md) [...] - **Fast guard decisions:** the [Semantic language](https://camel.apache.org/components/next/languages/semantic-language.md) with Jev, a System One model ([TypeSafe AI](https://camel.apache.org/components/next/typesafe-ai-component.md)) checks whether an action fits the approved task, or scores a contribution, as a yes/no, category or score inside `choice`, `switch` or `filter`. [Wolf Defender](https://camel.apache.org/components/next/others/semantic-wolf-defender.md) detects prompt inje [...] - **What happened:** [AI Observability](https://camel.apache.org/components/next/others/ai-observability.md) records OpenTelemetry GenAI spans and Micrometer metrics for every LLM call, next to the route's own traces. `camel run --observe` adds it automatically when a route uses AI components. See [Observe your Camel AI routes](https://camel.apache.org/blog/2026/09/camel-genai-observability-jbang/). -### Tier 2: Governed agent access (Wanaku) - -When AI agents must never reach backend systems directly, and every tool call needs policy, identity, and audit enforced in between, put a governed proxy in front of your Camel routes. - -- [Wanaku](https://wanaku.ai/): A governed action proxy for AI agents (formerly the Wanaku MCP Router). It sits between agents and the systems they act on, intercepting MCP tool calls, agent-to-agent messages, and inference traffic. Policy evaluators, authentication and authorization, namespace isolation per team or tenant, and an admin dashboard. Apache License 2.0. -- [Integration Capability for Apache Camel](https://github.com/wanaku-ai/camel-integration-capability): Publishes Camel routes as tools through Wanaku. It runs the routes with Camel's built-in MCP server, so routes using the `ai-tool:` URI become tools that agents call through the proxy. - -The same `ai-tool:` routes work at both tiers. Develop and test them with the Camel CLI (Tier 1), then publish them through Wanaku (Tier 2) when agents need governed access. - ### AI components - [AI Patterns](https://camel.apache.org/components/next/eips/ai-patterns.md): Common AI and modern design pattern terms mapped to Camel EIPs — fan-out, scatter-gather, circuit breaker, retry, tokenize, and more. - [Camel LangChain4j](https://camel.apache.org/components/next/langchain4j-chat-component.md): LLM integration via LangChain4j — connect Camel routes to large language models. The [LangChain4j Agent](https://camel.apache.org/components/next/langchain4j-agent-component.md) component adds tool calling, moderation and tool-calling limits. Models can be configured with properties only, for example `camel.component.langchain4j-agent.provider=ollama` with `modelName` and `baseUrl`. - [LLM (OpenAI-compatible)](https://camel.apache.org/components/next/openai-component.md): the `llm:` component (with `openai:` as an alias) for OpenAI and any OpenAI-compatible API, such as OpenRouter, Ollama, vLLM and LM Studio. It also covers moderation (block a flagged message before it reaches the model), the [Batch API](https://camel.apache.org/components/next/others/openai-batch.md) (asynchronous, at half the price), the Responses API with hosted tools, MCP tool calling with a tok [...] - [Spring AI](https://camel.apache.org/components/next/spring-ai-chat-component.md): chat, embeddings, image and vector store components on Spring AI 2.0 (Spring Boot 4.1). -- [LangChain4j Ingest](https://camel.apache.org/components/next/langchain4j-ingest-component.md): Split, embed and store documents into an embedding store for retrieval-augmented generation. +- [LangChain4j Ingest](https://camel.apache.org/components/next/langchain4j-ingest-component.md): Split, embed and store documents into an embedding store for retrieval-augmented generation. See [Document Ingestion for RAG in Camel 4.23](https://camel.apache.org/blog/2026/11/camel-document-ingestion-rag/) and [Building an Agentic RAG Application with Apache Camel and LangChain4j](https://camel.apache.org/blog/2026/10/agentic-rag-apache-camel/). - [Semantic language](https://camel.apache.org/components/next/languages/semantic-language.md): Decisions, categories, scores and labels about message content, for routing and filtering by meaning. See the next section. - [AI Observability](https://camel.apache.org/components/next/others/ai-observability.md): OpenTelemetry spans and Micrometer metrics for every LLM call. @@ -502,7 +513,7 @@ A System One model gives fast, structured decisions instead of generated text: g - Declare named evaluations once: a yes/no decision, a choice of category, a score, or a set of labels. Use them wherever Camel accepts an expression or predicate: `choice`, `filter`, `switch`, `validate`, aggregate correlation and completion, `recipientList`, `loop`, and `onException` `retryWhile`. - Use an evaluation with `ref:name` in the semantic language, or with `${semantic('name')}` in Simple. `refs:a,b,c` asks several questions in one call and returns a map of named answers; the result metadata, including the probabilities, is in `CamelSemanticResults`. - Each evaluation names an *expert*: a pluggable adapter, registered as a bean. An expert is a configured evaluator, not an autonomous agent. [TypeSafe AI](https://camel.apache.org/components/next/typesafe-ai-component.md) asks Jev (yes/no, choice and score questions, with probabilities; set `camel.component.typesafe-ai.api-key`). [Wolf Defender](https://camel.apache.org/components/next/others/semantic-wolf-defender.md) detects prompt injection and jailbreak attempts locally on the CPU, [...] -- Decisions can be audited (opt-in): `camel semantic audit`, the developer console, and the Semantic tab in the Camel TUI. +- Decisions can be audited (opt-in): `camel semantic audit`, the developer console, and the Semantic tab in the Camel TUI. From Camel 4.24, `camel semantic monitoring` and [Semantic Micrometer](https://camel.apache.org/components/next/others/semantic-micrometer.md) export the measurements as metrics. - Version notes: the YAML syntax changed during 4.23 (`question:` became `evaluation:`). From 4.24 every evaluation must name its `expert` (the `semantic:` block no longer sets a default), and the providers move to `camel-semantic-typesafe-ai` and `camel-semantic-wolf-defender` (in 4.23: `camel-typesafe-ai` and `camel-wolf-defender`). The example below works in both versions. ```yaml @@ -551,7 +562,10 @@ See [semantic decisions with Jev](https://camel.apache.org/blog/2026/09/semantic - [Tooling Overview](https://camel.apache.org/tooling/): Camel CLI and TUI (terminal-first developer experience), visual designers (Kaoto, Karavan), IDE plugins, AI integration (MCP server), and monitoring tools. - [Kaoto](https://kaoto.io): Open source visual designer for Camel routes — drag-and-drop, no code required. - [Karavan](https://github.com/apache/camel-karavan): Visual designer for Camel integrations in VS Code and as a standalone application. +- IDE plugins: the [Apache Camel IDEA Plugin](https://github.com/camel-tooling/camel-idea-plugin) for IntelliJ IDEA and the [VS Code Extension Pack for Camel](https://marketplace.visualstudio.com/items?itemName=redhat.apache-camel-extension-pack), both with route debugging. +- Maven plugins: the [Camel Maven Plugin](https://camel.apache.org/manual/camel-maven-plugin.md) (`camel:run`, `camel:dev` with hot-reload), the [Camel Report Maven Plugin](https://camel.apache.org/manual/camel-report-maven-plugin.md) (validates endpoint URIs and Simple expressions, route coverage), and the [REST DSL OpenAPI plugin](https://camel.apache.org/manual/rest-dsl-openapi.md) (contract-first REST). - [Camel Monitor Operator](https://camel-tooling.github.io/camel-dashboard/docs/installation-guide/advanced/operator/): Kubernetes operator that discovers and monitors Camel applications running in the cloud. Lightweight dashboard with Prometheus integration. +- [hawt.io](https://hawt.io): Web console for visualizing, managing and tracing Camel routes and endpoints, JMX, and more. ## Examples @@ -578,7 +592,7 @@ For high-quality answers about routing, code generation, and troubleshooting, AI - **Message Model** — Exchange, headers vs. properties vs. variables, type conversion, data formats. See [Core Concepts](#core-concepts) above. - **Expression Languages** — especially the [Simple language](https://camel.apache.org/components/next/languages/simple-language.md), the most commonly used expression language in Camel routes. - **Resilience and Error Handling** — redelivery policies, dead letter channels, circuit breakers, compensation. See [Error Handling](https://camel.apache.org/manual/error-handler.md). -- **Modern Tooling** — Camel CLI (`dev`, `validate`, `trace`, `send`, `export`, `kubernetes`, TUI), hot-reload workflow. See [Developer Experience](#developer-experience--cli-and-tui) above. +- **Modern Tooling** — Camel CLI (`dev`, `validate`, `trace`, `send`, `status`, `export`, `kubernetes`, TUI), hot-reload workflow. See [Developer Experience](#developer-experience--cli-and-tui) above. - **Runtimes** — embedding in Spring Boot vs. Quarkus (native compilation, dev mode, starters). See [Runtimes](#runtimes) above. - **Testing and Observability** — mock endpoints, tracing, OpenTelemetry integration. See [Testing](https://camel.apache.org/manual/testing.md). - **AI Features** — MCP/A2A protocols, LLM components, exposing routes as AI agent tools. See [AI Integration](#ai-integration) above. @@ -592,6 +606,7 @@ For high-quality answers about routing, code generation, and troubleshooting, AI - **Warn on version-specific features** — if a feature was introduced in a specific Camel version (e.g., variables in 4.4, route templates in 3.x), mention the version requirement. - **Validate generated routes** — use the [Camel MCP Server](https://camel.apache.org/manual/camel-jbang-mcp.md) or the [YAML DSL JSON Schema](https://github.com/apache/camel/blob/main/dsl/camel-yaml-dsl/camel-yaml-dsl/src/generated/resources/schema/camelYamlDsl-canonical.json) to verify generated YAML routes are structurally correct. - **Start from a sample, not from memory** — the Camel MCP server's catalog returns a validated YAML sample for any EIP or component by name. Fetch it before writing an EIP you have not used in this session; it is faster than a refused write and a guess. +- **Trust the exit code** — since Camel 4.24, Camel CLI commands follow the [exit codes and output](https://camel.apache.org/manual/camel-jbang-exit-codes.md) contract: act on the exit code, read stdout as data (one JSON document with `--json`), and pass `--timeout` to commands that talk to a running integration. - **Apply the error message literally** — since Camel 4.23, validator, Simple parser and runtime messages state the correct form (e.g. "Operators go outside the function: `${body} contains 'critical'`"). Write exactly what the message says rather than a variation of it, then re-validate. See [Common mistakes](#common-mistakes) above. ## Sitemaps @@ -617,7 +632,8 @@ For high-quality answers about routing, code generation, and troubleshooting, AI - [Apache Camel Is Not Afraid of AI](https://camel.apache.org/blog/2026/07/camel-not-afraid-of-ai/): The project pointed a frontier AI model at 19 years of code and fixed all 165 bugs it found — concurrency races, silent data loss, security gaps. AI-assisted code review is now a standard part of the development process. - [The local model benchmark series](https://camel.apache.org/blog/2026/10/camel-local-model-benchmark-round-4/): Four rounds (September–October 2026) of a frontier model coaching a local model on a 64 GB Mac mini through Camel, where every failure became a fix in Camel: beginner examples (0 to 12 of 13), real-world examples built step by step (81% to 92% of steps), Kamelets (1 of 15 to 47 of 50 steps), and intermediate examples with Kafka, JMS, REST and an LLM (37% to 64% in three night [...] - [The Camel website, rebuilt for humans and for AI](https://camel.apache.org/blog/2026/09/camel-website-rebuilt/): Why every page has a Markdown mirror and an offline bundle, and how the site gets a person or an AI agent to a running route. -- [Built to Patch Fast](https://camel.apache.org/blog/2026/07/camel-security-advisories-4.21.0/): How the project handled 32 CVEs in one release — the timeline, the backport process, incomplete fixes re-issued as new CVEs, and 31 public PoC reproducers. The best single-page overview of Camel's security response in practice. +- [Built to Patch Fast](https://camel.apache.org/blog/2026/07/camel-security-advisories-4.21.0/): How the project handled 32 CVEs in one release — the timeline, the backport process, incomplete fixes re-issued as new CVEs, and 31 public PoC reproducers. The best single-page overview of Camel's security response in practice. The latest round: [38 CVEs fixed in 4.18.5, 4.22.1 and 4.23.0](https://camel.apache.org/blog/2026/10/camel-security-advisories-4.23.0/). +- [Scaling the Apache Camel Core CI](https://camel.apache.org/blog/2026/11/camel-core-ci-improvements/): How the core CI went from a few green builds a year to reliable, faster feedback on every pull request. - [Security](https://camel.apache.org/security/): Security advisories and vulnerability reports. - [Security Model](https://camel.apache.org/manual/security-model.md): Apache Camel's built-in security model — route policy, payload validation, and how Camel protects against injection and untrusted input. - [Generating SBOMs](https://camel.apache.org/manual/sbom.html): How to generate Software Bill of Materials for Camel applications — Camel CLI, Spring Boot (built-in), and Quarkus. Every release since 4.0.3 ships with signed CycloneDX SBOMs.
