Overview

Wanaku MCP Router is an SSE (Server-Sent Events) based routing engine that implements the Model Context Protocol (MCP) to connect AI agents, tools, and enterprise systems in real time. It sits between model-driven agents and external services, forwarding context, events, and tool calls using an extensible routing model so that AI-powered workflows can react to streaming inputs and coordinate multiple tools or microservices.

The server is useful when you need low-latency, scalable integrations that preserve streaming context (for example, agent tool calls, predictions, or telemetry) and route those messages to the correct backend services. By relying on SSE for continuous event delivery and a modular connector architecture, Wanaku MCP Router enables developers to expose tools, loggers, and enrichment services to AI agents without tight coupling to a single provider or transport.

Features

SSE-first routing: leverages Server-Sent Events for one-way real-time updates and streaming context.
Extensible connectors: plug new tools and backends via a connector interface or simple HTTP/webhook adapters.
Protocol-aware: works with Model Context Protocol (MCP) messages to route tool calls, responses, and events.
Config-driven routing: declare routes and policies through configuration files or environment variables.
Lightweight and production-friendly: can be run as a binary or container, suitable for deployment in cloud or on-premises environments.
Observability hooks: integrates with logging and metrics backends to trace routed messages and performance.

Installation / Configuration

Clone the repository and run the server locally, or use the provided Docker image.

Clone source

git clone https://github.com/wanaku-ai/wanaku.git
cd wanaku

Build and run (if a Go binary or build script is provided)

# Example: build and run (adjust to actual repo build steps)
make build
./wanaku-mcp-router --config ./config/router.yaml

Run with Docker

# Pull and run the container (replace image name with the project's image)
docker run -p 8080:8080 \
  -e WANAKU_CONFIG=/etc/wanaku/router.yaml \
  -v $(pwd)/config:/etc/wanaku \
  wanaku/wanaku-mcp-router:latest

Minimum environment variables (example)

export WANAKU_BIND_ADDR="0.0.0.0:8080"
export WANAKU_LOG_LEVEL="info"
export WANAKU_CONFIG="/etc/wanaku/router.yaml"

Example router configuration (YAML)

# config/router.yaml
server:
  bind: "0.0.0.0:8080"

routes:
  - id: tools
    match: "mcp.tool.*"
    target: "http://tools.internal:9000/handle"
  - id: logs
    match: "mcp.event.logging"
    target: "http://logs.internal:9200/ingest"
connectors:
  - name: http-webhook
    type: webhook
    timeout: 10s

Configuration keys (summary)

Key	Description
server.bind	Address and port to listen on
routes	Routing table mapping MCP message types to target endpoints
connectors	Connector definitions (types: webhook, grpc, custom)
logging	Log level and output settings

Available Resources

Source code and issue tracker: https://github.com/wanaku-ai/wanaku/
Example configs and adapter templates: (look in the repo’s examples/ or connectors/ directories)
SSE client libraries: native EventSource (browser), eventsource (Node.js), or curl for manual testing

Quick SSE test (curl)

# Subscribe to a named stream (replace endpoint)
curl -N http://localhost:8080/stream/agents

Node.js SSE client example

import EventSource from "eventsource";

const es = new EventSource("http://localhost:8080/stream/agents");
es.onmessage = (msg) => {
  const data = JSON.parse(msg.data);
  console.log("MCP event:", data);
};
es.onerror = (err) => {
  console.error("SSE error:", err);
};

Use Cases

Tool orchestration for LLM agents: Route model-initiated tool calls (e.g., search, database query, or action invocation) to the appropriate microservice connectors and stream responses back to the agent.
Multi-agent coordination: Deliver contextual events and state updates to several agents or services concurrently using SSE channels so agents can act on near-real-time signals.
Enterprise system integration: Expose internal APIs (CRM, ticketing, or ERP) as MCP tools with configurable authentication and rate limiting while keeping AI agents decoupled from backend specifics.
Observability and audit trails: Route MCP events to logging and metrics endpoints to build an audit log of model interactions and tool usage for compliance and debugging.
Enrichment and preprocessing: Insert enrichment pipelines that intercept MCP messages to add metadata, normalize inputs, or apply policy checks before forwarding to tools.

Getting started tips

Start with a single route and a simple webhook connector to validate end-to-end messaging.
Use the SSE stream to monitor events in real time during development.
Add authentication and rate limiting on connector endpoints for production deployments.
Iterate on route matching rules to avoid unintended routing and to keep traffic predictable.

For code samples, advanced configuration patterns, and connector templates, see the repository: https://github.com/wanaku-ai/wanaku/

Wanaku MCP Router: SSE-based Extensible MCP Server