KnowForge/Apache Camel
Camel CLI

Camel MCP Server

qianmoQqianmoQ· 更新于 2026-09-22· 阅读 109 分钟· 0 次阅读
登录后可跨设备保存划线和私人笔记登录

Camel MCP Server

The Camel MCP Server gives AI coding assistants deep knowledge of Apache Camel. It exposes the full Camel Catalog — components, EIPs, data formats, Kamelets, examples — plus runtime introspection tools for live Camel applications, all through the Model Context Protocol (MCP).

With the MCP server running, your AI assistant can look up component documentation, validate endpoints and routes, generate test scaffolds, diagnose errors from stack traces, check dependencies, plan migrations, review routes for security concerns, and interact with running Camel applications — without you having to copy-paste anything.

Built on Quarkus with the quarkus-mcp-server extension.

Getting Started

The quickest way to get started:

  1. Install JBang (one-time)
  2. Run camel mcp (or jbang org.apache.camel:camel-jbang-mcp:LATEST:runner)
  3. Connect your AI assistant (see Setup below)

That’s it — the MCP server starts with STDIO transport and your AI assistant can immediately query the Camel Catalog, validate routes, and more.

Running the MCP Server

There are three ways to run the MCP server.

Using the Camel CLI (recommended)

The camel mcp command launches the MCP server as a first-class CLI command:

camel mcp

This starts the MCP server with STDIO transport (the default). To enable HTTP transport:

camel mcp --http
camel mcp --http --port 9090

See camel mcp Options for all available flags.

Using JBang directly

If you have JBang installed:

# STDIO transport (default)
jbang org.apache.camel:camel-jbang-mcp:LATEST:runner

# HTTP transport
jbang -Dquarkus.http.host-enabled=true -Dquarkus.http.port=8080 org.apache.camel:camel-jbang-mcp:LATEST:runner

Using java -jar (no JBang needed)

Download the MCP server uber-JAR from Maven Central and run it directly:

# Download (replace VERSION with the desired Camel version, e.g., 4.21.0)
curl -O https://repo1.maven.org/maven2/org/apache/camel/camel-jbang-mcp/VERSION/camel-jbang-mcp-VERSION-runner.jar

# Run with STDIO transport
java -jar camel-jbang-mcp-VERSION-runner.jar

# Run with HTTP transport
java -Dquarkus.http.host-enabled=true -Dquarkus.http.port=8080 -jar camel-jbang-mcp-VERSION-runner.jar

Transport

  • STDIO (default) — communicates over stdin/stdout. Logging goes to stderr.
  • HTTP/SSE — for web-based clients and remote/shared access. Enable with --http flag or -Dquarkus.http.host-enabled=true. Supports two variants: SSE (/mcp/sse, protocol 2024-11-05) and Streamable HTTP (/mcp, protocol 2025-03-26, recommended for new integrations).
The MCP server does not expose REST endpoints — all communication uses JSON-RPC over the MCP protocol.

Setup

Claude Code (plugin install, recommended)

claude plugin marketplace add apache/camel
claude plugin install camel-mcp@camel-marketplace

Manual configuration (all AI tools)

Add the server to your MCP configuration file. The JSON is the same for all tools — only the file location differs:

ToolConfiguration file
Claude Code.mcp.json (project) or ~/.claude/mcp.json (global)
OpenAI CodexMCP configuration file
VS Code / Copilot.vscode/mcp.json (use "servers" instead of "mcpServers" as the top-level key)
JetBrains IDEs (2025.1+)Settings > Tools > AI Assistant > MCP Servers, or .junie/mcp.json
{
  "mcpServers": {
    "camel": {
      "command": "jbang",
      "args": [
        "-Dquarkus.log.level=WARN",
        "org.apache.camel:camel-jbang-mcp:LATEST:runner"
      ]
    }
  }
}
For VS Code, the top-level key is "servers" instead of "mcpServers".

Inspecting with MCP Inspector

Start the server with HTTP enabled, then:

npx @modelcontextprotocol/inspector

Open http://localhost:6274/, set Transport Type to SSE, URL to http://localhost:8080/mcp/sse, Connection to Via Proxy.

camel mcp Options

OptionDefaultDescription
--httpfalseEnable HTTP transport (Streamable HTTP and SSE). Without this flag, the server uses STDIO transport.
--port8080HTTP server port (only used with --http).
--log-levelWARNLog level: ERROR, WARN, INFO, DEBUG, TRACE.
--version(current Camel version)Camel MCP server version to use. Defaults to the version of the Camel CLI.

Examples

Here are example prompts you can give your AI assistant. The assistant automatically selects the right MCP tools.

Catalog exploration

  • "Which component talks MQTT?" — uses camel_catalog_find
  • "Show me the Kafka component documentation with all options" — uses camel_catalog_doc
  • "Which EIP fans a message out to several endpoints?" — uses camel_catalog_find with kind=eip (the EIP aliases such as fan-out, dedup and rate-limit match)
  • "Show me all AWS source kamelets" — uses camel_catalog_kamelets
  • "What options does aws-s3-source accept?" — uses camel_catalog_kamelet_doc
  • "Show me beginner REST examples" — uses camel_catalog_examples

Building routes

Ask the assistant to build a route from requirements:

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 discovers components, looks up documentation, builds a YAML route, and validates it with camel_validate_source. Use the camel_build_integration prompt for a structured multi-step workflow.

Validation

  • "Validate this endpoint: kafka:myTopic?brkers=localhost:9092" — detects the typo and suggests brokers
  • "Validate this YAML route" — checks against the YAML DSL JSON schema, reports invalid elements

Understanding, security, and testing

  • "Explain what this route does" — uses camel_route_context for catalog-enriched analysis
  • "Analyze this route for security concerns" — uses camel_route_harden_context to detect hardcoded credentials, plain-text protocols, known CVE advisories, etc.
  • "Is my Camel 4.10.1 project affected by known CVEs?" — uses camel_security_advisories to match the published Apache Camel security advisories against a Camel version or component
  • "Generate a JUnit 5 test for this route" — uses camel_route_test_scaffold to produce test class with mock endpoints and test-infra stubs

Error diagnosis

Paste a stack trace:

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

The assistant uses camel_error_diagnose to identify the exception chain, extract components, and suggest fixes (e.g., missing camel-kafka dependency).

Dependencies and versions

  • "Check my pom.xml for missing or outdated dependencies" — uses camel_dependency_check
  • "What are the latest LTS versions for Spring Boot?" — uses camel_version_list
  • "Which dependency do I need for org.postgresql.ds.PGSimpleDataSource, and how do I add it on Quarkus?" — uses camel_dependency_for_class

Migration

  • "Migrate my project to the latest version (here’s my pom.xml)" — uses camel_migration_analyze → camel_migration_compatibility → camel_migration_recipes
  • "What changed with direct-vm in Camel 4?" — uses camel_migration_guide_search
  • "Migrate from WildFly to Quarkus" — uses camel_migration_wildfly_karaf for archetype commands and steps
  • Use the camel_migrate_project prompt for an orchestrated multi-step workflow

OpenAPI contract-first

  • "Validate this OpenAPI spec for Camel compatibility" — uses camel_openapi_validate
  • "Generate a Camel YAML scaffold with mock mode" — uses camel_openapi_scaffold
  • "Show me the mock directory structure" — uses camel_openapi_mock_guidance

Combine all three for a complete prototyping workflow: validate, scaffold, then implement routes one at a time while Camel mocks the rest.

Runtime introspection

Start a route with camel run my-route.yaml, then ask:

  • "Show me running Camel processes and route statistics" — uses camel_runtime_processes and camel_runtime_routes
  • "Enable tracing and show me the traced messages" — uses camel_runtime_trace
  • "Send a test message to direct:start" — uses camel_runtime_send
  • "Which processors are the slowest?" — uses camel_runtime_top
  • "Browse messages in seda:numbers" — uses camel_runtime_browse

Prompts (structured workflows)

MCP clients that support prompts expose these as selectable workflows:

  • camel_build_integration — 7-step guided workflow: discover components → select EIPs → build → validate → security review
  • camel_migrate_project — 6-step migration: analyze → compatibility → recipes → guide search → summary
  • camel_security_review — 3-step audit: analyze vulnerabilities → understand data flow → produce checklist

Available Tools

The server exposes catalog tools for exploring components, validating routes, and assisting with migration, runtime introspection tools for inspecting and interacting with live Camel processes, plus prompts that provide structured multi-step workflows.

Authoring (shared with the Camel TUI)

The tools an agent needs to build and edit an integration are defined once, in the Camel CLI, and exposed under the same camel_ names by this server and by camel tui --mcp (see Camel TUI), so an agent gets the same Camel through either door. The tools are self-contained: the file tools take the project directory as an argument, the runtime tools take the integration name (or use the only one running).

ToolDescription
camel_catalog_docCatalog documentation of a component, data format, language, EIP or built-in bean: description, options, Maven coordinates, and for a component the rules of its endpoint URI spelled out (which options are path parts, the YAML uri plus parameters form, placeholders, RAW()). For the simple language the syntax rules, functions and operators (their count and names by group, or with optionsFilter the matching ones with parameters and examples: a group name such as date gives that group only, an operator kind such as logical that kind only, a function or operator name comes first, and any other word matches the names and descriptions), and docPage serves the functions, operators, OGNL and advanced pages. With endpoint it checks a URI against the catalog: unknown options with the closest real names, invalid values, missing path parts, consumer options on a producer endpoint. includeHeaders=true adds the message headers of a component (the CamelXxx names, their constants, types and consumer or producer group), includeDoc=true the AsciiDoc page. An EIP alias (fan-out, dedup, rate-limit) or a word of its title finds the EIP; the answer then names the matchedTerm. includeOptions picks the options listed: common (the default) leaves out the deprecated and advanced ones and says how many with omittedOptions, required lists the required ones, all everything, false none; optionsFilter matches a keyword in the option names, descriptions and groups and searches all options. With kind=api (or a class name such as Exchange) it answers with the compact API reference of the core classes a bean or script calls: Exchange, Message, CamelContext, Registry, ProducerTemplate, Processor, AggregationStrategy, Predicate, Expression and TypeConverter, one line per method with the signatures, an example and the common mistakes (the first call of an aggregation strategy has a null oldExchange, a Map body has no ${body.type}, a bean name is not a Groovy variable, there is no getOut() in Camel 4). The reference is generated from the @Metadata(label = "api") annotations on the real methods in camel-api and shipped in camel-catalog (org/apache/camel/catalog/apis/), so it cannot drift. The name of a script language (groovy, js, python, python3, quickjs, java) or template returns the variables that script sees and how to reach the Camel API from them; the language documentation of those languages carries the same scriptVariables.
camel_catalog_findFinds components, data formats, languages and EIPs by a protocol, product, alias or other term that is not the exact name (mqtt, s3, snowflake, csv, fan-out, dedup), best match first with title and description; kind narrows it to one of them, and bean with an interface name such as AggregationStrategy lists the built-in implementations.
camel_catalog_sampleValidated YAML DSL samples of an EIP or file entry (onException, aggregate, split, rest, beans), a component (kafka, file), a data format (csv) or a language (jq) taken from the documentation examples, with where it goes: a top-level entry next to the route, a step inside it, an endpoint uri in from: or to: (the component’s consumer or producer side), a marshal/unmarshal step, or the expression of a step. The name can be kebab-case, a part of another EIP (doCatch, when, onFallback show the whole construct), an alias of the EIP (fan-out, rate-limit, from the catalog’s EIP models) or what to do (read file, call service, retry, batch); kind (eip, component, dataformat, language) is only needed for a name that is in several kinds (avro, file), otherwise the answer names the kinds to choose from. The samples come from the documentation of the catalog in use, so they follow its Camel version: the EIP page, the component page and its sub-pages (the examples using the component’s endpoint first), the data format or language page. The file entries come from the user manual examples that the build validates (generate-doc-samples in Camel YAML DSL Validator Maven Plugin). limit is 2 by default, at most 5. Use it before writing one the first time, or after a not defined in the schema validation error.
camel_validate_sourceValidates Camel YAML DSL or .properties source without writing: the YAML DSL schema (a misspelled option such as logLevel instead of loggingLevel), endpoint URIs, simple expressions, and camel.* options. Takes the content, or reads the file from the project directory. With camelVersion (or the version of the selected integration in the TUI) the catalog and the YAML DSL schema of that Camel version answer, the schema read from its camel-yaml-dsl jar; without it the CLI’s own, with nothing to download.
camel_get_filesThe source files of a project directory, subdirectories included (target, .git and the like skipped). The list says whether the directory is a Maven project or a flat folder, names the route files and the configuration files up front (routeFiles, configFiles) and, when an integration is selected, which file and line each of its routes was loaded from, mapped from the runtime’s location (a jar entry of an exported project, a classpath or file resource) onto the source under src/main. With file, a path relative to the directory as the list names it, the content of that file.
camel_write_fileWrites the complete content of a file in the project directory. YAML and .properties content is validated first; invalid content is not written and the errors are returned (validate=false writes anyway). Only a plain file name in the directory is accepted. Nobody is asked before the write: the MCP client (Claude Code, Cursor and the others ask before a tool that is not read-only runs) is where the human sits, and the read-only access level of the security layer hides the tool altogether.
camel_runStarts an integration from a project directory with camel run --source-dir in a separate process, in dev mode by default: the directory is watched, so a changed or added file (a route, a bean file, a Java class) is reloaded. Name files to run only those, for a directory that holds several apps. Returns the pid, name and log file once the integration is up.
camel_controlControls a running integration: stop, kill, restart (picks up edited files without dev mode), reload (loads the routes again from their files without a restart, as camel cmd reload does), stop-routes, start-routes, reset-stats.
camel_get_logRecent log records of a running integration, newest first, filtered by level or text; a stack trace comes as one record with a detail block.
camel_get_errorsThe failed exchanges of a running integration: route, exchange, exception with stack trace, body and headers.
camel_eval_expressionEvaluates an expression (simple by default) in the running integration, or locally when none is named, and returns the value (true/false for a predicate) or the syntax error, so an agent can check a simple expression before writing it into a route.
camel_dependency_for_classWhich Maven dependency provides a class, and how to declare it. Local first: the known dependencies camel run downloads by itself (nothing to declare there), then a Camel component’s artifact for each runtime. Only with mavenCentral=true it searches Maven Central by class name, groups the hits by artifact, takes the newest version, and marks the answer as a guess. Returns camel.jbang.dependencies, --dep, and the pom.xml dependency for Camel Main, Spring Boot and Quarkus, or one runtime with runtime. Uses the JVM proxy settings for the search.
camel_error_diagnoseSee Error Diagnosis; the same shared tool.

Catalog Exploration

ToolDescription
camel_catalog_docsList the AsciiDoc documentation page names of the catalog (kafka-component, split-eip, …​), with a substring filter; camel_catalog_doc with includeDoc=true returns a page.
camel_component_propertiesList valid configuration property keys for a Camel component in camel.component.<scheme>.<name> form, including option name, type, default value, and description.

Kamelet Catalog

ToolDescription
camel_catalog_kameletsList 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_docGet detailed documentation for a specific Kamelet including all properties/options, their types, defaults, examples, and the Kamelet’s Maven dependencies.

Example Catalog

ToolDescription
camel_catalog_examplesList available Camel CLI 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_fileGet the content of a specific file from a Camel CLI 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

ToolDescription
camel_route_contextGiven 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

ToolDescription
camel_route_test_scaffoldGenerates 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

ToolDescription
camel_route_harden_contextAnalyzes 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 and the known published CVE advisories affecting the components used by the route at the given Camel version.
camel_security_advisoriesLists the published Apache Camel CVE security advisories (the data behind camel.apache.org/security), optionally filtered by Camel version, component and severity. Each advisory includes the summary, affected and fixed versions, mitigation, and a best-effort verdict on whether the given Camel version is affected. Use it to answer questions such as "is my Camel 4.10.1 project affected by known CVEs?".

Security advisory data

The advisory data ships with the Camel catalog bundled in the MCP server, where it is synced from the official published Apache Camel security advisories (the sources of camel.apache.org/security) when Camel is built — the same way the known releases are synced. Lookups are therefore fully offline, only published advisories are included, and the data is as fresh as the Camel version of the MCP server: advisories published after that release are not included, so check the web page for the very latest. When the catalog carries no advisory data the tools report it as unavailable rather than returning an empty list, so a missing data set is never mistaken for "no known CVEs". The advisories are also browseable as MCP resources: camel://security/advisories (full list) and camel://security/advisory/{cve} (detail for one CVE).

Error Diagnosis

ToolDescription
camel_error_diagnoseDiagnoses 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

ToolDescription
camel_dependency_checkChecks 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

ToolDescription
camel_transform_routeAssists with route DSL format transformation between YAML and XML.
camel_configuration_validateValidate Camel configuration property lines (e.g., from application.properties). Detects misspelled option names, invalid values, and returns suggestions.
camel_properties_translateTranslate Camel configuration properties between runtimes (main, spring-boot, quarkus). Handles runtime-specific keys like HTTP server and management endpoint configuration.

Route Diagram

ToolDescription
camel_render_route_diagramGenerate a diagram of Camel routes from a source file (YAML, XML, Java). Supports image themes (dark, light, transparent) written as PNG, and text themes (ascii, unicode) returned directly. Useful for visualizing route structure for review, documentation, or troubleshooting.

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.

ToolDescription
camel_openapi_validateValidates 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_scaffoldGenerates 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_guidanceProvides 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

ToolDescription
camel_migration_analyzeAnalyzes 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_compatibilityChecks 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_recipesReturns 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_searchSearches 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_karafProvides 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

ToolDescription
camel_version_listLists 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

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

Context and Routes

ToolDescription
camel_runtime_contextGet Camel context information: name, version, state, uptime, route count, exchange statistics.
camel_runtime_routesList Camel routes with their state, uptime, messages processed, last error, and throughput statistics.
camel_runtime_route_sourceGet the source code of routes in the running Camel application. Supports wildcard filtering.
camel_runtime_route_dumpDump route definitions in XML or YAML format.
camel_runtime_route_structureShow the route structure as a tree of processors.
camel_runtime_route_controlControl a route: start, stop, suspend, or resume it by route ID.
camel_runtime_route_topologyGet the inter-route topology showing how routes connect to each other and to external endpoints. Returns nodes and edges describing the route graph.

Observability

ToolDescription
camel_runtime_healthGet health check status for the Camel application.
camel_runtime_endpointsList all endpoints registered in the Camel context with their URIs and usage statistics.
camel_runtime_inflightShow currently in-flight exchanges (messages being processed).
camel_runtime_blockedShow blocked exchanges that are stuck or waiting.
camel_runtime_topShow top processor statistics: which processors are slowest and most active.
camel_runtime_memoryShow JVM memory usage (heap/non-heap), garbage collection stats, and thread counts.
camel_runtime_heap_histogramGet a class-level heap histogram showing instance counts and byte usage per class. Useful for diagnosing memory leaks and understanding which classes dominate heap usage.
camel_runtime_memory_leakDiagnose memory leaks in a running Camel integration using Java Flight Recorder (JFR). Use command 'start' to begin recording, 'stop' to get results, 'status' to check state, and 'query' to retrieve cached results. Supports dual-recording mode for trend comparison.
camel_runtime_historyGet the message history trace of the last completed exchange. Shows the route path, processors visited, headers, body, and timing.
camel_runtime_thread_dumpGet a JVM thread dump showing thread names, states, and stack traces.

Data, Resilience and Analysis

ToolDescription
camel_runtime_sqlExecute a SQL statement against a DataSource of the running application: columns and rows for a SELECT, the update count otherwise. Lets the model look at the data a route reads or writes, or try a statement before putting it in a route.
camel_runtime_datasourcesDatasource connection pool status: active, idle and total connections, max pool size and waiting threads.
camel_runtime_sql_traceTraced SQL executions of the camel-sql and camel-jdbc components with timing, row counts, route ID and failure status.
camel_runtime_circuit_breakersCircuit breaker state (CLOSED/OPEN/HALF_OPEN), call counts, failure rates and not-permitted calls.
camel_runtime_metricsMicrometer metrics: counters, gauges, timers and distributions (requires --observe or camel-micrometer).
camel_runtime_eip_statsEIP usage across all routes with processor counts and performance figures.
camel_runtime_spansOpenTelemetry spans with trace IDs, durations, route IDs and status (requires --observe).
camel_runtime_startup_stepsStartup recorder steps with duration, level and type (requires camel.main.startup-recorder=true).
camel_runtime_route_analysisAnti-pattern and structure analysis per route: error handling, complexity, component usage.
camel_runtime_config_driftCompares the running route definitions with the source files to detect configuration drift.

Configuration and Registry

ToolDescription
camel_runtime_variablesShow exchange variables in the Camel context.
camel_runtime_consumersShow consumer statistics (polling consumers, event-driven consumers).
camel_runtime_propertiesShow configuration properties of the running Camel application.
camel_runtime_servicesShow services registered in the Camel service registry.

Interaction and Debugging

ToolDescription
camel_runtime_sendSend a test message to a Camel endpoint in the running application.
camel_runtime_traceEnable, disable, or dump message tracing for the running Camel application.
camel_runtime_browseBrowse messages in a Camel endpoint (e.g., messages queued in a SEDA endpoint).
camel_runtime_receiveReceive (poll) a message from a Camel endpoint in the running application. Consumes one message from the 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.

PromptArgumentsDescription
camel_build_integrationrequirements (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_projectpomContent (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_reviewroute (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_diagnose_routerouteId (optional), symptom (optional)Guided workflow to diagnose issues with a running Camel route: gather runtime state, errors, health, message history, and produce a root cause analysis with actionable fixes.
camel_optimize_routerouteId (optional), goal (optional)Guided workflow to optimize a Camel application’s performance: analyze throughput, identify bottlenecks, review resource usage, and produce prioritized optimization recommendations.

评论

登录后参与评论

正在加载评论…