Cerberus MCP server
Commit Nov 11, 2026Instruments APIs and AI agents to monitor tool calls, LLM traffic, and security events for threat detection.
Also known as cerberussecurityai/cerberus
- Stars
- 1
- Tools
- —
- Downloads, 30 days
- —
- Latest version
- —
- Last commit
- Nov 11, 2026
- License
- MIT
What is Cerberus MCP?
Cerberus instruments APIs and AI agents to monitor tool calls, LLM traffic, and security events for threat detection.
Summary generated from the project's README
About Cerberus MCP server
Monitoring tool calls, LLM traffic, and security events for threat detection is the primary function of these instrumentation packages. Developers can integrate these libraries into their existing applications or place them in front of services to gain visibility into what APIs serve, what agents call, and how much models spend. The system uses a unified event schema across different runtimes, allowing for interchangeable deployments.
Depending on your stack, you can use the cerberus-mcp package as a drop-in replacement for FastMCP to instrument tool, resource, and prompt calls. For Django applications, the cerberus-django middleware captures HTTP metadata and streams it via WebSockets. If you require a no-code solution, the cerberus-flex-gateway policy for MuleSoft Anypoint Flex Gateway captures request metadata without application changes. Other options include the cerberus-envoy-ai-gateway for Envoy AI Gateway users and the cerberus-core library for shared Python sanitization utilities.
Security is handled locally before data transmission. The system redacts values under sensitive key names and uses HMAC-pseudonymization for bearer tokens. This approach helps defend against tool poisoning, prompt injection, and excessive agency by recording critical interactions.
Written from the project's README. Every use case is checked against a quote from it.
Automated checks
Ran Nov 16, 2026Full report →Not verified yet. A server needs a score of 80, no serious finding, and enough data for us to check. How checks work · What to fix for more points
- Source repository linked and reachablecerberussecurityai/cerberus is public and reachablegithub.com/cerberussecurityai/cerberus ↗Pass
- Package names this repository as its sourceNot checked
- Build provenance (Sigstore attestation)Not checked
- Open source license (OSI)MITspdx.org/licenses/MIT.html ↗Pass
- Commit or release in the last yearLast commit or release 2026-11-11github.com/cerberussecurityai/cerberus ↗Pass
- OpenSSF ScorecardNot checked
- Package name not close to a popular packageNot checked
- No critical advisory in the package or its dependenciesNot checked
- No hidden instructions to the model0 tool descriptions and the README read; no override phrases, credential paths or hidden charactersPass
- Destructive tools are labelledNot checked
- Remote endpoint answers the MCP handshakeNot checked
README
View on GitHubCerberus — Client Instrumentation Packages
Instrumentation for API and AI agent security monitoring: what your APIs served, what your agents called, and what your models spent.
These are the libraries and gateway policies you add to your application, or place in front of it, so that a request, an MCP tool call, or an LLM call becomes something you can see. Each integration targets a different runtime and they all emit the same event schema, so they are interchangeable and can be mixed in one deployment.
Values under known sensitive key names are redacted in the client before anything is transmitted, and bearer tokens are HMAC-pseudonymized rather than stored. Source IPs are not treated as PII: the Flex Gateway policy (0.6.0+) sends them as-is, and the Python integrations' legacy IP hashing is being removed to match.
Looking for the backend/platform (event ingestion, processing, dashboards, infrastructure)? That lives in the separate
cerberus-intrepository.
Guides
Background on what these packages are for, independent of which one you use:
- Securing MCP servers: tool poisoning, prompt injection that becomes a tool call, excessive agency and exfiltration by chaining. Why network controls miss them, what to record, and how it maps to OWASP.
Packages
| Package | What it's for | Runtime | Distribution |
|---|---|---|---|
| cerberus-core | Shared sanitization + PII-hashing utilities used by the Python integrations (SENSITIVE_KEYS, sanitize_dict(), hash_pii()) |
Python | PyPI |
| cerberus-django | Django middleware that captures HTTP request/response metadata and streams it over WebSocket — a one-line MIDDLEWARE addition |
Python · Django | PyPI |
| cerberus-mcp | Drop-in FastMCP replacement that instruments MCP tool / resource / prompt calls |
Python · MCP (FastMCP) | PyPI |
| cerberus-flex-gateway | Custom policy for MuleSoft Anypoint Flex Gateway — captures and forwards request metadata with no application code changes | Rust → WASM (wasm32-wasip1) |
Prebuilt bundle → customer's own Anypoint Exchange (INSTALL.md) |
| cerberus-envoy-ai-gateway | OTLP trace bridge for Envoy AI Gateway — converts the gateway's LLM + MCP telemetry into Cerberus events, deployed beside the gateway with a few OTel env vars | Python · OTLP/HTTP | PyPI / container image |
Shared test fixtures: parity-fixtures — language-agnostic YAML cases that keep the Python and Rust sanitization logic byte-for-byte consistent.
Which one do I need?
- Django app →
cerberus-django(depends oncerberus-core) - MCP server (FastMCP) →
cerberus-mcp(depends oncerberus-core) - Envoy AI Gateway in front of LLM providers / MCP servers →
cerberus-envoy-ai-gateway(depends oncerberus-core) - Any API / non-Python stack / no code changes →
cerberus-flex-gatewaydeployed in front of your service - Building a new integration → reuse
cerberus-core's sanitization contract and the shared event schema
How they fit together
- All integrations emit the same event payload (
CoreData/MCPEventData), so the Cerberus backend (event_ingest) needs no per-client changes. - Sanitization happens before any data leaves the client, via
cerberus-core(Python) or its ported equivalent in the Rust gateway. Redaction matches key names againstSENSITIVE_KEYS, so it catches the usual suspects rather than inspecting values. Source IPs are not treated as PII: the Flex Gateway policy sends the normalized client IP as-is, and the Python integrations' remaining HMAC-SHA256 IP hashing (when a secret key is configured) is being removed to match. - The Flex Gateway policy re-implements the sanitization logic in Rust (there is no shared crate across languages). Parity is enforced by
parity-fixtures:cerberus-flex-gateway/tests/parity_runner.rsandcerberus-django/tests/test_parity.pyconsume the same YAML cases, so any drift fails CI. (cerberus-envoy-ai-gatewayimportscerberus-coredirectly, so it needs no parity runner.)- ⚠️ If you change
SENSITIVE_KEYS(or other sanitization rules) incerberus-core, update the matching fixture in the same PR.
- ⚠️ If you change
Development & publishing
- The Python packages build with
uv buildand publish to PyPI via./publish_package.sh<package>(e.g../publish_package.sh cerberus-core). cerberus-flex-gatewaycompiles to WASM and is distributed as a prebuilt bundle each customer publishes into their own Anypoint Exchange via the bundledinstall.sh(see INSTALL.md). Maintainers build the bundle withmake bundle; CI attaches it to aflex-gateway-v*GitHub Release. It can also be dropped onto a Flex Gateway pod as a.wasm(Local mode).cerberus-envoy-ai-gatewayadditionally ships as a container image (make image, push to your registry) with Kubernetes manifests in itsdeploy/directory.- Repo-wide guidance (architecture, commands, conventions) for contributors and AI assistants: CLAUDE.md.
License
See LICENSE.
Cerberus MCP questions
What does Cerberus monitor?
It monitors what your APIs served, what your agents called, and what your models spent by capturing request, tool-call, and LLM traffic.
How is sensitive data handled?
Sensitive values are redacted in the client before transmission, and bearer tokens are HMAC-pseudonymized.
Does Cerberus provide the backend for data ingestion?
No, the backend platform for event ingestion, processing, and dashboards is located in a separate repository called cerberus-int.