Camel MCP Server

The Camel MCP Server exposes the Apache Camel Catalog and a set of specialized tools through the Model Context Protocol (MCP), the open standard that allows AI coding assistants to call external tools. This enables AI tools such as Claude Code, OpenAI Codex, GitHub Copilot, and JetBrains AI to query live Camel catalog data, validate endpoint URIs, analyze routes for security concerns, browse Kamelets, and more.

The server is built on Quarkus using the quarkus-mcp-server extension and ships as a single uber-JAR that can be launched via JBang.

This module is in Preview status as of Camel 4.18.

Transport

The server supports two transports:

STDIO — The default transport for CLI-based AI tools. The server communicates over stdin/stdout using the MCP protocol. All logging goes to stderr to keep stdout clean for protocol messages.
HTTP/SSE — An optional transport for web-based clients and remote access scenarios. Useful when running the MCP server as a shared service for a team or in a container. Two protocol variants are supported:
- SSE (protocol version 2024-11-05) — The legacy HTTP/SSE transport. The client opens a Server-Sent Events stream at /mcp/sse and receives a message endpoint URL. All subsequent JSON-RPC requests are POSTed to that endpoint, and responses are delivered through the SSE stream.
- Streamable HTTP (protocol version 2025-03-26) — The newer single-endpoint transport. All JSON-RPC messages are POSTed to /mcp and responses are returned inline in the HTTP response body. This is simpler to use and is the recommended variant for new integrations.

By default, the HTTP server is disabled. To enable it, set quarkus.http.host-enabled=true.

The MCP server does not expose REST endpoints. You cannot query tools or resources with plain HTTP GET requests (e.g., curl http://localhost:8080/mcp/tools will return a 404). All communication uses JSON-RPC messages over the MCP protocol.

Available Tools

The server exposes 30 catalog tools organized into twelve functional areas, 21 runtime introspection tools for inspecting and interacting with live Camel processes, plus 3 prompts that provide structured multi-step workflows.

Catalog Exploration

Tool Description

Tool	Description
`camel_catalog_components`	List available Camel components with filtering by name, label (e.g., `messaging`, `cloud`, `database`), and runtime type (`main`, `spring-boot`, `quarkus`). Supports querying specific Camel versions.
`camel_catalog_component_doc`	Get documentation for a specific component: URI syntax, component-level and endpoint options. Supports `optionsFilter` (case-insensitive substring on option name) and `includeOptions` (`required`, `common`, or `all`; default `common`, which excludes deprecated and advanced options) to control payload size.
`camel_catalog_component_maven`	Get the Maven coordinates (`groupId`, `artifactId`, `version`) of a specific component, for adding it as a project dependency.
`camel_catalog_dataformats`	List available data formats (JSON, XML, CSV, Avro, Protobuf, and others).
`camel_catalog_dataformat_doc`	Get detailed documentation for a specific data format including all configuration options, Maven coordinates, and model information.
`camel_catalog_languages`	List expression languages (Simple, JsonPath, XPath, JQ, Groovy, and others).
`camel_catalog_language_doc`	Get detailed documentation for a specific expression language including all configuration options and Maven coordinates.
`camel_catalog_eips`	List Enterprise Integration Patterns with filtering by category.
`camel_catalog_eip_doc`	Get detailed documentation for a specific EIP including all its options.

camel_catalog_components

List available Camel components with filtering by name, label (e.g., messaging, cloud, database), and runtime type (main, spring-boot, quarkus). Supports querying specific Camel versions.

camel_catalog_component_doc

Get documentation for a specific component: URI syntax, component-level and endpoint options. Supports optionsFilter (case-insensitive substring on option name) and includeOptions (required, common, or all; default common, which excludes deprecated and advanced options) to control payload size.

camel_catalog_component_maven

Get the Maven coordinates (groupId, artifactId, version) of a specific component, for adding it as a project dependency.

camel_catalog_dataformats

List available data formats (JSON, XML, CSV, Avro, Protobuf, and others).

camel_catalog_dataformat_doc

Get detailed documentation for a specific data format including all configuration options, Maven coordinates, and model information.

camel_catalog_languages

List expression languages (Simple, JsonPath, XPath, JQ, Groovy, and others).

camel_catalog_language_doc

Get detailed documentation for a specific expression language including all configuration options and Maven coordinates.

camel_catalog_eips

List Enterprise Integration Patterns with filtering by category.

camel_catalog_eip_doc

Get detailed documentation for a specific EIP including all its options.

Kamelet Catalog

Tool Description

Tool	Description
`camel_catalog_kamelets`	List available Kamelets from the Kamelet Catalog with filtering by name, description, and type (`source`, `sink`, `action`). Supports querying specific Kamelets catalog versions.
`camel_catalog_kamelet_doc`	Get detailed documentation for a specific Kamelet including all properties/options, their types, defaults, examples, and the Kamelet’s Maven dependencies.

camel_catalog_kamelets

List available Kamelets from the Kamelet Catalog with filtering by name, description, and type (source, sink, action). Supports querying specific Kamelets catalog versions.

camel_catalog_kamelet_doc

Get detailed documentation for a specific Kamelet including all properties/options, their types, defaults, examples, and the Kamelet’s Maven dependencies.

Example Catalog

Tool Description

Tool	Description
`camel_catalog_examples`	List available Camel JBang examples with filtering by name, description, or tag (case-insensitive substring match). Supports filtering by difficulty level (`beginner`, `intermediate`, `advanced`) and limiting the number of results. Returns name, title, description, level, tags, and file list for each example.
`camel_catalog_example_file`	Get the content of a specific file from a Camel JBang example. For bundled examples, returns the file content directly. For non-bundled examples, returns a GitHub URL where the file can be found. Use `camel_catalog_examples` first to discover example names and their files.

camel_catalog_examples

List available Camel JBang examples with filtering by name, description, or tag (case-insensitive substring match). Supports filtering by difficulty level (beginner, intermediate, advanced) and limiting the number of results. Returns name, title, description, level, tags, and file list for each example.

camel_catalog_example_file

Get the content of a specific file from a Camel JBang example. For bundled examples, returns the file content directly. For non-bundled examples, returns a GitHub URL where the file can be found. Use camel_catalog_examples first to discover example names and their files.

Route Understanding

Tool Description

Tool	Description
`camel_route_context`	Given a Camel route (YAML, XML, or Java DSL), extracts all components and EIPs used, looks up their documentation from the catalog, and returns structured context.

camel_route_context

Given a Camel route (YAML, XML, or Java DSL), extracts all components and EIPs used, looks up their documentation from the catalog, and returns structured context.

Test Scaffolding

Tool Description

Tool	Description
`camel_route_test_scaffold`	Generates a JUnit 5 test skeleton from a Camel route definition (YAML or XML). Accepts an optional `format` (`yaml` or `xml`, default `yaml`) and `runtime` (`main` or `spring-boot`, default `main`). For `main` runtime, the generated test extends `CamelTestSupport`; for `spring-boot`, it uses `@CamelSpringBootTest` with `@SpringBootTest`. The tool replaces non-trivial producer endpoints with mock endpoints, generates `@RegisterExtension` stubs for infrastructure components (Kafka, JMS/Artemis, MongoDB, PostgreSQL, Cassandra, Elasticsearch, Redis, RabbitMQ, FTP, Consul, NATS, Pulsar, CouchDB, Infinispan, MinIO, Solr), and produces a `NotifyBuilder` pattern for timer-based routes or `template.sendBody()` for direct/seda consumers. Returns the generated test code, detected components, mock endpoint mappings, test-infra services, and required Maven test dependencies.

camel_route_test_scaffold

Generates a JUnit 5 test skeleton from a Camel route definition (YAML or XML). Accepts an optional format (yaml or xml, default yaml) and runtime (main or spring-boot, default main). For main runtime, the generated test extends CamelTestSupport; for spring-boot, it uses @CamelSpringBootTest with @SpringBootTest. The tool replaces non-trivial producer endpoints with mock endpoints, generates @RegisterExtension stubs for infrastructure components (Kafka, JMS/Artemis, MongoDB, PostgreSQL, Cassandra, Elasticsearch, Redis, RabbitMQ, FTP, Consul, NATS, Pulsar, CouchDB, Infinispan, MinIO, Solr), and produces a NotifyBuilder pattern for timer-based routes or template.sendBody() for direct/seda consumers. Returns the generated test code, detected components, mock endpoint mappings, test-infra services, and required Maven test dependencies.

Security Analysis

Tool Description

Tool	Description
`camel_route_harden_context`	Analyzes a route for security concerns. Identifies security-sensitive components, assigns risk levels, detects issues like hardcoded credentials or plain-text protocols, and returns structured security findings alongside best practices.

camel_route_harden_context

Analyzes a route for security concerns. Identifies security-sensitive components, assigns risk levels, detects issues like hardcoded credentials or plain-text protocols, and returns structured security findings alongside best practices.

Error Diagnosis

Tool Description

Tool	Description
`camel_error_diagnose`	Diagnoses Camel errors from stack traces or error messages. Identifies the exception type against 17 known Camel exceptions (such as `NoSuchEndpointException`, `ResolveEndpointFailedException`, `FailedToCreateRouteException`, `PropertyBindingException`, and others), extracts the components and EIPs involved, and returns common causes, suggested fixes, and links to relevant Camel documentation.

camel_error_diagnose

Diagnoses Camel errors from stack traces or error messages. Identifies the exception type against 17 known Camel exceptions (such as NoSuchEndpointException, ResolveEndpointFailedException, FailedToCreateRouteException, PropertyBindingException, and others), extracts the components and EIPs involved, and returns common causes, suggested fixes, and links to relevant Camel documentation.

Dependency Check

Tool Description

Tool	Description
`camel_dependency_check`	Checks Camel project dependency hygiene given a `pom.xml` and optional route definitions. Detects outdated Camel versions compared to the latest catalog release, identifies missing Maven dependencies for components used in routes, and flags version conflicts between the Camel BOM and explicit dependency overrides. Returns actionable recommendations with corrected dependency snippets.

camel_dependency_check

Checks Camel project dependency hygiene given a pom.xml and optional route definitions. Detects outdated Camel versions compared to the latest catalog release, identifies missing Maven dependencies for components used in routes, and flags version conflicts between the Camel BOM and explicit dependency overrides. Returns actionable recommendations with corrected dependency snippets.

Validation and Transformation

Tool Description

Tool	Description
`camel_validate_route`	Validates Camel endpoint URIs against the catalog schema. Catches unknown options, missing required parameters, invalid enum values, and type mismatches. Also provides suggestions for misspelled option names.
`camel_validate_yaml_dsl`	Validates a YAML DSL route definition against the Camel YAML DSL JSON schema. Checks for valid DSL elements, correct route structure, and returns detailed schema validation errors including instance path, error type, and schema path.
`camel_transform_route`	Assists with route DSL format transformation between YAML and XML.

camel_validate_route

Validates Camel endpoint URIs against the catalog schema. Catches unknown options, missing required parameters, invalid enum values, and type mismatches. Also provides suggestions for misspelled option names.

camel_validate_yaml_dsl

Validates a YAML DSL route definition against the Camel YAML DSL JSON schema. Checks for valid DSL elements, correct route structure, and returns detailed schema validation errors including instance path, error type, and schema path.

camel_transform_route

Assists with route DSL format transformation between YAML and XML.

OpenAPI Contract-First

Since Camel 4.6, the recommended approach for building REST APIs from OpenAPI specifications is contract-first: referencing the OpenAPI spec directly at runtime via rest:openApi rather than generating REST DSL code. These tools help validate, scaffold, and provide mock guidance for that workflow.

Tool Description

Tool	Description
`camel_openapi_validate`	Validates an OpenAPI specification for compatibility with Camel’s contract-first REST support. Checks for missing `operationId` fields, unsupported security schemes, OpenAPI 3.1 limitations, webhooks usage, and empty paths. Returns errors, warnings, and info-level diagnostics.
`camel_openapi_scaffold`	Generates a Camel YAML scaffold for contract-first OpenAPI integration. Produces a `rest:openApi` configuration block referencing the spec file and a `direct:<operationId>` route stub for each operation, with `Content-Type` and `CamelHttpResponseCode` headers pre-configured from the spec. Supports configuring the `missingOperation` mode (`fail`, `ignore`, or `mock`).
`camel_openapi_mock_guidance`	Provides guidance on configuring Camel’s `missingOperation` modes (`fail`, `ignore`, `mock`). For `mock` mode, returns the `camel-mock/` directory structure, mock file paths derived from the API paths, and example content from the spec. Explains the behavior of each mode.

camel_openapi_validate

Validates an OpenAPI specification for compatibility with Camel’s contract-first REST support. Checks for missing operationId fields, unsupported security schemes, OpenAPI 3.1 limitations, webhooks usage, and empty paths. Returns errors, warnings, and info-level diagnostics.

camel_openapi_scaffold

Generates a Camel YAML scaffold for contract-first OpenAPI integration. Produces a rest:openApi configuration block referencing the spec file and a direct:<operationId> route stub for each operation, with Content-Type and CamelHttpResponseCode headers pre-configured from the spec. Supports configuring the missingOperation mode (fail, ignore, or mock).

camel_openapi_mock_guidance

Provides guidance on configuring Camel’s missingOperation modes (fail, ignore, mock). For mock mode, returns the camel-mock/ directory structure, mock file paths derived from the API paths, and example content from the spec. Explains the behavior of each mode.

Migration

Tool Description

Tool	Description
`camel_migration_analyze`	Analyzes a Camel project’s `pom.xml` to detect the runtime type (`main`, `spring-boot`, `quarkus`, `wildfly`, `karaf`), Camel version, Java version, and Camel component dependencies. This is the first step in a migration workflow.
`camel_migration_compatibility`	Checks migration compatibility for Camel components by providing relevant migration guide URLs and Java version requirements. The LLM consults the migration guides for detailed component rename mappings and API changes.
`camel_migration_recipes`	Returns Maven commands to run Camel OpenRewrite migration recipes for upgrading between versions. The project must compile successfully before running the recipes, as OpenRewrite requires a compilable project to parse and transform the code.
`camel_migration_guide_search`	Searches Camel migration and upgrade guides for a specific term or component name. Returns matching snippets from the official guides with version info and URLs. Supports fuzzy matching for typo tolerance. Use this instead of web search when looking up migration-related changes, removed components, API renames, or breaking changes.
`camel_migration_wildfly_karaf`	Provides migration guidance for Camel projects running on WildFly, Karaf, or WAR-based application servers. Returns the Maven archetype command to create a new target project, migration steps, and relevant migration guide URLs.

camel_migration_analyze

Analyzes a Camel project’s pom.xml to detect the runtime type (main, spring-boot, quarkus, wildfly, karaf), Camel version, Java version, and Camel component dependencies. This is the first step in a migration workflow.

camel_migration_compatibility

Checks migration compatibility for Camel components by providing relevant migration guide URLs and Java version requirements. The LLM consults the migration guides for detailed component rename mappings and API changes.

camel_migration_recipes

Returns Maven commands to run Camel OpenRewrite migration recipes for upgrading between versions. The project must compile successfully before running the recipes, as OpenRewrite requires a compilable project to parse and transform the code.

camel_migration_guide_search

Searches Camel migration and upgrade guides for a specific term or component name. Returns matching snippets from the official guides with version info and URLs. Supports fuzzy matching for typo tolerance. Use this instead of web search when looking up migration-related changes, removed components, API renames, or breaking changes.

camel_migration_wildfly_karaf

Provides migration guidance for Camel projects running on WildFly, Karaf, or WAR-based application servers. Returns the Maven archetype command to create a new target project, migration steps, and relevant migration guide URLs.

Version Management

Tool Description

Tool	Description
`camel_version_list`	Lists available Camel versions for a given runtime, including release dates, JDK requirements, and LTS status.

camel_version_list

Lists available Camel versions for a given runtime, including release dates, JDK requirements, and LTS status.

Runtime Introspection

Runtime tools require a running Camel application started via camel run. They communicate with the application through the file-based IPC protocol in ~/.camel/. All tools accept an optional nameOrPid parameter; when omitted, the server auto-discovers the running Camel process (this works when exactly one process is running).

Process Discovery

Tool Description

Tool	Description
`camel_runtime_processes`	List all running Camel processes that can be inspected. Returns PID, name, and context name for each discovered process.

camel_runtime_processes

List all running Camel processes that can be inspected. Returns PID, name, and context name for each discovered process.

Context and Routes

Tool Description

Tool	Description
`camel_runtime_context`	Get Camel context information: name, version, state, uptime, route count, exchange statistics.
`camel_runtime_routes`	List Camel routes with their state, uptime, messages processed, last error, and throughput statistics.
`camel_runtime_route_source`	Get the source code of routes in the running Camel application. Supports wildcard filtering.
`camel_runtime_route_dump`	Dump route definitions in XML or YAML format.
`camel_runtime_route_structure`	Show the route structure as a tree of processors.
`camel_runtime_route_control`	Control a route: start, stop, suspend, or resume it by route ID.

camel_runtime_context

Get Camel context information: name, version, state, uptime, route count, exchange statistics.

camel_runtime_routes

List Camel routes with their state, uptime, messages processed, last error, and throughput statistics.

camel_runtime_route_source

Get the source code of routes in the running Camel application. Supports wildcard filtering.

camel_runtime_route_dump

Dump route definitions in XML or YAML format.

camel_runtime_route_structure

Show the route structure as a tree of processors.

camel_runtime_route_control

Control a route: start, stop, suspend, or resume it by route ID.

Observability

Tool Description

Tool	Description
`camel_runtime_health`	Get health check status for the Camel application.
`camel_runtime_endpoints`	List all endpoints registered in the Camel context with their URIs and usage statistics.
`camel_runtime_inflight`	Show currently in-flight exchanges (messages being processed).
`camel_runtime_blocked`	Show blocked exchanges that are stuck or waiting.
`camel_runtime_top`	Show top processor statistics: which processors are slowest and most active.
`camel_runtime_memory`	Show JVM memory usage (heap/non-heap), garbage collection stats, and thread counts.

camel_runtime_health

Get health check status for the Camel application.

camel_runtime_endpoints

List all endpoints registered in the Camel context with their URIs and usage statistics.

camel_runtime_inflight

Show currently in-flight exchanges (messages being processed).

camel_runtime_blocked

Show blocked exchanges that are stuck or waiting.

camel_runtime_top

Show top processor statistics: which processors are slowest and most active.

camel_runtime_memory

Show JVM memory usage (heap/non-heap), garbage collection stats, and thread counts.

Configuration and Registry

Tool Description

Tool	Description
`camel_runtime_variables`	Show exchange variables in the Camel context.
`camel_runtime_consumers`	Show consumer statistics (polling consumers, event-driven consumers).
`camel_runtime_properties`	Show configuration properties of the running Camel application.
`camel_runtime_services`	Show services registered in the Camel service registry.

camel_runtime_variables

Show exchange variables in the Camel context.

camel_runtime_consumers

Show consumer statistics (polling consumers, event-driven consumers).

camel_runtime_properties

Show configuration properties of the running Camel application.

camel_runtime_services

Show services registered in the Camel service registry.

Interaction and Debugging

Tool Description

Tool	Description
`camel_runtime_send`	Send a test message to a Camel endpoint in the running application.
`camel_runtime_trace`	Enable, disable, or dump message tracing for the running Camel application.
`camel_runtime_eval`	Evaluate an expression in the given language (e.g., simple, jsonpath, xpath) against the Camel context.
`camel_runtime_browse`	Browse messages in a Camel endpoint (e.g., messages queued in a SEDA endpoint).

camel_runtime_send

Send a test message to a Camel endpoint in the running application.

camel_runtime_trace

Enable, disable, or dump message tracing for the running Camel application.

camel_runtime_eval

Evaluate an expression in the given language (e.g., simple, jsonpath, xpath) against the Camel context.

camel_runtime_browse

Browse messages in a Camel endpoint (e.g., messages queued in a SEDA endpoint).

Available Prompts

Prompts are structured multi-step workflows that guide the LLM through orchestrating multiple tools in the correct sequence. Instead of the LLM having to discover which tools to call and in what order, a prompt provides the complete workflow as a step-by-step plan.

MCP clients that support prompts (such as Claude Desktop) expose them as selectable workflows. The LLM receives the instructions and executes each step by calling the referenced tools.

Prompt Arguments Description

Prompt	Arguments	Description
`camel_build_integration`	`requirements` (required), `runtime` (optional)	Guided workflow to build a Camel integration from natural-language requirements. Walks through seven steps: identify components, identify EIPs, get component documentation, build the YAML route, validate it with the YAML DSL schema, run a security review, and present the final result with explanations and run instructions.
`camel_migrate_project`	`pomContent` (required), `targetVersion` (optional)	Guided workflow to migrate a Camel project to a newer version. Walks through six steps: analyze the project’s `pom.xml`, determine the target version, check compatibility (including WildFly/Karaf detection), get OpenRewrite migration recipes, search migration guides for breaking changes per component, and produce a structured migration summary with blockers, breaking changes, commands, and manual steps.
`camel_security_review`	`route` (required), `format` (optional)	Guided workflow to perform a security audit of a Camel route. Walks through three steps: analyze the route for security-sensitive components and vulnerabilities, understand the route structure and data flow, and produce an actionable audit checklist organized into critical issues, warnings, positive findings, recommendations, and compliance notes.

camel_build_integration

requirements (required), runtime (optional)

Guided workflow to build a Camel integration from natural-language requirements. Walks through seven steps: identify components, identify EIPs, get component documentation, build the YAML route, validate it with the YAML DSL schema, run a security review, and present the final result with explanations and run instructions.

camel_migrate_project

pomContent (required), targetVersion (optional)

Guided workflow to migrate a Camel project to a newer version. Walks through six steps: analyze the project’s pom.xml, determine the target version, check compatibility (including WildFly/Karaf detection), get OpenRewrite migration recipes, search migration guides for breaking changes per component, and produce a structured migration summary with blockers, breaking changes, commands, and manual steps.

camel_security_review

route (required), format (optional)

Guided workflow to perform a security audit of a Camel route. Walks through three steps: analyze the route for security-sensitive components and vulnerabilities, understand the route structure and data flow, and produce an actionable audit checklist organized into critical issues, warnings, positive findings, recommendations, and compliance notes.

Setup

The MCP server requires JBang to be installed and available on your PATH.

Claude Code

Add the following to your project’s .mcp.json (or ~/.claude/mcp.json for global configuration):

{
  "mcpServers": {
    "camel": {
      "command": "jbang",
      "args": [
        "-Dquarkus.log.level=WARN",
        "org.apache.camel:camel-jbang-mcp:4.18.0:runner"
      ]
    }
  }
}

OpenAI Codex

Add the server to your MCP configuration:

{
  "mcpServers": {
    "camel": {
      "command": "jbang",
      "args": [
        "-Dquarkus.log.level=WARN",
        "org.apache.camel:camel-jbang-mcp:4.18.0:runner"
      ]
    }
  }
}

VS Code with Copilot

Configure MCP servers in your .vscode/mcp.json or in the user settings:

{
  "servers": {
    "camel": {
      "command": "jbang",
      "args": [
        "-Dquarkus.log.level=WARN",
        "org.apache.camel:camel-jbang-mcp:4.18.0:runner"
      ]
    }
  }
}

JetBrains IDEs

JetBrains IDEs support MCP servers starting from 2025.1. Configure them in Settings > Tools > AI Assistant > MCP Servers, or create an .junie/mcp.json file in your project root:

{
  "mcpServers": {
    "camel": {
      "command": "jbang",
      "args": [
        "-Dquarkus.log.level=WARN",
        "org.apache.camel:camel-jbang-mcp:4.18.0:runner"
      ]
    }
  }
}

Generic STDIO Client

Any MCP client that supports the STDIO transport can launch the server directly:

jbang org.apache.camel:camel-jbang-mcp:4.18.0:runner

HTTP/SSE Transport

To start the server with the HTTP/SSE transport enabled:

jbang -Dquarkus.http.host-enabled=true -Dquarkus.http.port=8080 org.apache.camel:camel-jbang-mcp:4.18.0:runner

If you have built Camel locally, you can also run the uber-JAR directly:

java -Dquarkus.http.host-enabled=true -Dquarkus.http.port=8080 -jar dsl/camel-jbang/camel-jbang-mcp/target/camel-jbang-mcp-4.21.0-SNAPSHOT-runner.jar

The server exposes two HTTP endpoints, corresponding to the two MCP protocol variants:

Endpoint Protocol Version Description

Endpoint	Protocol Version	Description
`/mcp/sse`	`2024-11-05` (SSE)	Legacy HTTP/SSE transport. The client opens an SSE stream at this URL to receive responses and a message endpoint URL. JSON-RPC requests are POSTed to the message endpoint. Most existing MCP clients support this variant.
`/mcp`	`2025-03-26` (Streamable HTTP)	Newer single-endpoint transport. JSON-RPC requests are POSTed directly to this URL and responses are returned inline in the HTTP response body. Simpler to use and recommended for new integrations.

/mcp/sse

2024-11-05 (SSE)

Legacy HTTP/SSE transport. The client opens an SSE stream at this URL to receive responses and a message endpoint URL. JSON-RPC requests are POSTed to the message endpoint. Most existing MCP clients support this variant.

/mcp

2025-03-26 (Streamable HTTP)

Newer single-endpoint transport. JSON-RPC requests are POSTed directly to this URL and responses are returned inline in the HTTP response body. Simpler to use and recommended for new integrations.

Inspecting the MCP Server

To explore what the Camel MCP server exposes (tools, resources, and prompts), you can use the MCP Inspector. This is a web-based UI that connects to any MCP server and lets you browse and invoke its capabilities interactively.

Start the Camel MCP server with HTTP enabled as shown above, then run the MCP Inspector:

npx @modelcontextprotocol/inspector

Open the Inspector UI at http://localhost:6274/ and configure the connection:

Transport Type: SSE
URL: http://localhost:8080/mcp/sse
Connection: Via Proxy

Once connected, you can navigate the available MCP Tools, Resources, and Prompts exposed by the server. This is useful for understanding what data the server provides and for testing tool invocations before integrating with an AI coding assistant.

Getting Started

This walkthrough demonstrates the full AI-assisted Camel workflow: use the catalog tools to build a route, launch it with camel run, then use the runtime tools to inspect and interact with the live application. The same MCP server provides both catalog and runtime capabilities.

Prerequisites

JBang installed and on your PATH
manual/camel-jbang.html[Camel JBang] installed (jbang app install camel@apache/camel)
An MCP-capable AI tool (Claude Code, VS Code with Copilot, JetBrains AI, etc.) configured as shown in the Setup section above

Step 1: Ask the AI to build a route

Start by asking your AI assistant to create a Camel route. The assistant uses the catalog tools to discover components, look up their documentation, build the route, and validate it:

Build me a Camel route that generates a message every 5 seconds with a random number,
logs it, and sends it to a SEDA queue called "numbers".

The assistant uses camel_catalog_component_doc to look up the timer, log, and seda component options, builds a YAML route, and validates it with camel_validate_yaml_dsl. You can also use the camel_build_integration prompt for a more structured multi-step workflow.

The result is a route file, for example random-numbers.yaml:

- route:
    from:
      uri: timer:generate?period=5000
      steps:
        - setBody:
            simple: "${random(1000)}"
        - log: "Generated number: ${body}"
        - to: seda:numbers

Step 2: Launch the route

In AI tools that can execute shell commands (such as Claude Code), ask the assistant to launch the route:

Run this route with camel run

The assistant runs camel run random-numbers.yaml in the background. Alternatively, open a separate terminal and run it yourself:

camel run random-numbers.yaml

Step 3: Inspect the running application

Once the route is running, use the runtime tools to inspect it:

Show me the running Camel processes and their route statistics

The assistant calls camel_runtime_processes to discover the running application, then camel_runtime_routes to show route state, message counts, and throughput. You can drill deeper:

Are there any health issues? What do the endpoints look like?

The assistant calls camel_runtime_health and camel_runtime_endpoints to provide a full picture of the live application.

Step 4: Interact with the running application

Try sending a test message or enabling tracing:

Enable message tracing so I can see the exchange flow, wait a few seconds,
then show me the traced messages.

The assistant calls camel_runtime_trace with action=enable, waits, then calls it again with action=dump to show the message path through the route processors.

Browse the messages queued in the seda:numbers endpoint

The assistant calls camel_runtime_browse with endpoint=seda:numbers to show pending messages.

Step 5: Debug and iterate

If something goes wrong, combine catalog and runtime tools:

The route is showing errors. Diagnose the issue and suggest a fix.

The assistant calls camel_runtime_health and checks error details from camel_runtime_routes, then uses camel_error_diagnose (a catalog tool) to analyze the error and suggest fixes — all in one conversation.

Examples

Listing Components

Prompt your AI assistant with:

List all Camel components in the messaging category

The assistant calls camel_catalog_components with label=messaging and receives structured results with name, title, description, label, deprecation status, and support level for each matching component.

Getting Component Documentation

Show me the documentation for the Kafka component, including all endpoint options

The assistant calls camel_catalog_component_doc with component=kafka and receives the full component model including the URI syntax, Maven coordinates, and every endpoint option with types, defaults, and descriptions.

Browsing Kamelets

Show me all available source kamelets related to AWS

The assistant calls camel_catalog_kamelets with type=source and filter=aws and returns matching Kamelets with their name, type, support level, and description.

To drill into a specific Kamelet:

What options does the aws-s3-source kamelet accept?

The assistant calls camel_catalog_kamelet_doc with kamelet=aws-s3-source and returns the complete property list including required fields, types, defaults, and Maven dependencies.

Browsing Examples

Show me beginner-level Camel examples related to REST

The assistant calls camel_catalog_examples with filter=rest and level=beginner and returns matching examples with their name, title, description, difficulty level, tags, and file list.

To read a specific file from an example:

Show me the route file from the rest-api example

The assistant calls camel_catalog_example_file with example=rest-api and file=route.camel.yaml and returns the file content directly for bundled examples, or a GitHub URL for non-bundled ones.

Validating an Endpoint URI

Validate this Kafka endpoint: kafka:myTopic?brkers=localhost:9092&groupId=myGroup

The assistant calls camel_validate_route and detects the typo (brkers), reports the URI as invalid, and suggests the correct option name (brokers).

Validating YAML DSL Structure

Validate this YAML route definition for me:

- route:
    from:
      uri: timer:yaml
      steps:
        - setCheese:
            simple: Hello Camel
        - log: ${body}

The assistant calls camel_validate_yaml_dsl which validates the route against the Camel YAML DSL JSON schema and reports that setCheese is not a valid DSL element, returning the instance path and error type so the AI can suggest the correct processor name (e.g., setBody).

Understanding a Route

Paste a route and ask:

Explain what this route does

The assistant calls camel_route_context which extracts all components and EIPs used in the route, looks up their documentation from the catalog, and returns enriched context so the AI can provide an accurate explanation.

Security Hardening

Analyze this route for security concerns and suggest hardening measures

The assistant calls camel_route_harden_context which analyzes the route for security-sensitive components, detects issues (hardcoded credentials, HTTP instead of HTTPS, plain FTP, etc.), assigns risk levels, and returns structured findings with remediation recommendations.

Diagnosing an Error

Paste a stack trace or error message and ask:

I'm getting this error when starting my Camel route. What's wrong?

org.apache.camel.FailedToCreateRouteException: Failed to create route route1 at: >>> To[kafka:myTopic] <<<
Caused by: org.apache.camel.ResolveEndpointFailedException: Failed to resolve endpoint: kafka:myTopic
Caused by: org.apache.camel.NoSuchEndpointException: No endpoint could be found for: kafka:myTopic

The assistant calls camel_error_diagnose which identifies all three exceptions in the chain, extracts the kafka component, and returns common causes (missing camel-kafka dependency, typo in URI scheme), suggested fixes (add the dependency, verify the URI), and links to the relevant Camel documentation.

Generating a Test Skeleton

Generate a JUnit 5 test for this route:

- route:
    from:
      uri: kafka:orders
      steps:
        - marshal:
            json: {}
        - to: mongodb:myDb?collection=orders&operation=insert

The assistant calls camel_route_test_scaffold with the route content. It detects the kafka and mongodb components, generates a test class extending CamelTestSupport with @RegisterExtension stubs for both KafkaService and MongoDBService, replaces the mongodb producer with a mock endpoint, and returns the generated test code along with the required Maven test dependencies (camel-test-junit5, camel-mock, camel-test-infra-kafka, camel-test-infra-mongodb).

For Spring Boot projects, specify the runtime:

Generate a Spring Boot test for this Kafka-to-MongoDB route

The tool generates a test class annotated with @CamelSpringBootTest and @SpringBootTest, with CamelContext and ProducerTemplate injected via @Autowired.

Checking Dependency Hygiene

Here's my pom.xml and my main route. Can you check if I'm missing any dependencies
or if anything is outdated?

Provide your pom.xml and route content, and the assistant calls camel_dependency_check. It detects whether your Camel version is outdated compared to the latest release, identifies components used in the route that are missing from the pom (e.g., camel-kafka for kafka: endpoints), and flags version conflicts where a dependency has an explicit version override while a BOM is present. Each issue comes with a corrected Maven snippet you can paste directly into your pom.

Checking Camel Versions

What are the latest LTS versions of Camel for Spring Boot?

The assistant calls camel_version_list with runtime=spring-boot and lts=true and returns version information including release dates, end-of-life dates, and JDK requirements.

Migrating a Camel Project

Start by providing your project’s pom.xml:

I want to migrate my Camel project to the latest version. Here's my pom.xml.

The assistant calls camel_migration_analyze to detect the runtime, current Camel version, Java version, and component dependencies. It then calls camel_migration_compatibility to check for breaking changes and camel_migration_recipes to provide the OpenRewrite commands for automated migration.

Searching Migration Guides

What changed with the direct-vm component in Camel 4?

The assistant calls camel_migration_guide_search with query=direct-vm and returns matching snippets from the official migration guides with version info and URLs, so you can see exactly what changed and how to adapt.

Migrating from WildFly or Karaf

I have a Camel application running on WildFly and I want to migrate it to Quarkus. Here's my pom.xml.

The assistant calls camel_migration_wildfly_karaf which returns the Maven archetype command to create a new Quarkus-based project, migration steps, and relevant guide URLs. The archetype generates the correct project structure so you can then migrate your routes and source files into it.

Validating an OpenAPI Spec for Camel

I have this OpenAPI spec for my Pet Store API. Can you validate it for use with Camel's contract-first REST support?

Paste the OpenAPI spec (JSON or YAML) and the assistant calls camel_openapi_validate. It reports any compatibility issues such as missing operationId fields, unsupported security schemes (OAuth2, mutual TLS), OpenAPI 3.1 limitations, and webhooks usage. A valid spec with no issues returns valid: true with an operation count.

Scaffolding a Contract-First REST API

Generate a Camel YAML scaffold for this OpenAPI spec. The spec file will be called petstore.yaml
and I want missing operations to use mock mode.

The assistant calls camel_openapi_scaffold with specFilename=petstore.yaml and missingOperation=mock. It returns a ready-to-use YAML file containing:

A rest:openApi configuration block referencing the spec file with missingOperation: mock
A direct:<operationId> route stub for each operation with Content-Type and response code headers

Getting Mock Guidance

I want to use Camel's mock mode for my OpenAPI REST API during development. Show me the directory
structure and mock files I need to create.

The assistant calls camel_openapi_mock_guidance with mode=mock. It returns:

An explanation of how mock mode works
The YAML configuration snippet with missingOperation: mock
The camel-mock/ directory structure with mock file paths derived from the API paths
Example content for mock files based on examples defined in the spec

Combined Contract-First Workflow

For a complete prototyping workflow, you can combine all three tools:

I'm building a new REST API with Camel using contract-first. Here's my OpenAPI spec.
Please validate it for compatibility issues, then generate the Camel YAML scaffold
with mock mode so I can prototype quickly.

The assistant first calls camel_openapi_validate to check for issues, then calls camel_openapi_scaffold to generate the route scaffold. This gives you a validated spec and a complete starting point where you can implement routes one at a time while Camel auto-mocks the rest.

Using the Build Integration Prompt

In MCP clients that support prompts, select the camel_build_integration prompt and provide your requirements:

Requirements: Read messages from a Kafka topic, filter them by a JSON field, and write matching messages to an AWS S3 bucket.
Runtime: quarkus

The prompt guides the assistant through a structured seven-step workflow: discovering the right components (kafka, aws2-s3), selecting EIPs (filter), retrieving their documentation, building a YAML route, validating it against the YAML DSL schema, and running a security review — all in the correct order.

Using the Migrate Project Prompt

Select the camel_migrate_project prompt and provide your project’s pom.xml:

pomContent: <paste your pom.xml here>
targetVersion: 4.18.0

The prompt orchestrates the full migration workflow: analyzing your project, checking component compatibility, retrieving OpenRewrite recipes, searching migration guides for per-component breaking changes, and producing a structured migration summary with blockers, manual steps, and the exact commands to run.

Using the Security Review Prompt

Select the camel_security_review prompt and provide a route:

Route: <paste your route here>
Format: yaml

The prompt guides the assistant through a security audit: analyzing the route for vulnerabilities and security-sensitive components, understanding the data flow, and producing a structured audit checklist with critical issues, warnings, positive findings, and actionable recommendations.

Runtime Introspection Examples

The runtime tools require a Camel application to be running. Start one with camel run:

camel run my-route.yaml

Then, from a separate terminal (or through your AI assistant), the MCP server auto-discovers the running process.

Listing Running Processes

Show me the running Camel processes

The assistant calls camel_runtime_processes and returns the PID, name, and context name for each discovered Camel application.

Inspecting Context and Routes

Show me the Camel context info and route statistics for the running application

The assistant calls camel_runtime_context to get context metadata (version, state, uptime) and camel_runtime_routes to list routes with their state, exchange counts, and throughput.

Debugging a Live Route

Enable tracing so I can see messages flowing through my routes, then show me the traced messages

The assistant calls camel_runtime_trace with action=enable to start tracing, waits briefly, then calls camel_runtime_trace with action=dump to retrieve the traced messages showing the path each exchange took through the route processors.

Sending a Test Message

Send a test message with body "Hello" to the direct:start endpoint

The assistant calls camel_runtime_send with endpoint=direct:start and body=Hello. The tool returns the exchange result and any response.

Finding Performance Bottlenecks

Which processors in my routes are the slowest?

The assistant calls camel_runtime_top to get processor-level statistics sorted by processing time, helping identify bottlenecks in the running application.