zilla MCPサーバー
コミット 2026年11月15日LLMリクエストのルーティング、MCPツールの管理、そしてKafka、MQTT、HTTPを単一のエンジンで接続するマルチプロトコルゲートウェイです。
別名 aklivity/zilla
- スター
- 1,692
- ツール
- —
- ダウンロード数(30日間)
- —
- 最新バージョン
- —
- 最終コミット
- 2026年11月15日
- ライセンス
- —
zilla MCPとは
LLMリクエストのルーティング、MCPツールの管理、そしてKafka、MQTT、HTTPを単一のエンジンで接続するマルチプロトコルゲートウェイです。
プロジェクトのREADMEから生成された概要
zilla MCP server について
Zillaは、単一のゲートウェイを通じてAIエージェントをエンタープライズデータやツールに接続することを可能にします。LLMリクエストをルーティングし、MCPツールを管理し、Kafka、MQTT、HTTPを橋渡しするマルチプロトコルエンジンとして機能します。開発者は、カスタムの統合ラッパーを構築することなく、既存のMCP server、OpenAPIサービス、またはKafkaトピックへの管理されたアクセスをAIエージェントに提供するためにこれを利用できます。
ステートレスなランタイムとして動作するZillaは、zilla.yamlファイルを介して設定され、Docker Composeを使用してローカルにデプロイしたり、Kubernetesを使用して本番環境にデプロイしたりできます。OpenAI、Anthropic、Geminiなどのプロバイダーに対するモデルルーティングをサポートする一方で、REST、SSE、WebSocket、gRPC、MQTTを介したKafkaストリームのプロトコル変換も提供します。システムは、これらの異なる通信経路にわたって、アイデンティティ、アクセス制御、およびスキーマ検証を管理します。
Zillaは、LLMゲートウェイ、MCPゲートウェイ、およびイベントストリーミングを一つの運用モデルに統合している点が特徴です。これにより、エージェントがMCPを通じてKafkaベースのツールを検出して呼び出すといった、複雑なワークフローが可能になります。また、トークン使用量、レイテンシ、プロトコルメトリクスの観測性を提供し、AIとデータトラフィックの制御を維持するのに役立ちます。
できること
- 1KafkaトピックをMCPツールとして公開開発者は、KafkaトピックやSchema Registryの操作を、AIエージェントが検出して呼び出すことができるツールとして提示できます。
- 2プロバイダー間でのLLMリクエストのルーティングサポートされているSDKを使用してリクエストを送信すると、ZillaがAnthropicやGeminiなどの適切なモデルプロバイダーにルーティングします。
- 3HTTPリクエストとKafkaストリームのブリッジアプリケーションは、標準的なHTTPメソッドを使用して、Kafkaトピックからレコードを生成または取得できます。
- 4LLMセキュリティガードレールの適用チームは、プロンプトやレスポンスのセクションに、個人データや機密情報の存在などのポリシー違反がないかを確認できます。
プロジェクトの README から作成されています。すべてのユースケースは、その引用と照らし合わせて確認されています。
自動チェック
実行日 2026年11月13日完全なレポート →まだ検証されていません。サーバーには80点のスコア、重大な問題がないこと、および検証に必要な十分なデータが必要です。 チェックの仕組み · 点数を上げるための改善点
- ソースリポジトリがリンクされており、アクセス可能合格
- オープンソースライセンス (OSI)No license検出事項
- 過去1年以内にコミットまたはリリースあり合格
- パッケージ名が有名なパッケージに酷似していない未チェック
- リモートエンドポイントがHTTPSを使用未チェック
- 破壊的なツールがラベル付けされている未チェック
- モデルへの隠れた指示がない合格
- パッケージおよびその依存関係に重大な勧告なし未チェック
README
GitHubで見るBefore moving on, please consider giving us a GitHub star ⭐️. Thank you!
Zilla is a streaming-native, multi-protocol gateway for AI, APIs, and real-time data.
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.
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.
Contents
- What You Can Build
- Why One Multi-Protocol Gateway?
- Get Started
- How Zilla Works
- Governance in the Data Path
- Streaming-Native by Design
- Capabilities at a Glance
- Zilla Plus and Zilla Console
- Install and Deploy
- Documentation and Examples
- Community and Contributing
- License
What You Can Build
⚡ Connect and govern real-time data
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.
Explore: Kafka Gateway · Kafka use cases · REST example
✨ Connect applications to LLMs
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.
Explore: LLM Gateway · Cross-provider demo
🤖 Give AI agents governed access to tools and data
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.
Explore: MCP Gateway · MCP example
Why One Multi-Protocol Gateway?
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.
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.
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.
Use either capability on its own. Combine them when your applications need both.
Get Started
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.
Prerequisite: Docker with Docker Compose.
git clone --depth 1 --branch 2.6.0 https://github.com/aklivity/zilla.git
cd zilla/examples/http.kafka.crud
docker compose up --wait
Produce a record over HTTP, then retrieve it by key:
curl -i -X POST http://localhost:7114/items \
-H 'Idempotency-Key: hello' \
-H 'Content-Type: application/json' \
-d '{"message":"Hello from Zilla"}'
curl http://localhost:7114/items/hello
Zilla maps the request to Kafka without an application service in between. Inspect the topic in Kafka UI. Stop the stack with docker compose down.
Prefer an AI example? Try the MCP Gateway or run the cross-provider LLM demo.
How Zilla Works
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.
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.
Routes are defined in zilla.yaml. For example, this excerpt maps an HTTP endpoint to a Kafka topic:
bindings:
api_to_events:
type: http-kafka
kind: proxy
routes:
- when:
- method: POST
path: /events
exit: kafka_cache_client
with:
capability: produce
topic: events
key: ${idempotencyKey}
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.
How Zilla Works · Configuration reference
Governance in the Data Path
Zilla applies protocol-aware controls where traffic crosses a system boundary, instead of requiring every application, agent, or integration to implement them independently.
| Control | What you can enforce or observe |
|---|---|
| Identity and access | Authenticate callers with supported guards, TLS/mTLS, and provider credentials; authorize model routes and MCP tool discovery and invocation. |
| Schema and API contracts | Validate supported JSON, Avro, and Protobuf payloads; apply OpenAPI and AsyncAPI-driven configuration and transformations. |
| LLM guardrails | Check configured prompt and response sections for policy violations, including secrets, personal data, and other classified content. |
| Data protection | Apply field-level encryption, masking, and conditional disclosure for supported Kafka workflows with Zilla Plus. |
| Observability | Export gateway and protocol metrics, MCP interactions, LLM token usage, and logs to supported telemetry systems. |
Policies are configured per protocol and route; not every control applies to every kind of traffic. Explore AI security · Kafka governance · Monitoring and observability
Streaming-Native by Design
Zilla's runtime is designed for continuous, high-throughput traffic as well as request/response workloads.
- Backpressure-aware streaming: Data flows through protocol bindings without requiring whole messages or streams to be buffered unnecessarily.
- Efficient data processing: Code-generated flyweights operate on encoded buffers while minimizing copying, allocation, and cross-worker contention.
- Stateless horizontal scaling: Run independent gateway instances in containers or Kubernetes; configure shared stores only for capabilities that need them.
- One operational model: Deploy and observe LLM, MCP, API, and event-streaming routes through the same engine and declarative configuration.
Explore the architecture and Kafka performance benchmarks.
Capabilities at a Glance
| Area | Capabilities |
|---|---|
| Protocols | Kafka, HTTP, SSE, WebSocket, gRPC, MQTT, MCP, and supported LLM APIs |
| LLM connectivity | OpenAI, Anthropic, and Gemini; model-based routing, streaming, supported dialect translation, and unreachable-deployment fallback |
| MCP connectivity | Aggregate MCP servers; expose HTTP/OpenAPI, Kafka, Kafka Connect, and Schema Registry capabilities as tools and resources |
| Kafka integration | HTTP/MQTT/gRPC/SSE mediation, schema validation, and Kafka-backed API patterns |
| Security and policy | TLS, JWT-based guards, authorization, schema enforcement, and configurable LLM guardrails |
| Telemetry | Metrics and logs with Prometheus, OTLP, and other supported exporters |
| Deployment | Docker, Kubernetes/Helm, and local installation; declarative zilla.yaml configuration |
Some features and integrations require Zilla Plus. See the edition capability matrix.
Zilla Plus and Zilla Console
Zilla Community includes the multi-protocol runtime, Kafka protocol mediation, MCP and LLM gateway capabilities, and core security, schema, and observability features.
Zilla Plus adds enterprise capabilities, including:
- Transparent Kafka-to-Kafka proxying for existing producers, consumers, and Kafka Connect clients, without changing the client protocol.
- Virtual Kafka clusters, dynamic topic aliases, and secure public or private Kafka access across VPCs and cloud accounts.
- Field-level data protection and additional enterprise security and identity integrations.
- Additional LLM providers: Amazon Bedrock, Azure AI Foundry, and Google Vertex AI.
- Advanced MCP tool-discovery policies, distributed stores, and commercial support.
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.
Compare editions · Explore Zilla Console · Request a Zilla Plus license · AWS Marketplace
Install and Deploy
The quickstart above runs a complete example stack. For your own configuration, supply a valid zilla.yaml and publish ports that match its listeners.
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
Kubernetes / Helm
After preparing your zilla.yaml and Helm values:
helm install zilla oci://ghcr.io/aklivity/charts/zilla \
--namespace zilla \
--create-namespace \
--wait \
--values values.yaml \
--set-file 'zilla\.yaml=zilla.yaml'
For local installation, container options, Kubernetes configuration, and production deployment guidance, see Deploy & Configure.
Documentation and Examples
- Start here: Documentation · Examples · End-to-end demos
- AI: LLM Gateway · MCP Gateway · Tool discovery
- Real-time data: Kafka Gateway · Kafka use cases
- Reference: Configuration · Editions · Releases
Community and Contributing
Questions, feedback, and contributions are welcome.
- Join the community on Slack
- Report an issue or request a feature
- Read the contributing guide
- Follow the roadmap
If Zilla is useful to you, consider starring the repository.
License
Zilla Community is source-available under the Aklivity Community License; 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 for complete terms.
zilla MCPのよくある質問
Zillaがサポートしているプロトコルは何ですか?
Zillaは、Kafka、HTTP、SSE、WebSocket、gRPC、MQTT、MCP、および各種LLM APIをサポートしています。
KafkaのトピックをMCPツールとして公開できますか?
はい、Zillaを使用すると、カスタムのラッパーサービスを構築することなく、Kafkaトピック、Kafka Connect、およびSchema Registryの操作をMCPツールとして公開できます。
Zillaのルートはどのように設定しますか?
ルートは、zilla.yaml設定ファイル内で宣言的に定義します。
ZillaはLLMリクエストのセキュリティを提供しますか?
はい、LLMガードレールが含まれており、プロンプトやレスポンスの内容に機密情報や個人データなどのポリシー違反がないかを確認できます。