Camel Integration Capability

A capability service for the Wanaku MCP Router that enables AI agents to interact with backend systems through dynamically executed Apache Camel routes.

What is This?

The Camel Integration Capability bridges AI agents with enterprise integration patterns.

It exposes Apache Camel routes as MCP (Model Context Protocol) tools and resources, allowing AI agents to perform complex backend operations through standardized gRPC interfaces.

Key Use Cases:

• Enable AI agents to query databases, CRMs, or inventory systems
• Orchestrate multi-step business workflows through natural language
• Integrate AI capabilities with existing enterprise service buses
• Provide controlled, rule-based access to backend APIs for AI agents

Project Structure

camel-integration-capability/
├── camel-integration-capability-common/           # Shared utilities, models, gRPC services
└── camel-integration-capability-runtimes/
    ├── camel-integration-capability-plugin/       # SPI plugin for existing Camel apps
    └── camel-integration-capability-main/         # Standalone CLI application

Deployment Options

Option	Use Case	Configuration
Standalone	Dedicated service deployment	CLI arguments
Plugin	Embed into existing Camel apps	Environment variables

Architecture Overview

graph TB
    A[AI Agent/LLM] -->|MCP Protocol| B[Wanaku MCP Router]
    B -->|gRPC| C[Camel Integration Capability]
    C -->|OAuth2/OIDC| B
    C -->|Execute| E[Apache Camel Routes]
    E -->|HTTP/REST| F[Backend APIs]
    E -->|Database| G[Data Sources]
    E -->|Message Queue| H[Messaging Systems]

    I[Service Catalog] -.->|Routes, Rules & Dependencies| C
    J[DataStore Service] -.->|Individual Resources| C

Quick Start

Prerequisites

• Java 21 or higher
• Maven 3.6+ (for building from source)
• Access to a Wanaku MCP Router instance
• OAuth2/OIDC authentication provider (e.g., Keycloak)

5-Minute Setup

1. Download the latest release or build from source:

   git clone https://github.com/wanaku-ai/camel-integration-capability.git
   cd camel-integration-capability
   mvn clean package
   

2. Prepare your Camel routes (example my-routes.camel.yaml):

   - route:
       id: get-employee-info
       from:
         uri: direct:get-employee-info
         steps:
           - toD: https://api.example.com/employees/${header.Wanaku.employeeId}
   

3. Prepare route exposure rules (example my-rules.yaml):

   mcp:
     tools:
        - get-employee-info:
            route:
             id: get-employee-info
            description: "Fetches core profile data for a specific employee"
   

   Note

   This example uses automatic parameter mapping. All MCP parameters are mapped to Camel headers with the Wanaku. prefix (e.g., employeeId → Wanaku.employeeId). For explicit control over parameter names, see the Usage Guide.

Option 1: Standalone Application

Run as a dedicated service with CLI configuration. The recommended approach is to use a service catalog, which bundles routes, rules, and dependencies into a single versioned artifact:

java -jar camel-integration-capability-runtimes/camel-integration-capability-main/target/camel-integration-capability-main-*-jar-with-dependencies.jar \
  --registration-url http://localhost:8080 \
  --registration-announce-address localhost \
  --name employee-system \
  --service-catalog employee-system-v2 \
  --service-catalog-system employee-system \
  --client-id wanaku-service \
  --client-secret your-secret

You can also reference individual files instead of a catalog (useful during development):

java -jar camel-integration-capability-runtimes/camel-integration-capability-main/target/camel-integration-capability-main-*-jar-with-dependencies.jar \
  --registration-url http://localhost:8080 \
  --registration-announce-address localhost \
  --routes-ref file:///path/to/routes.camel.yaml \
  --rules-ref file:///path/to/rules.yaml \
  --client-id wanaku-service \
  --client-secret your-secret

Option 2: Plugin Mode

Embed into an existing Camel application using SPI. Add the shaded jar to your classpath and configure via environment variables:

export REGISTRATION_URL=http://localhost:8080
export REGISTRATION_ANNOUNCE_ADDRESS=localhost
export GRPC_PORT=9190
export SERVICE_NAME=my-camel-app
export ROUTES_RULES=file:///path/to/rules.yaml
export CLIENT_ID=wanaku-service
export CLIENT_SECRET=your-secret

java -cp camel-integration-capability-plugin-*-shaded.jar:your-app.jar your.MainClass

The plugin is automatically discovered via META-INF/services/org.apache.camel.spi.ContextServicePlugin.

Documentation

For stable release documentation, visit the Wanaku Documentation website.

The guides below cover development and unreleased features. They may describe behavior that differs from the latest stable release.

• Usage Guide - Standalone application configuration
• Plugin Guide - Embedding in Camel applications
• Service Catalog Guide - Creating and publishing service catalogs
• CLI Reference - Complete command-line parameter reference
• Rules Schema - Route exposure rules YAML reference
• Authentication - OAuth2/OIDC configuration
• Operations - Production deployment and monitoring
• Troubleshooting - Common issues and solutions
• Building - Build instructions and development setup
• Migration Guide - Upgrading between versions
• Examples - Working example routes and configurations
• Contributing - Guidelines for contributing
• Security - Vulnerability reporting

Deployment

Docker

mvn clean package -DskipTests
docker build -t camel-integration-capability .
docker run -p 9190:9190 camel-integration-capability [options]

Kubernetes/OpenShift

Deploy using the Wanaku operator. See Usage Guide for examples.

Support

• Issues: GitHub Issues
• Community: Wanaku
• Email: contact@wanaku.ai

License

Apache License 2.0 - see LICENSE for details.

Related Projects

• Wanaku MCP Router - The MCP router this capability integrates with
• Apache Camel - The integration framework powering route execution
• Kaoto - Visual designer for Camel routes