Docs • Quickstart • Examples • Demos • Blog

---

Zilla is a stateless, multi-protocol gateway for event-driven applications and AI agents.

It provides two gateway surfaces through one protocol-native engine:

• Event Gateway — expose Apache Kafka® and MQTT to applications, services, and devices over HTTP, SSE, gRPC, MQTT, or WebSocket.
• MCP Gateway — give AI agents one governed MCP endpoint for MCP servers, HTTP APIs, OpenAPI services, and Apache Kafka.

Both are configured in a single zilla.yaml and share the same routing, identity, authorization, schema, telemetry, and deployment infrastructure.

Zilla is evolving into a unified Event and AI Gateway. Zilla 2.0 extends the same streaming-native, multi-protocol engine that powers the Event Gateway with native MCP capabilities for connecting, governing, and observing AI agents.

⭐ Star this repository to follow new capabilities, examples, and Zilla 2.0 release updates.

Why Zilla?

Browsers do not speak Kafka. IoT clients may use MQTT while the system of record uses Kafka. AI agents may need capabilities spread across MCP servers, APIs, and event streams, each with its own endpoint, credential, schema, and telemetry model.

Zilla replaces custom protocol bridges, per-provider MCP wrappers, authentication glue, and fragmented instrumentation with declarative gateway routes. Zilla is designed for exceptional scalability, adding minimal latency and throughput overhead when proxying protocols. (see architecture).

Get Started

Prerequisite: Docker Compose

git clone https://github.com/aklivity/zilla.git
cd zilla/examples

Path 1: Event Gateway — REST over Kafka

docker compose --project-directory http.kafka.crud up -d

curl -X POST http://localhost:7114/items \
  -H 'Content-Type: application/json' \
  -d '{"name": "widget", "price": 9.99}'

curl http://localhost:7114/items

View the records in Kafka UI.

Path 2: MCP Gateway — one endpoint for multiple providers

docker compose --project-directory mcp.proxy up -d

Connect an MCP client that supports Streamable HTTP to:

http://localhost:7114/mcp

Zilla aggregates the configured providers into one namespaced capability catalog and routes each request to the correct MCP server, API, or Kafka cluster.

Check MCP metrics:

curl http://localhost:7190/metrics

→ AI Gateway quickstart
→ Browse all examples

Two Gateway Surfaces

Capability	What Zilla does
Event access	Exposes Kafka through application-friendly protocols
MCP federation	Combines multiple providers behind one virtual MCP server
Toolkit routing	Namespaces capabilities and routes each call to the correct backend
HTTP and OpenAPI	Exposes existing APIs as MCP tools and resources
Kafka for agents	Exposes Kafka operations directly through the native MCP–Kafka binding
Authentication	Validates the agent identity at the gateway
Authorization	Controls access to endpoints, toolkits, tools, prompts, and resources
Context control	Supports cached listings plus eager and cold tool discovery
Guardrails	Validates and transforms JSON, Avro, and Protobuf payloads
Observability	Records MCP metrics, durations, outcomes, and lifecycle events
Scaling	Keeps request processing stateless and externalizes shared state when needed

🆕 MCP Gateway

Zilla can connect an agent-facing MCP endpoint to:

• existing MCP servers;
• HTTP APIs;
• OpenAPI-described services;
• Apache Kafka.

Capabilities are namespaced as:

<toolkit>__<capability>

For example:

github__create_pr
payments__refund
kafka__produce_message

The toolkit selects the route and avoids naming collisions across providers.

Zilla can authenticate the agent once, filter capability listings by authorization, and forward or exchange credentials for upstream services. Zilla Plus adds advanced OAuth grants and shared Redis or Hazelcast stores for multi-replica deployments.

Large catalogs can be divided into eager and cold tools so agents load only the capabilities they need. Zilla can also relay MCP elicitation, apply schema guardrails, and export telemetry without requiring changes to agents or upstream providers.

→ MCP Gateway architecture
→ Security
→ Guardrails
→ Observability
→ Configuration reference

Architecture

Zilla uses a protocol-native streaming engine designed to minimize allocation, copying, and cross-thread coordination.

• Code-generated flyweights provide typed access over encoded buffers.
• Each connection remains assigned to one worker for its lifetime.
• Bindings exchange back-pressured stream frames through shared memory.
• Cache-enabled Kafka routes can fetch once and serve many downstream consumers.
• MCP listing and authorization state can be externalized for multi-replica consistency.

→ How Zilla Works

Editions

Zilla Community includes the core Event Gateway and MCP Gateway.

Zilla Plus adds advanced OAuth, distributed stores, secure Kafka access, virtual clusters, and commercial support. Visit aklivity.io for more details.

Install

Docker

docker pull ghcr.io/aklivity/zilla:latest

docker run --rm \
  -p 7114:7114 \
  -v "$(pwd)/zilla.yaml:/etc/zilla/zilla.yaml:ro" \
  ghcr.io/aklivity/zilla:latest \
  start -v

Helm

helm install zilla oci://ghcr.io/aklivity/charts/zilla \
  --namespace zilla \
  --create-namespace \
  --wait \
  --values values.yaml \
  --set-file zilla\\.yaml=zilla.yaml

Resources

• 📖 Documentation
• ✨ AI Gateway
• ⚡ Quickstart
• 🧪 Examples
• 🎬 Demos
• 🗺️ Roadmap
• 💬 Discord Server
• 💬 Community Slack
• 🐛 GitHub Issues
• 🦎 Contributing

License

Zilla is made available under the Aklivity Community License.

The license allows you to deploy, run, and modify Zilla for your own workloads, including production and cloud deployments. It does not permit offering Zilla as a standalone commercial Zilla-as-a-service product.

Review the license text for the complete terms.

(🔼 Back to top)