guard-core-mcp
Provides tools for Guard Core config validation and documentation search for Actix Web applications via the actix-guard-rs adapter.
Provides tools for Guard Core config validation and documentation search for Django applications via the djapi-guard adapter.
Provides tools for Guard Core config validation and documentation search for Express applications via the @guardcore/express adapter.
Provides tools for Guard Core config validation and documentation search for FastAPI/Starlette applications via the fastapi-guard adapter.
Provides tools for Guard Core config validation and documentation search for Fastify applications via the @guardcore/fastify adapter.
Provides tools for Guard Core config validation and documentation search for Flask applications via the flaskapi-guard adapter.
Provides tools for Guard Core config validation and documentation search for Gin applications via the gin-guard adapter.
Provides tools for Guard Core config validation and documentation search for Hono edge applications via the @guardcore/hono adapter.
Provides tools for Guard Core config validation and documentation search for Laravel applications via the laravel-guard adapter.
Provides tools for Guard Core config validation and documentation search for NestJS applications via the @guardcore/nestjs adapter.
Provides tools for Guard Core config validation and documentation search for Symfony applications via the symfony-guard adapter.
Provides tools for Guard Core config validation and documentation search for Tower-based Rust applications via the tower-guard-rs adapter.
Ecosystem
Guard Core is the Python engine. Framework adapters are thin wrappers that translate native request/response types into Guard Core's protocols. The telemetry agents ship security events and metrics to the monitoring backend. Parallel engine implementations exist for Go, PHP, TypeScript (on npm), and Rust (on crates.io) - all ports of the same reference semantics, conformance-tested against the shared adversarial corpus.
Python
Package | Role | PyPI |
Framework-agnostic security engine | ||
Telemetry agent | ||
FastAPI / Starlette adapter | ||
Flask adapter | ||
Django adapter | ||
Tornado adapter |
Go
Go modules published via GitHub releases. Production-ready.
Package | Role | Release |
Go engine | ||
net/http adapter | ||
Gin adapter | ||
Echo (v4) adapter | ||
Fiber (v3) adapter | ||
Telemetry agent |
PHP
Published on Packagist under the rennf93 vendor. Production-ready.
Package | Role | Packagist |
PHP engine | ||
Laravel adapter | ||
Symfony adapter | ||
PSR-15 adapter | ||
Slim 4 adapter | ||
Telemetry agent |
TypeScript / JavaScript
Published under the @guardcore npm scope; source in the guard-core-ts monorepo. Production-ready.
Package | Role | npm |
Core engine | ||
Express adapter | ||
NestJS adapter | ||
Fastify adapter | ||
Hono (edge) adapter | ||
Telemetry agent |
Rust
Published on crates.io. Production-ready.
Package | Role | crates.io |
Core engine crate | ||
Facade crate (consumer entry point) | ||
Actix Web adapter | ||
Axum adapter | ||
Tower adapter | ||
Rocket adapter | ||
Telemetry agent |
AI Coding Agents
Package | Role | PyPI |
MCP server: config validation, docs search, detection sandbox |
Related MCP server: FlowCheck MCP Server
Documentation
📚 Documentation - full technical documentation for this package.
🛡️ Guard Core - the engine's reference documentation.
🤖 Monitoring Agent Integration - monitor your Guard instance with a monitoring agent.
Why
Your agent can already read the docs. What it cannot do is tell you that the redis_failopen in your config is silently doing nothing because the real field is redis_fail_open, or that the flag you are reaching for did not exist until guard-core 3.5.0, or whether a given request would actually be blocked and by which pattern.
This server answers those from the installed package: real pydantic validation, real field metadata, and the real detection engine. It also answers the cross-language questions the libraries cannot answer: which package guards a Gin, Fastify, Laravel or Rocket app, whether it is tagged or still path-dependent, how to wire its telemetry agent, and what response codes the SaaS ingest endpoint returns.
Install
Install it into your project's environment, not as an isolated tool:
uv add --dev guard-core-mcp
claude mcp add guard-core -- uv run guard-core-mcpuvx guard-core-mcp will start, but an isolated environment contains no guard-core or fastapi-guard for it to introspect, so it can only answer from bundled documentation. Running it inside your own environment is what makes the answers match the versions you actually ship.
Tools
Tool | Answers |
| Which Guard libraries are installed here, and at what version |
| Is this config valid, including typo'd keys pydantic silently ignores |
| What is this setting, what does it default to, does a setting for X exist |
| Where do the docs cover this |
| The full text of one documentation page |
| Would this request be blocked, and by which pattern |
| The full registry matrix: 5 languages, engines, adapters, agents, conformance, SaaS contract |
| Install plus a verified minimal integration for one adapter (e.g. |
| How to set up the telemetry agent for a language, including the ingestion contract |
The ecosystem tools are pure data, so they work everywhere, with or without the Python libraries installed. Every quick-start snippet is copied verbatim from the sibling repo READMEs, and release_status tells you honestly whether a package is published, tagged, or still untagged (source, main, or path dependency only).
ChatGPT plugin
The same tools are also served remotely at https://mcp.guard-core.com/mcp and packaged as a ChatGPT plugin: sign in with a guard-core account, and ChatGPT can validate configs, search the docs and run payloads through the hosted detection engine (the latest published releases, not your local versions). The packaging lives in plugin/, the hosted server in guard_core_mcp.hosting, and the full story (env vars, Docker image, developer-mode test loop, submission checklist) in the ChatGPT plugin guide.
Licence
MIT
mcp-name: io.github.Guard-Core/guard-core-mcp
Available Tools
9 toolsadapter_setupAdapter setupARead-onlyIdempotent
Get the install command and a verified minimal integration for one Guard adapter.
Use this when you know the language and web framework and want working setup code. Use ecosystem instead to survey every adapter, and wire_agent to set up telemetry.
Returns language, engine (package, install command, release_status and conformance status of the engine the adapter depends on) and adapter (install command, release_status, its role in the framework, the Python adapter it mirrors, and a quick-start snippet taken verbatim from the adapter's README). Snippets reflect the README at the time this server was built; when release_status is untagged, re-check the repository. An unknown language or framework returns an object with an error key instead of raising. Read-only static data, works without the Guard libraries installed.
Inputs: language (required), framework (required). Returns: object
check_payloadCheck payloadARead-onlyIdempotent
Run one synthetic request through guard-core's real penetration-detection engine.
Use this to confirm that an attack payload is caught, or to explain why a benign request was flagged. Use validate_config instead to check a config, not a request.
Returns is_threat (bool), trigger_info (the matched parameter and pattern, empty when clean), threat_categories (for example sqli or xss), threat_scores (a score per category) and elapsed_ms. Verdicts come from the same detection path a live adapter runs. Read-only and sandboxed: the request is never sent anywhere and enable_redis is forced off so Redis is never touched. If guard-core is not installed, returns an object with an error key and a hint instead of raising.
This is the detection stage alone, not the whole middleware pipeline. A real request also passes IP rules, rate limiting, user-agent and cloud-provider checks, any of which can block it before detection runs, and a whitelisted IP skips detection entirely. A clean verdict here does not promise the request reaches the route, and a threat verdict does not promise a running app would block it.
The scan is bounded, so a payload past a cap is judged on the scanned prefix only: detection_max_scan_values caps values inspected (default 512), detection_max_scan_chars caps total characters scanned (default 65536), and detection_max_json_depth (default 32) caps how deep a JSON body is walked before the rest is scanned as one serialized value. These caps and the enhanced detection path apply from guard-core 3.15.0; versions reports what is installed.
Inputs: body, path, query, config, +2 more. Returns: object
config_fieldsConfig fields lookupARead-onlyIdempotent
Find a Guard config setting by name or by what it does, with type and default.
Use this to learn what a setting means, or whether a setting for some behaviour exists at all. Use validate_config instead to check a whole config you already wrote, and search_docs for prose explanations rather than field metadata.
Returns package, version, query, exact and matches. An exact field name fills exact with that field's name, type, default, required flag and description (otherwise exact is null). Every query also fills matches with each other field whose name or description contains every word of the query; if nothing matches at all, matches falls back to the closest field names by spelling.
Read-only, in-memory lookup. If the library is not installed, or package is not recognized, returns an object with an error key instead of raising.
Inputs: query (required), package. Returns: object
ecosystemEcosystem registryARead-onlyIdempotent
Survey the whole Guard ecosystem: every language, engine, adapter and agent.
Use this to resolve a package name or compare languages. It takes no arguments. When you already know the language and framework, use adapter_setup for one adapter or wire_agent for the telemetry agent instead, which return less.
Returns the full registry for five languages (python, go, typescript, php, rust). Each language entry holds its engine (name, install command, version, release_status, conformance status), every framework adapter with a verified quick-start snippet and the Python adapter it maps to, and its telemetry agent with delivery semantics. A conformance block describes the frozen spec-4.0.2 corpus every engine is tested against, and a saas block documents the guard-core-app ingestion contract all agents share.
release_status is published (live on a package registry), tagged (a git tag exists, registry presence may lag) or untagged (install from source, main or a path dependency). Read it together with notes: several Go, PHP and Rust packages carry tags or version constants that registry publishing has not caught up with. Read-only static data that works with or without the Guard libraries installed.
Inputs: no named parameters. Returns: object
get_docGet doc pageARead-onlyIdempotent
Return the full text of one bundled Guard documentation page.
Use this after search_docs when a snippet is not enough; it does not search. The package and path come from a search_docs result.
Returns package, path, url (the live page to cite) and content (the full markdown). An unknown package or a path that does not exist returns {"error": "unknown doc path"}; the two cases are not distinguished. Read-only and offline, and it cannot read files outside the bundled documentation.
Inputs: path (required), package (required). Returns: object
search_docsSearch docsARead-onlyIdempotent
Search the bundled Guard documentation and return ranked, citable pages.
Use this to answer how or why questions from documentation, and to find the page to read in full with get_doc. Use config_fields instead for a setting's type and default, and adapter_setup or wire_agent for install and wiring steps.
Returns query and results. Each result has package, path, heading, snippet, url (the live documentation page to cite) and score. Pass a result's package and path straight to get_doc to read the whole page.
Read-only and offline: it searches the docs shipped inside this package. Unlike validate_config, an unrecognized package is not an error, it silently matches nothing, so an empty results list means either a real gap in the docs or a mistyped package name; retry with package omitted before concluding the former.
Inputs: query (required), limit, package. Returns: object
validate_configValidate configARead-onlyIdempotent
Check a Guard config dict against the installed library's real pydantic model.
Use this to confirm a config is valid, or to find out why a setting seems to have no effect. Use config_fields instead when you do not yet know the setting's name.
Returns valid (bool), package, version, model, errors (type errors, each with field, message and input), unknown_fields (each with name and did_you_mean suggestions), deprecated (field and message) and construction_warnings. Unknown keys matter: pydantic silently ignores them, so a misspelled setting does nothing at runtime and raises no error anywhere else. construction_warnings carries guard-core's own logged-not-raised misconfiguration warnings: an unknown constructor keyword, a trusted_proxies or whitelist /0 network, and enabled_detection_categories empty while penetration detection is enabled.
Read-only: the config is validated in memory and never applied. If the library is not installed, or package is not recognized, returns an object with an error key (plus a hint when the cause is a missing install) instead of raising.
Inputs: config (required), package. Returns: object
versionsGuard versionsARead-onlyIdempotent
Report which Guard libraries this server can introspect, and at which version.
Call this first, before trusting any answer about a version-specific feature. It takes no arguments.
Returns guard_core_mcp (this server's version), installed (the guard-core, fastapi-guard and guard-agent versions live in this interpreter), and docs_bundled_for and knowledge_bundled_for (the versions the bundled docs and the hand-written ecosystem notes describe).
A null installed version means that library is absent from the interpreter running this server, so validate_config, config_fields and check_payload cannot answer for it and any answer would be a guess. An installed version that differs from docs_bundled_for is normal and only means the docs may lag or lead the install.
Inputs: no named parameters. Returns: object
wire_agentWire agentARead-onlyIdempotent
Get how to set up the Guard telemetry agent for one language.
Use this to ship security events and metrics to the guard-core-app backend. Use adapter_setup instead for the request-blocking middleware itself.
Returns language, agent (package, install command, release_status, quick-start snippet, and a summary of its buffer, flush, overflow and retry semantics), ingestion (the guard-core-app contract the agent ships against: endpoints, headers, HMAC signing, size limits and response semantics) and framework_note. For python the note points at the bundled guard-agent doc page for the adapter; for other languages the agent is standalone and the note says so. An unknown language or framework returns an object with an error key instead of raising. Read-only static data, works without the Guard libraries installed.
Inputs: language (required), framework. Returns: object
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
TDQS
Scored across 9 tools
Each tool targets a clearly distinct purpose, and the descriptions actively disambiguate near-neighbors (validate_config vs config_fields, search_docs vs get_doc, adapter_setup vs wire_agent vs ecosystem) with explicit 'use X instead' guidance. Overlap between ecosystem/adapter_setup/wire_agent is resolved by scope (survey vs one adapter vs telemetry agent), so misselection is unlikely.
Most tools follow a clean verb_noun snake_case pattern (check_payload, wire_agent, validate_config, config_fields, search_docs, get_doc, adapter_setup). The bare nouns 'versions' and 'ecosystem' break the pattern, but the deviation is minor and the names remain readable.
Nine tools is well-scoped for an introspection/help server covering config validation, field lookup, payload testing, docs retrieval, version reporting, and setup guidance. Each tool earns its place with no redundant filler.
The surface covers the main Guard workflows thoroughly: version reporting, config validation and field lookup, payload testing, docs search/read, ecosystem survey, and adapter/agent setup. Minor gaps exist, such as no direct tool to enumerate available doc packages or a changelog/migration guide, but these are workable around via ecosystem and search_docs.
Maintenance
Related MCP Connectors
Deep security scans of repos you own from your editor: dependency CVEs, SAST, git-history secrets.
Checks AI-written code for leaked keys and made-up packages, on your machine. Never uploads code.
Security reviews, threat models over a repo or website, and remediation tracking, in your editor.
Scan, monitor and fix a live web app from your editor: graded security reports with fix prompts.
Related MCP Servers
- AlicenseNot gradedqualityDmaintenanceAI-powered security scanner for Python projects and GitHub repositories. Detects vulnerabilities, secrets, and provides AI risk assessment.11MIT
- AlicenseAqualityDmaintenanceActs as a production-grade safety layer for AI-assisted coding, monitoring Git hygiene, scanning for security issues (PII, secrets, injection), and enabling semantic history search.9MIT
- AlicenseAqualityBmaintenanceLocal-first, zero-egress security scanner for AI-generated / "vibe-coded" JS/TS. Bundles Opengrep, Gitleaks & Trivy behind one CWE-keyed schema and adds AI-code-specific checks (client-side secret exposure, Supabase RLS, prompt-injection & LLM-output XSS sinks). No account, no telemetry.10358 npm51Apache 2.0
- AlicenseNot gradedqualityCmaintenanceProvides security checks for AI agents, including secret scanning, CVE lookup, and dependency vulnerability scanning, all running locally except for CVE lookups.MIT