Wanaku 0.1.1: Bringing Apache Camel Integration Capabilities to AI Agents via MCP

Otavio Rodolfo Piske — Thu, 11 Jun 2026 20:45:53 +0000

We're excited to announce Wanaku 0.1.1, a significant milestone that showcases how Apache Camel's powerful integration capabilities can be seamlessly exposed to AI agents through the Model Context Protocol (MCP). This release introduces Service Catalogs and Service Templates — features that leverage Apache Camel as the integration runtime to bridge the gap between AI and enterprise systems.

What is Wanaku?

Wanaku is an open-source MCP router and capability management platform that acts as a smart intermediary between AI agents and integration capabilities. Think of it as a gateway that allows AI systems to discover and invoke enterprise integrations as if they were native tools, all through a unified MCP interface.

While Wanaku is runtime-agnostic in design, Apache Camel is the native and first-class integration runtime, providing the robust, battle-tested foundation for connecting AI agents to hundreds of enterprise systems, protocols, and data formats.

Getting started is a single command. After downloading the CLI, just run:

wanaku start local

This launches the Wanaku router and admin UI on your machine — no containers, no cloud accounts, no configuration files. You're ready to create and deploy Service Catalogs in seconds.

Service Catalogs: Packaging Camel Routes as AI Tools

At the heart of Wanaku 0.1.1 is the Service Catalog concept — a way to bundle Apache Camel routes, MCP tool definitions, and dependencies into a single deployable package. This brings several Apache Camel strengths directly to AI agents:

Camel routes define integration logic using YAML-based route definitions
Wanaku rules map route IDs to MCP tool definitions, adding the metadata AI agents need to discover and invoke each route
Maven dependencies declare required Camel components and libraries

Here's what a Service Catalog looks like, using a book search example that calls the free Open Library API:

demo-catalog/
├── index.properties              # Catalog manifest
└── books/
    ├── books.camel.yaml           # Camel routes
    ├── books.wanaku-rules.yaml    # MCP tool definitions
    └── books.dependencies.txt     # Camel component dependencies

The Apache Camel Foundation

The books.camel.yaml file contains standard Apache Camel route definitions:

- route:
    id: get-book-by-isbn
    description: Retrieve book information by ISBN
    from:
      uri: direct:get-by-isbn
      steps:
        - setHeader:
            name: CamelHttpMethod
            constant: GET
        - log:
            message: "Fetching book with ISBN: ${body}"
        - toD:
            uri: "https://openlibrary.org/api/books?bibkeys=ISBN:${body}&format=json&jscmd=data"
        - convertBodyTo:
            type: String
        - log:
            message: "Book data received: ${body}"

- route:
    id: search-books
    description: Search for books by title
    from:
      uri: direct:search-books
      steps:
        - setHeader:
            name: CamelHttpMethod
            constant: GET
        - log:
            message: "Searching for books with query: ${body}"
        - toD:
            uri: "https://openlibrary.org/search.json?q=${body}&limit=5"
        - convertBodyTo:
            type: String
        - log:
            message: "Search results received: ${body}"

This is pure Camel — nothing AI-specific here. The routes leverage Camel's direct component for triggering and the http component for external API calls. The beauty is that most Camel routes can become AI tools with minimal modification — typically just exposing a direct: endpoint and adding a wanaku-rules mapping.

Tip: You can use a visual editor such as Kaoto or Camel Karavan to design and edit Camel routes, rather than hand-editing YAML.

From Route ID to AI Tool

Wanaku's CLI generates MCP tool definitions from route IDs:

wanaku service expose --path=demo-catalog

This scans each Camel route file and generates a corresponding wanaku-rules.yaml:

# Auto-generated Wanaku rules for books
# Generated by 'wanaku service expose'
mcp:
  tools:
    - get-book-by-isbn:
        route:
          id: "get-book-by-isbn"
        description: "Invoke route get-book-by-isbn in books"
        properties:
          - name: wanaku_body
            type: string
            description: The greeting message to send
            required: true
    - search-books:
        route:
          id: "search-books"
        description: "Invoke route search-books in books"
        properties:
          - name: wanaku_body
            type: string
            description: The greeting message to send
            required: true

Notice the wanaku_body property in each tool definition — this is a special argument that tells Wanaku to place the AI agent's input directly into the body of the Camel data exchange, rather than passing it as a parameter or header. This is what allows the routes above to reference ${body} in their toD URIs and log messages.

AI agents can now discover get-book-by-isbn and search-books as available tools and invoke them through the MCP protocol. Under the hood, Wanaku routes each request to the corresponding Camel direct: endpoint, executes the route, and returns the result.

Leveraging Camel's Component Ecosystem

One of Apache Camel's greatest strengths is its 400+ components covering everything from HTTP and databases to messaging systems, cloud services, and IoT protocols. Service Catalogs make this entire ecosystem available to AI agents.

For example, the book search catalog declares its dependencies in books.dependencies.txt:

org.apache.camel:camel-http:4.18.2
org.apache.camel:camel-jackson:4.18.2

This declarative approach means that as soon as you deploy the catalog, Wanaku ensures the necessary Camel components are available at runtime. AI agents get instant access to HTTP clients, JSON transformations, and more — all powered by Camel.

Service Templates: Parameterized Camel Integrations

Building on Service Catalogs, Service Templates introduce parameterization using Camel Property Placeholders. This allows you to create reusable integration blueprints that users can customize without touching YAML or Java code.

How It Works: Camel Property Placeholders

Service Templates use Camel's native {{property}} syntax to mark configurable values. For example, here's a Kafka template that sets up request/reply messaging:

kafka/service.properties:

kafka.brokers={{kafka.brokers}}
kafka.request.topic={{kafka.request.topic}}
kafka.response.topic={{kafka.response.topic}}
kafka.reply.timeout-ms={{kafka.reply.timeout-ms}}
kafka.response.group-id={{kafka.response.group-id}}

kafka/kafka.camel.yaml:

- route:
    id: kafka-request-reply
    description: Send a Kafka request and wait for the correlated reply
    from:
      uri: direct:wanaku
      steps:
        - to:
            uri: kafka:{{kafka.request.topic}}
            parameters:
              brokers: "{{kafka.brokers}}"
        - pollEnrich:
            timeout: "{{kafka.reply.timeout-ms}}"
            expression:
              simple:
                expression: "seda:kafka-replies"

When a user instantiates this template, Wanaku generates a ready-to-deploy Service Catalog and works with Apache Camel to substitutes those placeholders. The resulting Camel routes are fully functional — no manual editing required. Users can browse and instantiate templates via the Service Catalog page in the Wanaku Admin UI.

Built-in Templates for Common Integrations

Wanaku 0.1.1 ships with several built-in Service Templates that showcase Apache Camel's versatility:

kafka-tool — Request/reply messaging with manual correlation using camel-kafka
jms-tool — ActiveMQ Artemis messaging with camel-jms
github-pullrequest-source-tool — Fetch GitHub PR data using camel-http and REST APIs
jira-add-comment-tool, jira-add-issue-tool, jira-update-issue-tool — Jira integration using camel-jira
mail-sink-tool — Send emails via SMTP using camel-mail
rabbitmq-tool — RabbitMQ messaging with camel-rabbitmq
telegram-sink-tool — Send Telegram messages using camel-telegram
ftp-resource, sftp-resource — File transfer with camel-ftp
aws-s3-resource, azure-files-resource — Cloud storage access with camel-aws-s3 and camel-azure-files

Each template demonstrates how Camel components handle the heavy lifting — protocol handling, connection management, error recovery — while Wanaku exposes the result as a clean, AI-friendly tool.

The Camel Integration Capability

Service Catalogs and Templates provide a declarative way to package Camel routes, but something needs to actually run them. That's the Camel Integration Capability — a standalone runtime service that dynamically loads and executes Camel routes on behalf of AI agents.

This capability:

Accepts Camel route YAML files deployed via the Wanaku CLI, REST API, or Kubernetes operator
Loads the routes into a Camel context
Exposes route IDs as MCP tools
Handles route lifecycle (start, stop, update)

The Camel Integration Capability is a plain Java application built using:

Apache Camel Main — for lightweight, standalone Camel route execution
Wanaku Capabilities Java SDK — for MCP protocol integration

After deploying a Service Catalog, you start the capability service separately:

java -jar camel-integration-capability-main-0.1.1-jar-with-dependencies.jar \
  --registration-url http://localhost:8080 \
  --registration-announce-address localhost \
  --grpc-port 9190 \
  --name books \
  --client-id wanaku-service \
  --service-catalog demo-catalog \
  --service-catalog-system books \
  --fail-fast

The capability service registers with the Wanaku router and the tools become available to AI agents within seconds. Download the JAR from the Camel Integration Capability releases page.

CLI Workflow: From Init to Deploy

With Wanaku running locally, the workflow for building a Service Catalog is straightforward:

# Step 1: Initialize a new service catalog
wanaku service init --name=demo-catalog --services=books

# Step 2: Edit the Camel routes (books/books.camel.yaml)
# Define your integration logic using Camel YAML DSL

# Step 3: Add dependencies (books/books.dependencies.txt)
# List the Camel components your routes need

# Step 4: Generate MCP tool definitions from route IDs
wanaku service expose --path=demo-catalog

# Step 5: Deploy to the Wanaku router
wanaku service deploy --path=demo-catalog --host=http://localhost:8080

# Step 6: Start the Camel Integration Capability to run the routes
# (see section above for the full command)

For Service Templates, you can also package and deploy reusable blueprints:

# Package a template into a ZIP archive
wanaku service package --path=weather-template -o weather-template.zip

# Deploy the template to the router
wanaku service template deploy --file=weather-template.zip --host=http://localhost:8080

This workflow mirrors the familiar Camel development experience — define routes, package, deploy — but with MCP tooling baked in.

Testing Your Tools

Once deployed, you can verify your tools are registered:

wanaku tools list

You should see output like:

name             namespace type  uri                      labels
get-book-by-isbn default   books books://get-book-by-isbn {}
search-books     default   books books://search-books     {}

Use the MCP Inspector to test your tools interactively:

npx @modelcontextprotocol/inspector

Kubernetes-Native Deployment

Service Catalogs are environment-agnostic: deploy locally via wanaku service deploy or to Kubernetes via the operator and CRDs.

For production use, Wanaku includes a Kubernetes Operator that manages Service Catalogs declaratively:

apiVersion: "wanaku.ai/v1alpha1"
kind: WanakuServiceCatalog
metadata:
  name: my-service-catalogs
spec:
  routerRef: wanaku-dev
  catalogs:
    - name: demo-catalog
      configMapRef: demo-catalog-data

The operator reads the ConfigMap containing the packaged Service Catalog and deploys it to the router automatically. This approach aligns with GitOps practices and integrates seamlessly with existing Kubernetes workflows.

Why Service Catalogs and Templates Matter

Before Wanaku 0.1.1, exposing a Camel route to an AI agent required custom REST API wrappers, manual MCP tool definitions, dependency management, and container orchestration. Service Catalogs collapse this into a single wanaku service init + wanaku service deploy workflow. Service Templates go further — turning a Kafka integration that would take hundreds of lines of boilerplate into a five-property form.

This unlocks the full power of Apache Camel for AI agents:

Camel's Integration Patterns — Enterprise Integration Patterns (EIPs), content-based routing, data transformation, error handling — all become accessible to AI agents without custom API wrappers.
Protocol Diversity — AI agents can interact with systems that don't expose modern REST APIs. Need to query an AS/400 via JT400? Poll an FTP server? Consume from a legacy JMS queue? Camel handles it.
Data Format Flexibility — Camel's type converters and data formats (Jackson, JAXB, CSV, Avro) mean AI agents can consume and produce data in the formats enterprise systems expect.
Error Handling & Resilience — Camel's error handlers, retry policies, and dead letter channels ensure robust integrations even when AI agents interact with flaky external systems.
Observability — Camel's built-in metrics, logging, and tracing integrate with standard observability stacks (Prometheus, Grafana, Jaeger), making it easy to monitor AI-driven integrations.

Getting Started

Try Wanaku 0.1.1 today:

Download the CLI: https://github.com/wanaku-ai/wanaku/releases/
Learn Wanaku from the ground up: https://wanaku.ai/docs/demos/ — step-by-step guides that take you from local experimentation all the way to production deployment on the cloud
- Demo 2.02 — Service Catalogs: Build and deploy a book search catalog step by step
- Demo 2.03 — Service Templates: Create and instantiate reusable integration blueprints
Read the Service Catalogs Guide: Service Catalogs Documentation
Read the Service Templates Guide: Service Templates Documentation

What's Next?

We're just getting started. Future releases will bring:

Simplified Camel Integration — a WanakuCamelRoute CRD that lets you deploy Camel routes directly on Kubernetes without manually packaging Service Catalogs
Hosted Agent Builder — a built-in UI and API for assembling AI agents from registered tools, selecting LLM providers, and deploying them — all from the Wanaku Admin UI
Embedded Kaoto designer — visual Camel route editing directly in the admin UI, so you can design integration routes without leaving the browser
Code Execution Engine on Kubernetes — operator support for deploying the Camel Code Execution Engine alongside the router
More Service Templates — pre-built templates for SQL databases, AWS SQS, vector search (Qdrant, Pinecone), LangChain4j AI services, and more

Join the Community

Wanaku is open source (Apache License 2.0) and built for the Apache Camel community. We'd love your feedback, contributions, and use cases:

GitHub: https://github.com/wanaku-ai/wanaku
Issues: https://github.com/wanaku-ai/wanaku/issues

By bringing Apache Camel's 20+ years of integration expertise to the AI agent ecosystem, we're making it easier than ever to connect AI to the real world — the messy, heterogeneous, protocol-diverse world that enterprises actually operate in.

Happy integrating!

DEV Community: Otavio Rodolfo Piske