MCP server de zilla
Commit 15 nov 2026Una pasarela multiprotocolo que enruta solicitudes de LLM, gestiona herramientas MCP y conecta Kafka, MQTT y HTTP a través de un único motor.
También conocido como aklivity/zilla
- Stars
- 1692
- Herramientas
- —
- Descargas, 30 días
- —
- Última versión
- —
- Último commit
- 15 nov 2026
- Licencia
- —
¿Qué es zilla MCP?
Una pasarela multiprotocolo que enruta solicitudes de LLM, gestiona herramientas MCP y conecta Kafka, MQTT y HTTP a través de un único motor.
Resumen generado a partir del README del proyecto
Acerca del MCP server de zilla
Zilla permite conectar agentes de IA con datos y herramientas empresariales mediante una única pasarela. Actúa como un motor multiprotocolo que enruta solicitudes de LLM, gestiona herramientas MCP y sirve de puente entre Kafka, MQTT y HTTP. Los desarrolladores pueden utilizarlo para proporcionar a los agentes de IA acceso gestionado a MCP servers existentes, servicios OpenAPI o temas de Kafka sin tener que construir wrappers de integración personalizados.
Al ejecutarse como un runtime sin estado, Zilla se configura mediante un archivo zilla.yaml y puede desplegarse localmente usando Docker Compose o en producción mediante Kubernetes. Soporta el enrutamiento de modelos para proveedores como OpenAI, Anthropic y Gemini, ofreciendo además traducción de protocolos para flujos de Kafka a través de REST, SSE, WebSocket, gRPC y MQTT. El sistema gestiona la identidad, el control de acceso y la validación de esquemas a través de estas diferentes vías de comunicación.
Zilla se distingue por combinar una pasarela de LLM, una pasarela MCP y el streaming de eventos en un único modelo operativo. Esto permite flujos de trabajo complejos, como permitir que un agente descubra e invoque herramientas respaldadas por Kafka a través de MCP. Además, proporciona observabilidad sobre el uso de tokens, la latencia y métricas de protocolo para ayudar a mantener el control sobre el tráfico de datos e IA.
Qué puedes hacer con él
- 1Exponer temas de Kafka como herramientas MCPUn desarrollador puede presentar temas de Kafka y operaciones de Schema Registry como herramientas que un agente de IA puede descubrir e invocar.
- 2Enrutar solicitudes de LLM entre proveedoresPuedes usar los SDK compatibles para enviar solicitudes que Zilla luego enruta al proveedor de modelo adecuado, como Anthropic o Gemini.
- 3Conectar solicitudes HTTP con flujos de KafkaUna aplicación puede producir o recuperar registros de un tema de Kafka utilizando métodos HTTP estándar.
- 4Aplicar guardrails de seguridad para LLMLos equipos pueden revisar las secciones de prompt y respuesta para detectar violaciones de políticas, como la presencia de datos personales o secretos.
Escrito a partir del README del proyecto. Cada caso de uso se verifica con una cita del mismo.
Verificaciones automáticas
Ejecutado 13 nov 2026Informe completo →Aún no verificado. Un servidor necesita una puntuación de 80, ningún hallazgo grave y suficientes datos para que podamos revisarlo. Cómo funcionan las verificaciones · Qué corregir para obtener más puntos
- Repositorio de origen vinculado y accesibleAprobado
- Licencia de código abierto (OSI)No licenseHallazgo
- Commit o lanzamiento en el último añoAprobado
- El nombre del paquete no es similar a un paquete popularNo verificado
- El endpoint remoto usa HTTPSNo verificado
- Las herramientas destructivas están etiquetadasNo verificado
- Sin instrucciones ocultas para el modeloAprobado
- No hay avisos críticos en el paquete ni en sus dependenciasNo verificado
README
Ver en GitHubBefore 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.
Preguntas sobre zilla MCP
¿Qué protocolos soporta Zilla?
Zilla soporta Kafka, HTTP, SSE, WebSocket, gRPC, MQTT, MCP y diversas API de LLM.
¿Puede Zilla exponer temas de Kafka como herramientas MCP?
Sí, Zilla puede exponer temas de Kafka, Kafka Connect y operaciones de Schema Registry como herramientas MCP sin necesidad de crear servicios de envoltura personalizados.
¿Cómo configuro las rutas de Zilla?
Las rutas se definen de forma declarativa en un archivo de configuración zilla.yaml.
¿Zilla proporciona seguridad para las solicitudes de LLM?
Sí, incluye guardrails para LLM que revisan las secciones de prompt y respuesta en busca de violaciones de políticas, como secretos o datos personales.