Skip to content
Back to search

zilla

🦎 A lightweight, streaming-native, multi-protocol gateway for AI, APIs, and real-time data. Route LLM requests across providers, govern MCP tools, and connect Kafka, MQTT, and HTTP through one high-performance engine with shared security and observability.

Safety scan

A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.

Checked today

Check it deeper on your machine

It has changed since its scan on 11 Nov 2026.

As a Claude Code plugin, install it and then ask Claude Code:

/plugin marketplace add keithmackay/mackayi/plugin install scanskillsafety@mackayiDo a deep scan of https://github.com/aklivity/zilla with scanskillsafety

Or from a terminal, clone it and run it:

git clone https://github.com/keithmackay/scanskillsafety-skill ~/.claude/skills/scanskillsafetynode ~/.claude/skills/scanskillsafety/cli.cjs --deep 'https://github.com/aklivity/zilla'

It checks the exact commit: every file, its packages against OSV (api.osv.dev), how it compares with this page's scan (findsafeskills.com receives the repository's address), and, if you agree, Claude reading every file with your own Claude subscription. It never runs the code.

Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/aklivity--zilla/badge.svg)](/listings/aklivity--zilla)

HTML

<a href="/listings/aklivity--zilla"><img src="/api/listings/aklivity--zilla/badge.svg" alt="findsafeskills safety rating" /></a>

Install

i

Install instructions from the README

As written by the repo's author. findsafeskills has not verified these steps.

For a guided first experience, use the [LLM quickstart](#1-try-the-llm-gateway) above. The commands below run Zilla with a configuration you supply; they do not generate a working `zilla.yaml` for you.

Docker

docker pull ghcr.io/aklivity/zilla:2.6.0

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

Adjust published ports to match the listeners in your configuration.

Kubernetes / Helm

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

Choose chart settings and gateway image version appropriate for your deployment. See the [deployment documentation](https://docs.aklivity.io/latest/).

What was scanned

The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.

README.md · README · 265 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

This file has changed since it was scanned, so this is not exactly the text that was scanned, and no line is marked. The findings are listed with the safety scan above.

  1. <div id="top"></div>
  2. <div align="center">
  3. <!-- <img src="./assets/zilla-hero-diagram-dark.png" height="450"> -->
  4. <picture>
  5. <!-- Source for dark mode -->
  6. <source media="(prefers-color-scheme: dark)" srcset="./assets/zilla-gateway-lockup-dark.png">
  7. <source media="(prefers-color-scheme: light)" srcset="./assets/zilla-gateway-lockup-light.png">
  8. <!-- Fallback image for light mode and other clients -->
  9. <img src="./assets/zilla-gateway-lockup-light.png" width="600">
  10. </picture>
  11. </div>
  12. <div align="center">
  13. <!--[![Build Status][build-status-image]][build-status]-->
  14. [![Latest Release][release-latest-image]][release-latest]
  15. [![Slack Community][community-image]][community-join]
  16. [![Artifact HUB][artifact-hub-shield]][artifact-hub]
  17. </div>
  18. <div align="center">
  19. <a href="https://docs.aklivity.io/latest/">Docs</a> &bull;
  20. <a href="https://docs.aklivity.io/latest/ai-gateway/get-started/">Quickstart</a> &bull;
  21. <a href="/examples">Examples</a> &bull;
  22. <a href="https://github.com/aklivity/zilla-demos">Demos</a> &bull;
  23. <a href="https://www.aklivity.io/blog">Blog</a>
  24. </div>
  25. <br></br>
  26. >
  27. > Before moving on, please consider giving us a GitHub star ⭐️. Thank you!
  28. >
  29. * * * * *
  30. **Zilla is a streaming-native, multi-protocol gateway for AI, APIs, and real-time data.**
  31. Connect applications to LLMs, give AI agents governed access to enterprise tools, and expose Kafka streams through application-friendly protocols. Zilla provides protocol translation, routing, security, and observability in a lightweight, stateless runtime, configured declaratively in `zilla.yaml`.
  32. **One engine, many use cases.** LLM access, MCP tool connectivity, and event streaming are different routes through the same gateway, not separate proxy products to deploy and operate.
  33. ## Contents
  34. - [What You Can Build](#what-you-can-build)
  35. - [Why One Multi-Protocol Gateway?](#why-one-multi-protocol-gateway)
  36. - [Get Started](#get-started)
  37. - [How Zilla Works](#how-zilla-works)
  38. - [Governance in the Data Path](#governance-in-the-data-path)
  39. - [Streaming-Native by Design](#streaming-native-by-design)
  40. - [Capabilities at a Glance](#capabilities-at-a-glance)
  41. - [Zilla Plus and Zilla Console](#zilla-plus-and-zilla-console)
  42. - [Install and Deploy](#install-and-deploy)
  43. - [Documentation and Examples](#documentation-and-examples)
  44. - [Community and Contributing](#community-and-contributing)
  45. - [License](#license)
  46. ## What You Can Build
  47. ### ⚡ Connect and govern real-time data
  48. Expose Kafka through REST, SSE, WebSocket, gRPC, and MQTT without building custom protocol bridges. Validate schemas, control access, and connect browsers, services, and devices to event streams. With **Zilla Plus**, transparently proxy native Kafka clients and Kafka Connect, including across network boundaries.
  49. **Explore:** [Kafka Gateway](https://docs.aklivity.io/latest/kafka-gateway/) · [Kafka use cases](https://docs.aklivity.io/latest/kafka-gateway/use-cases/) · [REST example](./examples/http.kafka.crud/)
  50. ### ✨ Connect applications to LLMs
  51. Keep using supported OpenAI, Anthropic, and Gemini SDKs while Zilla routes requests to the right model provider. Translate supported chat and tool-call workflows across APIs, stream responses, apply configurable guardrails, and observe token usage and latency. Configure fallback for unreachable model deployments.
  52. **Explore:** [LLM Gateway](https://docs.aklivity.io/latest/ai-gateway/llm-gateway/) · [Cross-provider demo](https://github.com/aklivity/zilla-demos/tree/main/llm.gateway)
  53. ### 🤖 Give AI agents governed access to tools and data
  54. Present one MCP endpoint for existing MCP servers, HTTP/OpenAPI services, and Kafka. Expose Kafka topics, Kafka Connect, and Schema Registry operations as MCP tools without custom wrapper services. Authorize what each caller can discover and invoke, and keep large tool catalogs manageable with eager and on-demand discovery.
  55. **Explore:** [MCP Gateway](https://docs.aklivity.io/latest/ai-gateway/mcp-gateway/) · [MCP example](./examples/mcp.proxy/)
  56. ## Why One Multi-Protocol Gateway?
  57. Kafka and AI solve different problems. Kafka moves real-time data, LLM APIs connect applications to models, and MCP connects agents to tools. But the infrastructure needed to connect them has much in common: **routing, identity, access control, protocol mediation, policy enforcement, and observability**.
  58. Zilla was built as a streaming-native, multi-protocol engine rather than a collection of standalone proxies. Protocol-aware bindings connect clients and backends, while routing, security, telemetry, and declarative configuration are managed through the same runtime. Each protocol retains its own semantics and specialized controls.
  59. That architecture matters both when these workloads are separate and when they intersect. Use Zilla to govern LLM access without Kafka, to expose Kafka without AI, or to connect them directly—for example, letting an agent discover and invoke Kafka-backed tools through MCP without building a custom integration service.
  60. **Use either capability on its own. Combine them when your applications need both.**
  61. ## Get Started
  62. Run Zilla locally with Docker Compose and expose a Kafka topic as a REST API. The example starts Zilla, Kafka, and Kafka UI; no external service credentials are required.
  63. **Prerequisite:** Docker with Docker Compose.
  64. ```bash
  65. git clone --depth 1 --branch 2.6.0 https://github.com/aklivity/zilla.git
  66. cd zilla/examples/http.kafka.crud
  67. docker compose up --wait
  68. ```
  69. Produce a record over HTTP, then retrieve it by key:
  70. ```bash
  71. curl -i -X POST http://localhost:7114/items \
  72. -H 'Idempotency-Key: hello' \
  73. -H 'Content-Type: application/json' \
  74. -d '{"message":"Hello from Zilla"}'
  75. curl http://localhost:7114/items/hello
  76. ```
  77. Zilla maps the request to Kafka without an application service in between. Inspect the topic in [Kafka UI](http://localhost:8080/ui/clusters/local/all-topics). Stop the stack with `docker compose down`.
  78. **Prefer an AI example?** [Try the MCP Gateway](https://docs.aklivity.io/latest/ai-gateway/get-started/) or [run the cross-provider LLM demo](https://github.com/aklivity/zilla-demos/tree/main/llm.gateway).
  79. ## How Zilla Works
  80. Zilla is built from composable, protocol-aware **bindings**. An inbound binding accepts a protocol, routes and configured guards determine what is permitted, and an outbound binding connects to the destination. The same runtime can map HTTP/SSE/MQTT/gRPC to Kafka, expose APIs and Kafka as MCP tools, or route LLM API calls across providers.
  81. <img src="./assets/zilla-gateway-architecture.png" alt="Zilla multi-protocol gateway architecture" width="760">
  82. The same architecture supports an **AI SDK → LLM provider**, an **AI agent → MCP → Kafka**, or an **HTTP client → Kafka** route. Protocol-specific bindings and policies determine which combinations are supported; these are not interchangeable protocols or separate gateway runtimes.
  83. Routes are defined in `zilla.yaml`. For example, this excerpt maps an HTTP endpoint to a Kafka topic:
  84. ```yaml
  85. bindings:
  86. api_to_events:
  87. type: http-kafka
  88. kind: proxy
  89. routes:
  90. - when:
  91. - method: POST
  92. path: /events
  93. exit: kafka_cache_client
  94. with:
  95. capability: produce
  96. topic: events
  97. key: ${idempotencyKey}
  98. ```
  99. One declarative configuration defines protocol connectivity and the controls applied along each route. Zilla runs as a stateless data plane; optional external stores support features that require shared state across replicas.
  100. [How Zilla Works](https://www.aklivity.io/post/how-zilla-works) · [Configuration reference](https://docs.aklivity.io/latest/reference/2.x/)
  101. ## Governance in the Data Path
  102. Zilla applies protocol-aware controls where traffic crosses a system boundary, instead of requiring every application, agent, or integration to implement them independently.
  103. | Control | What you can enforce or observe |
  104. | --- | --- |
  105. | **Identity and access** | Authenticate callers with supported guards, TLS/mTLS, and provider credentials; authorize model routes and MCP tool discovery and invocation. |
  106. | **Schema and API contracts** | Validate supported JSON, Avro, and Protobuf payloads; apply OpenAPI and AsyncAPI-driven configuration and transformations. |
  107. | **LLM guardrails** | Check configured prompt and response sections for policy violations, including secrets, personal data, and other classified content. |
  108. | **Data protection** | Apply field-level encryption, masking, and conditional disclosure for supported Kafka workflows with Zilla Plus. |
  109. | **Observability** | Export gateway and protocol metrics, MCP interactions, LLM token usage, and logs to supported telemetry systems. |
  110. Policies are configured per protocol and route; not every control applies to every kind of traffic. [Explore AI security](https://docs.aklivity.io/latest/ai-gateway/) · [Kafka governance](https://docs.aklivity.io/latest/kafka-gateway/) · [Monitoring and observability](https://docs.aklivity.io/latest/ai-gateway/monitoring-observability/)
  111. ## Streaming-Native by Design
  112. Zilla's runtime is designed for continuous, high-throughput traffic as well as request/response workloads.
  113. - **Backpressure-aware streaming:** Data flows through protocol bindings without requiring whole messages or streams to be buffered unnecessarily.
  114. - **Efficient data processing:** Code-generated flyweights operate on encoded buffers while minimizing copying, allocation, and cross-worker contention.
  115. - **Stateless horizontal scaling:** Run independent gateway instances in containers or Kubernetes; configure shared stores only for capabilities that need them.
  116. - **One operational model:** Deploy and observe LLM, MCP, API, and event-streaming routes through the same engine and declarative configuration.
  117. Explore the [architecture](https://www.aklivity.io/post/how-zilla-works) and [Kafka performance benchmarks](https://www.aklivity.io/post/zilla-plus-on-confluent-cloud-aklivity-zilla-benchmark-series-part-2).
  118. ## Capabilities at a Glance
  119. | Area | Capabilities |
  120. | --- | --- |
  121. | **Protocols** | Kafka, HTTP, SSE, WebSocket, gRPC, MQTT, MCP, and supported LLM APIs |
  122. | **LLM connectivity** | OpenAI, Anthropic, and Gemini; model-based routing, streaming, supported dialect translation, and unreachable-deployment fallback |
  123. | **MCP connectivity** | Aggregate MCP servers; expose HTTP/OpenAPI, Kafka, Kafka Connect, and Schema Registry capabilities as tools and resources |
  124. | **Kafka integration** | HTTP/MQTT/gRPC/SSE mediation, schema validation, and Kafka-backed API patterns |
  125. | **Security and policy** | TLS, JWT-based guards, authorization, schema enforcement, and configurable LLM guardrails |
  126. | **Telemetry** | Metrics and logs with Prometheus, OTLP, and other supported exporters |
  127. | **Deployment** | Docker, Kubernetes/Helm, and local installation; declarative `zilla.yaml` configuration |
  128. Some features and integrations require **Zilla Plus**. See the [edition capability matrix](https://docs.aklivity.io/latest/reference/editions/capability-matrix/).
  129. ## Zilla Plus and Zilla Console
  130. **Zilla Community** includes the multi-protocol runtime, Kafka protocol mediation, MCP and LLM gateway capabilities, and core security, schema, and observability features.
  131. **Zilla Plus** adds enterprise capabilities, including:
  132. - Transparent **Kafka-to-Kafka proxying** for existing producers, consumers, and Kafka Connect clients, without changing the client protocol.
  133. - **Virtual Kafka clusters**, dynamic topic aliases, and secure public or private Kafka access across VPCs and cloud accounts.
  134. - **Field-level data protection** and additional enterprise security and identity integrations.
  135. - **Additional LLM providers:** Amazon Bedrock, Azure AI Foundry, and Google Vertex AI.
  136. - Advanced MCP tool-discovery policies, distributed stores, and commercial support.
  137. **Zilla Console** is an optional management and governance layer, available as an add-on with Plus and included with Enterprise. It provides gateway and Kafka observability, API/data product catalogs, managed access, self-service subscriptions, and audit workflows. Zilla does not require Console to run.
  138. [Compare editions](https://docs.aklivity.io/latest/reference/editions/capability-matrix/) · [Explore Zilla Console](https://docs.aklivity.io/latest/zilla-console/) · [Request a Zilla Plus license](https://www.aklivity.io/contact) · [AWS Marketplace](https://aws.amazon.com/marketplace/pp/prodview-lqfqftufwpttm)
  139. ## Install and Deploy
  140. The quickstart above runs a complete example stack. For your own configuration, supply a valid `zilla.yaml` and publish ports that match its listeners.
  141. ### Docker
  142. ```bash
  143. docker pull ghcr.io/aklivity/zilla:2.6.0
  144. docker run --rm \
  145. -p 7114:7114 \
  146. -v "$(pwd)/zilla.yaml:/etc/zilla/zilla.yaml:ro" \
  147. ghcr.io/aklivity/zilla:2.6.0 start -v
  148. ```
  149. ### Kubernetes / Helm
  150. After preparing your `zilla.yaml` and Helm values:
  151. ```bash
  152. helm install zilla oci://ghcr.io/aklivity/charts/zilla \
  153. --namespace zilla \
  154. --create-namespace \
  155. --wait \
  156. --values values.yaml \
  157. --set-file 'zilla\.yaml=zilla.yaml'
  158. ```
  159. For local installation, container options, Kubernetes configuration, and production deployment guidance, see [Deploy & Configure](https://docs.aklivity.io/latest/deployment/).
  160. ## Documentation and Examples
  161. - **Start here:** [Documentation](https://docs.aklivity.io/latest/) · [Examples](./examples/) · [End-to-end demos](https://github.com/aklivity/zilla-demos)
  162. - **AI:** [LLM Gateway](https://docs.aklivity.io/latest/ai-gateway/llm-gateway/) · [MCP Gateway](https://docs.aklivity.io/latest/ai-gateway/mcp-gateway/) · [Tool discovery](https://docs.aklivity.io/latest/ai-gateway/mcp-gateway/tool-discovery/)
  163. - **Real-time data:** [Kafka Gateway](https://docs.aklivity.io/latest/kafka-gateway/) · [Kafka use cases](https://docs.aklivity.io/latest/kafka-gateway/use-cases/)
  164. - **Reference:** [Configuration](https://docs.aklivity.io/latest/reference/2.x/) · [Editions](https://docs.aklivity.io/latest/reference/editions/) · [Releases](https://github.com/aklivity/zilla/releases)
  165. ## Community and Contributing
  166. Questions, feedback, and contributions are welcome.
  167. - [Join the community on Slack](https://www.aklivity.io/slack)
  168. - [Report an issue or request a feature](https://github.com/aklivity/zilla/issues)
  169. - [Read the contributing guide](./.github/CONTRIBUTING.md)
  170. - [Follow the roadmap](https://github.com/orgs/aklivity/projects/4/views/1)
  171. If Zilla is useful to you, consider [starring the repository](https://github.com/aklivity/zilla).
  172. ## License
  173. Zilla Community is **source-available** under the [Aklivity Community License](./LICENSE-AklivityCommunity); select components carry Apache License 2.0. The Community License allows you to use, modify, and distribute Zilla, subject to its terms and a restriction on offering competing hosted services. Review the [license](./LICENSE-AklivityCommunity) for complete terms.
  174. <!-- Badge links -->
  175. [community-image]: https://img.shields.io/badge/slack-@aklivitycommunity-blue.svg?logo=slack
  176. [community-join]: https://www.aklivity.io/slack
  177. [artifact-hub-shield]: https://img.shields.io/endpoint?url=https://artifacthub.io/badge/repository/zilla
  178. [artifact-hub]: https://artifacthub.io/packages/helm/zilla/zilla
  179. [release-latest-image]: https://img.shields.io/github/v/release/aklivity/zilla?label=release&sort=semver
  180. [release-latest]: https://github.com/aklivity/zilla/releases
  181. <p align="right">(<a href="#top">Back to top</a>)</p>

Ratings and comments

Sign in to rate this skill.

Sign in

Free to use. If it’s helped, pass it on.