This is an automated email from the ASF dual-hosted git repository.
davsclaus pushed a commit to branch main
in repository https://gitbox.apache.org/repos/asf/camel-website.git
The following commit(s) were added to refs/heads/main by this push:
new e842c19b chore: llms.txt - Camel CLI doc links, canonical YAML, Camel
4.23 features (#1801)
e842c19b is described below
commit e842c19bb242b5b9d6a5f4895141dbb906861a69
Author: Claus Ibsen <[email protected]>
AuthorDate: Sat Oct 3 07:32:57 2026 +0200
chore: llms.txt - Camel CLI doc links, canonical YAML, Camel 4.23 features
(#1801)
- Link every Camel CLI and TUI manual page directly instead of the CLI
landing page; fix the camel test description (Citrus) and add
camel kubernetes run, camel validate, camel run --example, camel overview.
- The YAML examples are written in the canonical form and pass
camel validate yaml --canonical; structure rules and common mistakes
updated to match.
- Align with the front page: 83,000+ commits, the three ways to start
(install.sh, Spring Initializr, Quarkus).
- Separate the two MCP servers: routes as MCP tools (camel-ai-tool +
camel-mcp-server) and the Camel CLI MCP server for coding assistants.
- New in Camel 4.23: Switch and Cache EIPs, Semantic and TypeSafe AI,
LangChain4j Ingest, AI Resource, AI Observability, OPA, OpenFGA, SPIFFE,
OData, HiveMQ, State Store, REST Postman, Alibaba Cloud, Python 3,
QuickJS, TOON, UBL.
- Metrics and health at /observe/... with camel-observability-services;
fix the Micrometer, Prometheus, Message History and Camel Karaf links.
- ACP coding agents in the TUI, GenAI observability, recent blog posts.
Signed-off-by: Claus Ibsen <[email protected]>
Co-authored-by: Claude Opus 5.5 (1M context) <[email protected]>
---
llms-txt-template.md | 123 +++++++++++++++++++++++++++++++++++++--------------
1 file changed, 91 insertions(+), 32 deletions(-)
diff --git a/llms-txt-template.md b/llms-txt-template.md
index c8688ae3..37b4d77d 100644
--- a/llms-txt-template.md
+++ b/llms-txt-template.md
@@ -1,6 +1,6 @@
# Apache Camel
-> Apache Camel is an open source integration framework with 350+ connectors
for databases, APIs, message brokers, and cloud services. Write routes in Java,
YAML, or XML. Develop with instant hot-reload, live message tracing, and a
terminal dashboard — no IDE or Java knowledge required. Deploy on Spring Boot,
Quarkus, or standalone. In production since 2007, used by thousands of
companies worldwide. 100,000+ commits, 1,500+ contributors, median 1–2 day bug
fix time. Apache License 2.0 — z [...]
+> Apache Camel is an open source integration framework with 350+ connectors
for databases, APIs, message brokers, and cloud services. Write routes in Java,
YAML, or XML. Develop with instant hot-reload, live message tracing, and a
terminal dashboard — no IDE or Java knowledge required. Deploy on Spring Boot,
Quarkus, or standalone. In production since 2007, used by thousands of
companies worldwide. 83,000+ commits, 1,500+ contributors, median 1–2 day bug
fix time. Apache License 2.0 — ze [...]
All Apache Camel documentation pages are available in LLM-friendly Markdown
format by replacing `.html` with `.md` in any URL.
For example:
@@ -44,6 +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`
- 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 a
monitoring TUI — 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)
@@ -52,10 +53,10 @@ 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: embedded MCP server (`camel mcp`) and
A2A protocol for developers, plus Wanaku enterprise MCP gateway for teams
managing many integrations at scale with governance, auth, and namespace
isolation
+- 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 enterprise MCP gateway for teams managing many integrations at scale
with governance, auth, and namespace isolation
- 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 laptop (`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-local-model [...]
+- 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 laptop (`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-local-model [...]
- Commercial support available from multiple vendors — see the commercial
support page
## Who maintains the project
@@ -83,7 +84,10 @@ The full committer list with organizational affiliations is
published at https:/
- [When to use Apache Camel](https://camel.apache.org/when-to-use/index.md):
Common use cases, real-world scenarios, when Camel fits, and when alternatives
might be better.
- [Why Apache Camel](https://camel.apache.org/trust/index.md): Why teams trust
Apache Camel in production — release cadence, LTS, security track record,
vendor-neutral governance, bug fix data, dependency maintenance, and AI
readiness.
- [Camel DNA](https://camel.apache.org/camel-dna/index.md): The origin story —
from the first JMS-to-File route in 2007 to the Camel CLI today, and why the
core idea has not changed.
-- [Getting Started](https://camel.apache.org/manual/getting-started.md): Quick
start guide for Apache Camel.
+- [Getting Started](https://camel.apache.org/manual/getting-started.md): Quick
start guide for Apache Camel. Three ways to start:
+ - Camel CLI: `curl -fsSL https://camel.apache.org/install.sh | sh`, then
`camel init hello.yaml` and `camel run hello.yaml` — see [Camel CLI Getting
Started](https://camel.apache.org/manual/camel-jbang-getting-started.md)
+ - Spring Boot: generate a project with Camel from Spring Initializr (`curl
https://start.spring.io/starter.tgz -d dependencies=camel -d type=maven-project
-d baseDir=camel-app | tar -xzf -`), then add starters for the components you
need
+ - Quarkus: add Camel extensions to a Quarkus project, for example `quarkus
ext add camel-quarkus-kafka`
- [User Manual](https://camel.apache.org/manual/index.md): Complete user guide
and reference documentation.
- [Architecture
(CamelContext)](https://camel.apache.org/manual/camelcontext.md): How Camel
works — routes, components, endpoints, processors, producers, consumers, and
the DSL.
- [Error Handling](https://camel.apache.org/manual/error-handler.md): Error
handlers, retries, dead letter channels, and exception handling in Camel routes.
@@ -111,7 +115,7 @@ Understanding these concepts is essential for generating
correct Camel routes an
Minimal, correct examples that can be run instantly with `camel run
route.yaml` (no project setup, no compilation). YAML DSL is the recommended
syntax for AI-assisted development. More examples at [Camel CLI
Examples](https://github.com/apache/camel-jbang-examples).
-**TIP:** The [Camel MCP
Server](https://camel.apache.org/manual/camel-jbang-mcp.md) can validate YAML
routes against the official JSON Schema, look up component options, and check
endpoint URIs — so AI agents can verify their generated routes are correct
before the user runs them. The examples below were all validated this way.
+**TIP:** The [Camel MCP
Server](https://camel.apache.org/manual/camel-jbang-mcp.md) can validate YAML
routes against the official JSON Schema, look up component options, and check
endpoint URIs — so AI agents can verify their generated routes are correct
before the user runs them. The examples below are written in the canonical YAML
form and pass `camel validate yaml --canonical`.
### Timer → Log (simplest possible route)
@@ -121,7 +125,9 @@ Minimal, correct examples that can be run instantly with
`camel run route.yaml`
uri: timer:tick?period=1000
steps:
- setBody:
- constant: "Hello from Camel!"
+ expression:
+ constant:
+ expression: "Hello from Camel!"
- log:
message: "${body}"
```
@@ -136,7 +142,9 @@ Minimal, correct examples that can be run instantly with
`camel run route.yaml`
- log:
message: "Processing ${header.CamelFileName}"
- transform:
- simple: "Processed: ${body}"
+ expression:
+ simple:
+ expression: "Processed: ${body}"
- to:
uri: file:data/outbox
```
@@ -150,11 +158,15 @@ Minimal, correct examples that can be run instantly with
`camel run route.yaml`
steps:
- choice:
when:
- - simple: "${header.priority} == 'high'"
+ - expression:
+ simple:
+ expression: "${header.priority} == 'high'"
steps:
- to:
uri: kafka:orders.priority
- - simple: "${header.priority} == 'low'"
+ - expression:
+ simple:
+ expression: "${header.priority} == 'low'"
steps:
- to:
uri: kafka:orders.standard
@@ -169,7 +181,8 @@ Minimal, correct examples that can be run instantly with
`camel run route.yaml`
```yaml
- onException:
handled:
- constant: "true"
+ constant:
+ expression: "true"
exception:
- java.net.ConnectException
redeliveryPolicy:
@@ -207,14 +220,18 @@ Minimal, correct examples that can be run instantly with
`camel run route.yaml`
uri: direct:hello
steps:
- setBody:
- constant: "Hello from Camel!"
+ expression:
+ constant:
+ expression: "Hello from Camel!"
- route:
from:
uri: direct:hello-name
steps:
- setBody:
- simple: "Hello ${header.name}!"
+ expression:
+ simple:
+ expression: "Hello ${header.name}!"
```
### Java DSL equivalent (Timer → Log)
@@ -235,6 +252,7 @@ The [YAML
DSL](https://camel.apache.org/components/next/others/yaml-dsl.md) is t
- Processing steps go inside `steps:` under `from:` — this is the processor
chain
- Endpoints use `uri:` with the standard Camel URI syntax:
`scheme:path?option=value`
- Expressions (`simple`, `jq`, `xpath`, `jsonpath`, `constant`) are used
inside EIPs for predicates and transformations
+- Write the **canonical form**: an expression goes under `expression:`, and
the language holds its text under `expression:` too, for example `setBody:
{expression: {simple: {expression: "Hello ${body}"}}}` and `- expression:
{simple: {expression: "${header.priority} == 'high'"}}` for a `when`. The
compact form (`setBody: {simple: "..."}`, or a top-level `- from:` without `-
route:`) still loads but is deprecated; `camel validate normalize` rewrites a
file in the canonical form, and `came [...]
- Options that look like numbers but are typed as strings in the schema (e.g.,
`redeliveryDelay`) must be quoted: `"2000"` not `2000`
### Route templates (parameterized routes)
@@ -253,7 +271,9 @@ Route templates let you define a reusable route pattern
with parameters. Use `{{
uri: "timer:{{name}}?period={{myPeriod}}"
steps:
- setBody:
- simple: "{{greeting}} ${body}"
+ expression:
+ simple:
+ expression: "{{greeting}} ${body}"
- log:
message: "${body}"
```
@@ -277,11 +297,11 @@ See [Route
Templates](https://camel.apache.org/manual/route-template.md) for the
These are the errors models make most often when writing Camel YAML, taken
from [the local model
benchmark](https://camel.apache.org/blog/2026/09/camel-local-model-benchmark/).
Since Camel 4.23 the validator and the runtime report each of them with the
correct form; before that, check for them yourself.
-- The file must be a **list** (`- route:` / `- from:`), not a map. A map loads
zero routes without an error in older releases.
+- The file must be a **list** (`- route:`), not a map. A map loads zero routes
without an error in older releases.
- Simple operators go **outside** the function braces: `${body} contains
'critical'`, not `${body contains 'critical'}`. Text outside `${...}` is a
literal, so `body contains 'critical'` is a string, not a predicate — functions
are always written as `${body}`, `${header.name}`.
- Bean methods use a dot or `?method=`: `${bean:myBean.getCount}` or
`${bean:myBean?method=getCount}`, never `${bean:myBean:getCount}` (the whole
`myBean:getCount` is looked up as the bean name).
- `onException:` and `errorHandler:` are top-level list items placed before
the routes, not steps inside a route.
-- `handled` is a predicate, not a boolean: `handled: {constant: "true"}`.
+- `handled` is a predicate, not a boolean: `handled: {constant: {expression:
"true"}}`.
- `beans:` is a list where the name is a property: `- name: myBean` followed
by `type: "#class:com.example.MyBean"`, not a map keyed by bean name.
- `mock:` is producer-only and cannot be a `from:`. To pass messages between
routes, send with `to: direct:name` and consume with `from: direct:name`.
- `xslt:`, and other steps that transform the body, need a body: on a timer
route read the input first with `poll: file:...`, `pollEnrich`, or `setBody`.
@@ -302,28 +322,48 @@ This is the recommended starting point for all
developers, including those who a
### CLI Commands — Development Lifecycle
- [Camel CLI](https://camel.apache.org/manual/camel-jbang.md): Run, develop,
test, and trace Camel routes from the command line. Zero project setup — just a
YAML file and one command.
-- [`camel dev`](https://camel.apache.org/manual/camel-jbang.md): **Hot-reload
development mode.** Edit a YAML route, save, and the running integration
updates in seconds. Live feedback loop — same experience as modern web
frameworks (Next.js, Vite). This is the fastest way to build and iterate on
integrations.
-- [`camel run`](https://camel.apache.org/manual/camel-jbang.md): Run one or
more Camel routes from YAML, Java, XML, or Groovy files. No Maven, no build
step, no project structure required.
-- [`camel trace`](https://camel.apache.org/manual/camel-jbang.md): **Live
message tracing.** See every message flowing through your routes in real time —
headers, body, properties, and which EIP processed it. Essential for debugging
and understanding message flow.
-- [`camel cmd send`](https://camel.apache.org/manual/camel-jbang.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.md): Run
integration tests directly from the CLI. Supports JUnit-style assertions, mock
endpoints, and test profiles.
-- [`camel export`](https://camel.apache.org/manual/camel-jbang.md): **Bridge
from development to production.** Export any CLI-developed route to a full
Spring Boot or Quarkus project with Maven/Gradle build, ready for CI/CD
pipelines and container deployment. Start fast with the CLI, ship to production
on an enterprise runtime.
+- [`camel dev`](https://camel.apache.org/manual/camel-jbang-running.md):
**Hot-reload development mode.** Edit a YAML route, save, and the running
integration updates in seconds. Live feedback loop — same experience as modern
web frameworks (Next.js, Vite). This is the fastest way to build and iterate on
integrations.
+- [`camel run`](https://camel.apache.org/manual/camel-jbang-running.md): Run
one or more Camel routes from YAML, Java, XML, or Groovy files. No Maven, no
build step, no project structure required.
+- [`camel trace`](https://camel.apache.org/manual/camel-jbang-managing.md):
**Live message tracing.** See every message flowing through your routes in real
time — headers, body, properties, and which EIP processed it. Essential for
debugging and understanding message flow.
+- [`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 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 Maven/Gradle build, ready for CI/CD
pipelines and container deployment. Start fast with the CLI, ship to production
on an enterprise runtime.
+
+### Camel CLI documentation pages
+
+- [Getting
Started](https://camel.apache.org/manual/camel-jbang-getting-started.md):
install the CLI (installer script or JBang), create and run a first route,
built-in examples
+- [Installation
Options](https://camel.apache.org/manual/camel-jbang-installation.md), [Camel
CLI Launcher](https://camel.apache.org/manual/camel-jbang-launcher-install.md)
and [Container Image](https://camel.apache.org/manual/camel-jbang-container.md)
+- [Running Camel](https://camel.apache.org/manual/camel-jbang-running.md): dev
mode, properties and profiles, dependencies and Maven repositories, Spring Boot
/ Quarkus / Camel Main runtimes, running a Maven project
+- [Dev Services](https://camel.apache.org/manual/camel-jbang-dev-services.md):
start databases, brokers and other services locally with `camel infra`
+- [Java Beans](https://camel.apache.org/manual/camel-jbang-beans.md), [Data
Transformation](https://camel.apache.org/manual/camel-jbang-transforming.md)
(including converting routes between YAML, XML and Java DSL)
+- [Validation](https://camel.apache.org/manual/camel-jbang-validation.md):
check routes and properties before running them with `camel validate`
+- [Development
Tools](https://camel.apache.org/manual/camel-jbang-devtools.md): send and
receive messages, scripting, JDBC data sources
+- [Debugging](https://camel.apache.org/manual/camel-jbang-debugging.md),
[Managing
Integrations](https://camel.apache.org/manual/camel-jbang-managing.md) and
[Diagnostics](https://camel.apache.org/manual/camel-jbang-diagnostics.md)
(errors, memory leaks, heap and thread dumps, SQL, Kafka)
+- [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)
+-
[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 Monitoring Dashboard
-- [Camel TUI](https://camel.apache.org/manual/camel-jbang.md): A full-featured
monitoring dashboard in the terminal. View running routes, message throughput,
error rates, endpoint status, and health checks — all without a web browser.
Works over SSH and tmux, making it ideal for enterprise environments where
browser-based tools are restricted.
+- [Camel TUI](https://camel.apache.org/manual/camel-jbang-tui.md): A
full-featured monitoring dashboard in the terminal. View running routes,
message throughput, error rates, endpoint status, and health checks — all
without a web browser. Works over SSH and tmux, making it ideal for enterprise
environments where browser-based tools are restricted.
+- 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
[...]
- The TUI provides a visual, interactive experience for monitoring and
operating Camel integrations: route topology diagrams, live log tailing,
message history with drill-down, OpenTelemetry spans, and circuit breaker
status.
- In enterprise environments, the TUI runs over SSH/tmux — giving operations
teams a secure, auditable monitoring experience with no web application to
deploy, no ports to expose, and no browser dependencies.
### AI-Assisted Development
- [Camel MCP Server](https://camel.apache.org/manual/camel-jbang-mcp.md):
Model Context Protocol server for AI coding assistants (Claude Code, GitHub
Copilot, Cursor, Gemini CLI). The MCP server gives AI agents access to the full
Camel catalog — 350+ component schemas, EIP metadata, and YAML validation — so
AI can generate correct, validated Camel routes.
+- Bring your own coding agent: the [Camel
TUI](https://camel.apache.org/manual/camel-jbang-tui-ai-agents.md) drives ACP
coding agents (Claude Code, Codex, Qwen Code, OpenCode, or any other ACP agent)
next to the running integration, and its AI panel works with hosted models or a
local model via Ollama — see [AI Providers and Local
Models](https://camel.apache.org/manual/camel-jbang-ai-providers.md).
- 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 [a twenty-run
experiment](https://camel.apache.org/blog/2026/09/camel-local-model-benchmark/),
a frontier model with `camel validate` and `camel run` as tools built 13 of 13
beginner examples from one sentence each, and a 22 GB local model on a laptop
went from 0 of 13 (bare prompt) to 12 of 13 (Camel MCP server) as Camel's
messages were improved. 99 of the 117 findings were wrong for hu [...]
### CLI Examples
-- [Camel CLI Examples](https://github.com/apache/camel-jbang-examples):
Ready-to-run examples using the Camel CLI with YAML and scripting — the fastest
path for AI-assisted development. Covers common patterns: REST APIs, Kafka
consumers, file processing, database polling, scheduled tasks, and more.
+- [Camel CLI Examples](https://github.com/apache/camel-jbang-examples):
Ready-to-run examples organised as a ladder of groups — run, transform, route,
fail well, connect, contracts and security, AI and cloud — each with a README
that says what you will see, how it works and how to build it step by step, and
a Citrus test. Run one with `camel run --example=<name>`.
### Who Is This For
@@ -355,16 +395,18 @@ 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.
- **[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`).
## Observability
- **[Health Checks](https://camel.apache.org/manual/health-check.md)** —
built-in readiness and liveness checks for routes, consumers, and components.
Integrates with Spring Boot Actuator and Quarkus health endpoints for
Kubernetes probes.
-
**[OpenTelemetry](https://camel.apache.org/components/next/others/opentelemetry.md)**
— distributed tracing. Each route and EIP creates spans automatically.
Integrates with Jaeger, Zipkin, and any OpenTelemetry-compatible backend.
--
**[Micrometer](https://camel.apache.org/components/next/others/micrometer.md)**
— metrics collection. Route-level and exchange-level metrics (throughput,
latency, error rate) automatically collected per route and processor.
--
**[Prometheus](https://camel.apache.org/components/next/others/micrometer.md)**
— Micrometer metrics are exposed via a Prometheus endpoint out of the box.
Camel Main and Quarkus expose them at `/q/metrics`, Spring Boot at
`/actuator/prometheus`. Scrape these with Prometheus and visualize in Grafana
for production monitoring of route throughput, error rates, and processing
times.
-- **[Message History](https://camel.apache.org/manual/message-history.md)** —
tracks which processors an exchange passed through. Useful for debugging
complex routes.
-- **[Camel TUI](https://camel.apache.org/manual/camel-jbang.md)** —
terminal-based monitoring dashboard with live route topology, message history,
health checks, and OpenTelemetry spans.
+-
**[Micrometer](https://camel.apache.org/components/next/micrometer-component.md)**
— metrics collection. Route-level and exchange-level metrics (throughput,
latency, error rate) automatically collected per route and processor.
+-
**[Prometheus](https://camel.apache.org/components/next/others/micrometer-prometheus.md)**
— Micrometer metrics are exposed via a Prometheus endpoint. With
[camel-observability-services](https://camel.apache.org/components/next/others/observability-services.md),
Camel Main, Spring Boot and Quarkus expose them at `/observe/metrics` (health
at `/observe/health`) on the management port. Without it, Spring Boot Actuator
uses `/actuator/prometheus` and Quarkus `/q/metrics`. Scrape these wit [...]
+- **[GenAI
Observability](https://camel.apache.org/components/next/others/ai-observability.md)**
— OpenTelemetry spans and Micrometer metrics for LLM calls (model, tokens,
latency) from the Camel AI components: OpenAI, LangChain4j and Spring AI. See
the blog posts on [the Camel CLI and
TUI](https://camel.apache.org/blog/2026/09/camel-genai-observability-jbang/)
and [Spring
Boot](https://camel.apache.org/blog/2026/09/camel-genai-observability-spring-boot/).
+- **[Message
History](https://camel.apache.org/components/next/eips/message-history.md)** —
tracks which processors an exchange passed through. Useful for debugging
complex routes.
+- **[Camel TUI](https://camel.apache.org/manual/camel-jbang-tui.md)** —
terminal-based monitoring dashboard with live route topology, message history,
health checks, and OpenTelemetry spans.
## Deployment
@@ -384,10 +426,11 @@ Both runtimes use the same Camel routes, components, and
EIPs — only the depen
### Kubernetes deployment
+- Use [`camel kubernetes
run`](https://camel.apache.org/manual/camel-jbang-kubernetes.md) to build, push
and deploy CLI-developed routes as a Spring Boot, Quarkus or Camel Main
application in one step, or `camel kubernetes export` for a Maven project with
the Kubernetes manifest (Eclipse JKube) for CI/CD
- Use `camel export` to generate a Spring Boot or Quarkus project from
CLI-developed routes, ready for containerization
- Spring Boot: standard `Dockerfile` or Jib/Buildpacks, deploy as a
Deployment/StatefulSet
- Quarkus: native image builds for minimal container size and fast startup,
ideal for scale-to-zero
-- Health checks (`/health/ready`, `/health/live`) integrate with Kubernetes
probes out of the box
+- Health checks (`/observe/health/ready`, `/observe/health/live` with
camel-observability-services) integrate with Kubernetes probes out of the box;
`camel kubernetes` configures the probes
## Components and Patterns
- [Components Index](https://camel.apache.org/components/next/index.md):
Complete list of all Camel connectors (350+).
@@ -400,6 +443,16 @@ Both runtimes use the same Camel routes, components, and
EIPs — only the depen
- [Camel Catalog
(JSON)](https://github.com/apache/camel/tree/main/catalog/camel-catalog/src/generated/resources/org/apache/camel/catalog):
Machine-readable JSON metadata for all components, EIPs, languages, and data
formats. Same data served by the Camel MCP server.
- [Other
Components](https://camel.apache.org/components/next/others/index.md):
Additional Camel components and utilities.
+### New in Camel 4.23
+
+- [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 (see [semantic decisions with
Jev](https://camel.apache.org/blog/2026/09/semantic-evaluation-system-one/) and
[semantic agent routing](https://camel.apache.org/blog/2026/10/semanti [...]
+- [LangChain4j
Ingest](https://camel.apache.org/components/next/langchain4j-ingest-component.md)
(split, embed and store documents for RAG), [AI
Resource](https://camel.apache.org/components/next/ai-resource-component.md) (a
route as a read-only AI resource), [AI
Observability](https://camel.apache.org/components/next/others/ai-observability.md).
+- Security for agents and services:
[OPA](https://camel.apache.org/components/next/opa-component.md) (Rego
policies),
[OpenFGA](https://camel.apache.org/components/next/openfga-component.md)
(relationship-based authorization),
[SPIFFE](https://camel.apache.org/components/next/spiffe-component.md)
(workload identity and rotating mutual TLS) — see [Authorizing what an AI agent
may do](https://camel.apache.org/blog/2026/09/securing-ai-agent-tools/) and
[Workload identity with SPIFFE](https: [...]
+- 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).
+
## AI Integration
Apache Camel supports two tiers of AI agent connectivity: an embedded mode for
developers and an enterprise gateway for teams managing many integrations at
scale.
@@ -408,7 +461,8 @@ Apache Camel supports two tiers of AI agent connectivity:
an embedded mode for d
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.
-- [Camel MCP Server](https://camel.apache.org/manual/camel-jbang-mcp.md):
Model Context Protocol server embedded in the Camel CLI (`camel mcp`). Serves
the full Camel catalog — 350+ component schemas, EIP metadata, and YAML
validation — so AI coding assistants (Claude Code, GitHub Copilot, Cursor,
Gemini CLI) can generate correct, validated Camel routes.
+- [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 exposes
it to any MCP client. See [Camel Routes as AI
Tools](https://camel.apache.org/blog/2026/08/camel-ai-tools-mcp-422/).
+- [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.
### Tier 2: Enterprise MCP Gateway (Wanaku)
@@ -426,6 +480,9 @@ The same Camel routes work at both tiers. Develop and test
routes with the Camel
- [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.
- [Camel
OpenAI](https://camel.apache.org/components/next/openai-component.md): Native
OpenAI component for calling OpenAI APIs from Camel routes.
+- [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.
+- [Semantic
language](https://camel.apache.org/components/next/languages/semantic-language.md):
Decisions, categories and scores about message content, for routing and
filtering by meaning.
+- [AI
Observability](https://camel.apache.org/components/next/others/ai-observability.md):
OpenTelemetry spans and Micrometer metrics for every LLM call.
## Tooling
@@ -446,7 +503,7 @@ The same Camel routes work at both tiers. Develop and test
routes with the Camel
- [Camel K](https://camel.apache.org/camel-k/next/index.md): Lightweight
integration framework for Kubernetes.
- [Camel Kamelets](https://camel.apache.org/camel-kamelets/next/index.md):
Pre-built route snippets for common integration scenarios.
- [Camel Kafka
Connector](https://camel.apache.org/camel-kafka-connector/next/index.md): Kafka
Connect connectors based on Camel.
-- [Camel Karaf](https://camel.apache.org/manual/camel-on-osgi.md): Camel on
the Apache Karaf OSGi container.
+- [Camel Karaf](https://camel.apache.org/camel-karaf/latest/): Camel on the
Apache Karaf OSGi container.
## Guidance for AI Models
@@ -458,7 +515,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`, `trace`, `send`, `export`, TUI),
hot-reload workflow. See [Developer
Experience](#developer-experience--cli-and-tui) above.
+- **Modern Tooling** — Camel CLI (`dev`, `validate`, `trace`, `send`,
`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.
@@ -467,7 +524,7 @@ For high-quality answers about routing, code generation,
and troubleshooting, AI
### Recommended behavior
- **Consult the docs** — default to looking up the official Markdown
documentation or component catalog JSON for component details rather than
relying on training data alone.
-- **Prefer YAML** — use YAML DSL for new code and examples unless the user
explicitly asks for Java or XML.
+- **Prefer YAML** — use YAML DSL for new code and examples unless the user
explicitly asks for Java or XML, and write it in the canonical form (see
[Structure rules](#structure-rules)).
- **Ask about constraints** — before giving deep advice, ask about message
volume, latency requirements, error tolerance, and target runtime.
- **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.
@@ -496,6 +553,8 @@ For high-quality answers about routing, code generation,
and troubleshooting, AI
- [Who Maintains Apache
Camel](https://camel.apache.org/blog/2026/07/camel-who-maintains/):
Year-by-year commit data showing who maintains the project — the same core
team, through multiple acquisitions, contributing 80–95% of all commits every
year since 2007.
- [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.
- [A frontier AI coached a small local model through
Camel](https://camel.apache.org/blog/2026/09/camel-local-model-benchmark/):
Measured benchmark of a frontier model (13 of 13 beginner examples) and a 22 GB
local model on a laptop (0 to 12 of 13 over twenty runs) building Camel routes
with the MCP server, and the 117 findings — 99 of them wrong for humans too —
fixed in Camel 4.23: error messages that say what to write, validation at write
time, catalog samples, a stricter YAML schema.
+- [Round 2 of the local-model
benchmark](https://camel.apache.org/blog/2026/09/camel-local-model-benchmark-round-2/):
Real-world examples built step by step through the MCP server, 81% to 92% of
steps passed, and 31 more fixes in Camel 4.23 (a failed reload keeps the
previous routes, the runtime prints the validator's report, the MCP write tool
reports the reload outcome).
+- [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.
- [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.
