DEV Community: Otavio Rodolfo Piske

Building an MCP SQL Tool That Lets LLMs Query Live Databases with Wanaku

Otavio Rodolfo Piske — Thu, 18 Jun 2026 05:04:19 +0000

AI assistants are great at reasoning, but they have a fundamental blind spot: their answers come from training data that's frozen in time. Ask an AI "what laptops do you have under $1000?" and you'll get a plausible-sounding answer — just not one that reflects what's actually in your inventory right now.

What if the AI could just... check?

That's the problem Wanaku's upcoming sql-tool service template solves. Coming in version 0.2.0, it connects AI assistants to live relational databases through the Model Context Protocol (MCP), letting them query real data instead of guessing from stale knowledge.

Wait, What's Wanaku? What's MCP?

Quick context if you're new here:

MCP (Model Context Protocol) is an open protocol that lets AI assistants use external tools, access resources, and interact with services in a standardized way. Think of it as a universal API layer for AI — instead of every AI client needing custom integrations, they can all speak MCP.
Wanaku is an open-source MCP router and capability management platform. It acts as the glue between AI clients (like Claude Desktop, Codex, or custom LLM apps) and backend services. You expose capabilities as MCP-compatible tools, and Wanaku handles routing, authentication, and service discovery.

The upcoming 0.2.0 release (PR #1358 pending merge) introduces service templates — pre-packaged capability patterns you can instantiate with just a CLI command. The sql-tool template is the first of these, and it's designed to bridge the gap between AI assistants and relational databases.

Real-Time SQL Querying vs. Vector RAG

Here's a scenario every enterprise developer has seen: you ask an AI assistant about operational data in your system, and it confidently spits out an outdated or completely fabricated metric.

The classic workaround is RAG (Retrieval-Augmented Generation) — you pre-index your data, convert it into vector embeddings, and store it in a vector database for the AI to search. That works beautifully for text documents, wikis, and static datasets.

The RAG Limitation

What about live operational data? Your shifting inventory, current customer orders, or real-time application metrics change too fast for vector syncs. You don't want to pre-index that data — you want the LLM to query it on-demand via SQL.## The Solution: Exposing SQL Queries as MCP Tools

The sql-tool template packages everything a developer needs to securely expose a live SQL database query as an executable MCP tool:

An Apache Camel route that executes safe queries against your target data store.
An MCP tool definition that compatible AI clients can dynamically discover and call.
Pre-packaged runtime dependencies (including JDBC drivers, SQL components, and JSON marshalling).
Support for parameterizing AI inputs into dynamic SQL queries via Camel Simple expressions.

You provide the database connection details and the baseline query syntax; the Wanaku gateway handles the rest.

Step-by-Step Guide: Connecting an LLM to PostgreSQL

Here is a preview of how to instantiate the SQL template once 0.2.0 ships. In this example, we have a PostgreSQL database containing a live product catalog, and we want our AI assistant to accurately answer: "What laptops do you have under $800?"

Step 1: Deploy the PostgreSQL Database Container

Spin up a local PostgreSQL instance using Podman (Docker commands work identically here):

podman run --rm --name wanaku-postgres \
  -p 5432:5432 \
  -e POSTGRES_PASSWORD=wanaku \
  postgres

Load your schema and data:

podman exec -i wanaku-postgres psql -U postgres -d postgres < sql-tool-demo.sql

You can download the demo SQL script from the Wanaku website.

Step 2: Instantiate the Wanaku SQL Tool Template

Now, expose your live database to the MCP network by mapping the AI's input to a dynamic SQL query:

wanaku service template instantiate \
  --name sql-tool \
  --property forage.jdbc.username=postgres \
  --property forage.jdbc.password=wanaku \
  --property sql.query='SELECT name, price FROM products WHERE price < ${body} ORDER BY price' \
  --service-name product-catalog \
  --service-system product-catalog

Notice the ${body} placeholder in the query? That's a Camel Simple expression. At runtime, it gets replaced with whatever input the AI sends. So when a user asks "what laptops are under $800?", the AI calls the tool with 800 as input, and the query becomes:

SELECT name, price FROM products WHERE price < 800 ORDER BY price

This is the key insight: the SQL template doesn't run static queries — it accepts dynamic input from the AI, making it a true interactive tool.

Step 3: Verify the Catalog Deployment

Ensure your new service is correctly registered in the local capability catalog:

wanaku service catalog list

You can also confirm your live data store connectivity entries using:

wanaku data-store list --plain

Step 4: Querying Live Data via Your AI Client

Point any MCP-compatible AI client (such as Claude Desktop or Continue.dev) at your local Wanaku router gateway. The LLM will automatically discover the product-catalog schema tool capability and query the database directly.

No hallucinations. No stale data lakes. Just direct, deterministic SQL results parsed instantly by the LLM.

How It Works Under the Hood

When an AI assistant invokes the generated database tool, the orchestration pipeline executes across these layers:

Tool Invocation: The AI client sends an MCP payload containing the user's filtered variables.
Routing: Wanaku maps the request to the underlying Apache Camel SQL endpoint.
Parameter Injection: The ${body} runtime expression safely binds the AI's variables to the SQL execution context.
Execution: The statement runs natively against your PostgreSQL deployment.
Serialization: The rows are marshalled into a structured JSON string payload.
Response Generation: The LLM receives the raw JSON and translates it into a natural language response for the user.

The template wires all of this automatically — you just provide the query and connection details.

Parameterizing AI Prompts with Dynamic SQL

Since the sql-tool template is built on the Apache Camel SQL component, you can use any expression the component supports.

Simple value substitution:

SELECT * FROM products WHERE category_id = ${body}

Named parameters with headers:

SELECT * FROM products WHERE price < :#maxPrice AND category_id = :#category

For more advanced patterns, refer to the Camel SQL documentation.

Why This Matters

This demo is small — three tables, ten products — but the pattern scales to real-world use cases:

Customer support bots: query order history, account status, or ticket details in real time
Internal tools: let AI assistants search employee directories, project databases, or asset inventories
Analytics and reporting: expose reporting queries as MCP tools so AI can pull fresh metrics on demand
Developer productivity: connect AI code assistants to your test databases for context-aware suggestions

The point isn't the query. It's that the AI is no longer guessing — it's checking.

When Can You Try It?

The sql-tool template is part of the upcoming Wanaku 0.2.0 release, currently pending the merge of PR #1358. Once it ships:

Install Wanaku
Follow the setup steps above to instantiate the template
Connect your MCP-compatible AI client to the Wanaku router

If you want to try it before the official release, you can build Wanaku from the PR branch or use one of the early-builds.

Get Involved

Wanaku is open source, and we'd love your input:

⭐ Star the project on GitHub to help others discover it
💡 Have a template idea? Check the contributing guide
🐛 Found a bug or have feedback? Open an issue on GitHub

The sql-tool template is just the beginning — we're building a library of reusable capability patterns that make it trivial to connect AI assistants to real systems. If you're excited about that vision, come build with us.

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!

Ebook: Camel Passo a Passo

Otavio Rodolfo Piske — Sat, 28 Nov 2020 16:02:49 +0000

Começando meu primeiro post no dev.to para compartilhar o link de um ebook, em português, sobre integração de sistemas com Apache Camel.