Blog post featured image

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:

  1. 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.

  2. 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.

  3. 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.

  4. 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.

  5. 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:

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:

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!

About Wanaku: Wanaku is an open-source MCP router and capability management platform that enables AI agents to discover and use enterprise integrations through a unified interface. It leverages Apache Camel as the native integration runtime and supports deployment on Kubernetes/OpenShift via a dedicated operator.

Apache Camel Meets MCP: Securely Exposing Your Enterprise Routes as MCP Tools with Wanaku

 , by

The biggest challenge for enterprises in the rapidly evolving world of Generative AI isn’t just building “smarter” LLMs or agents — it’s securely connecting that AI to the decades of business logic and data locked away in enterprise systems. How do you let an AI agent interact with your Salesforce data, your Kafka topics, or your internal databases without rewriting everything or creating a massive security hole? It turns out the answer may already be running in your organization.

Continue reading ❯

AI

Apache Camel MCP Server: Bringing Camel Knowledge to AI Coding Assistants

 , by

Working with Apache Camel means dealing with over 300 components, dozens of Enterprise Integration Patterns, multiple DSL formats, and a rich set of configuration options. Keeping all of that in your head while writing integration routes is not trivial, and AI coding assistants have become a natural companion for this kind of work. The problem is that general-purpose LLMs lack deep, structured knowledge of Camel’s catalog, its component options, its URI syntax rules, and its security best practices.

Continue reading ❯

AITOOLING

Your REST APIs already speak MCP. They just don't know it yet.

 , by

Four years ago, I started writing an API Gateway. Not because I wanted to build a product — but because we needed more from the tools we had. I was working inside a government institution running a complex hybrid environment — services spread across on-premises data centers and cloud, strict security and compliance requirements, and a growing number of APIs that all needed to be managed, secured, and observed. We were using a well known API Gateway product, a capable and powerful platform, but for our use case, it was too heavy.

Continue reading ❯

USECASES

Apache Camel 4.10 What's New

 , by , , ,

Apache Camel 4.10 LTS has just been released. This release introduces a set of new features and noticeable improvements that we will cover in this blog post. Camel Core Added customize to RouteBuilder to make it easier to configure a specific Camel component / dataformat, service in a Java lambda style, such as follows: @Override public void configure() throws Exception { customize(KServeComponent.class, k -> { k.getConfiguration().setTarget("localhost:8888"); }); from("timer:kserve?repeatCount=1") .to("kserve:model/metadata?modelName=myModel") .log("${body}"); } This makes it possible for low-code users that want to have a single Java file with the Camel route and all the Java based configuration done entirely from the same configure method.

Continue reading ❯

RELEASES

Apache Camel 4.8 What's New

 , by , , ,

Apache Camel 4.8 LTS has just been released. This release introduces a set of new features and noticeable improvements that we will cover in this blog post. Camel Core The simple language has new functions such as a iif (ternary if). The @BindToRegistry now supports init/destroy methods, and can be declared as lazy as well. The log EIP can more easily configure its logger name using dynamic patterns. Add poll EIP as an easier and simpler version of pollEnrich EIP which is also more tooling friendly.

Continue reading ❯

RELEASES