This is an automated email from the ASF dual-hosted git repository.
orpiske pushed a commit to branch main
in repository https://gitbox.apache.org/repos/asf/camel-website.git
The following commit(s) were added to refs/heads/main by this push:
new 1cfa7d47 chore: add Wanaku 0.1.1 release blog post
1cfa7d47 is described below
commit 1cfa7d47c17c38eb8e75318e370e7ae0d59c3ece
Author: Otavio Rodolfo Piske <[email protected]>
AuthorDate: Tue May 26 13:55:22 2026 +0200
chore: add Wanaku 0.1.1 release blog post
---
content/blog/2026/05/wanaku-0.1.1/featured.jpeg | Bin 0 -> 824555 bytes
content/blog/2026/05/wanaku-0.1.1/index.md | 357 ++++++++++++++++++++++++
2 files changed, 357 insertions(+)
diff --git a/content/blog/2026/05/wanaku-0.1.1/featured.jpeg
b/content/blog/2026/05/wanaku-0.1.1/featured.jpeg
new file mode 100644
index 00000000..dc347000
Binary files /dev/null and b/content/blog/2026/05/wanaku-0.1.1/featured.jpeg
differ
diff --git a/content/blog/2026/05/wanaku-0.1.1/index.md
b/content/blog/2026/05/wanaku-0.1.1/index.md
new file mode 100644
index 00000000..154e8643
--- /dev/null
+++ b/content/blog/2026/05/wanaku-0.1.1/index.md
@@ -0,0 +1,357 @@
+---
+title: "Wanaku 0.1.1: Bringing Apache Camel Integration Capabilities to AI
Agents via MCP"
+date: 2026-05-31
+draft: false
+authors: [ orpiske ]
+categories: ["Releases", "Camel", "AI"]
+preview: "Wanaku 0.1.1: Service Catalogs and Service Templates bring Apache
Camel's integration power to AI agents through the Model Context Protocol"
+---
+
+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](https://github.com/wanaku-ai/wanaku/releases/tag/wanaku-0.1.1), just run:
+
+```shell
+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:
+
+```text
+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:
+
+```yaml
+- 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](https://kaoto.io) or
[Camel Karavan](https://github.com/apache/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:
+
+```shell
+wanaku service expose --path=demo-catalog
+```
+
+This scans each Camel route file and generates a corresponding
`wanaku-rules.yaml`:
+
+```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`:
+
+```text
+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:**
+```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:**
+```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:
+
+```shell
+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](https://github.com/wanaku-ai/camel-integration-capability/releases/tag/v0.1.1).
+
+## CLI Workflow: From Init to Deploy
+
+With Wanaku running locally, the workflow for building a Service Catalog is
straightforward:
+
+```shell
+# 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:
+
+```shell
+# 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:
+
+```shell
+wanaku tools list
+```
+
+You should see output like:
+
+```text
+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](https://github.com/modelcontextprotocol/inspector) to
test your tools interactively:
+
+```shell
+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:
+
+```yaml
+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:
+
+- **Download the CLI:**
[https://github.com/wanaku-ai/wanaku/releases/tag/wanaku-0.1.1](https://github.com/wanaku-ai/wanaku/releases/tag/wanaku-0.1.1)
+- **Learn Wanaku from the ground up:**
[https://github.com/wanaku-ai/wanaku-demos](https://github.com/wanaku-ai/wanaku-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](https://github.com/wanaku-ai/wanaku-demos/tree/main/2.02-service-catalogs):
Build and deploy a book search catalog step by step
+ - [Demo 2.03 — Service
Templates](https://github.com/wanaku-ai/wanaku-demos/tree/main/2.03-service-templates):
Create and instantiate reusable integration blueprints
+- **Read the Service Catalogs Guide:** [Service Catalogs
Documentation](https://github.com/wanaku-ai/wanaku/blob/main/docs/service-catalogs.md)
+- **Read the Service Templates Guide:** [Service Templates
Documentation](https://github.com/wanaku-ai/wanaku/blob/main/docs/service-templates.md)
+
+## 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](https://github.com/wanaku-ai/wanaku)
+- **Issues:**
[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!
+
+---
+
+*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.*
