Skip to main content
Glama


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

guard-core

Framework-agnostic security engine

PyPI

guard-agent

Telemetry agent

PyPI

fastapi-guard

FastAPI / Starlette adapter

PyPI

flaskapi-guard

Flask adapter

PyPI

djapi-guard

Django adapter

PyPI

tornadoapi-guard

Tornado adapter

PyPI

Go

Go modules published via GitHub releases. Production-ready.

Package

Role

Release

guard-core-go

Go engine

release

nethttp-guard

net/http adapter

release

gin-guard

Gin adapter

release

echo-guard

Echo (v4) adapter

release

fiber-guard

Fiber (v3) adapter

release

guard-agent-go

Telemetry agent

release

PHP

Published on Packagist under the rennf93 vendor. Production-ready.

Package

Role

Packagist

guard-core-php

PHP engine

Packagist

laravel-guard

Laravel adapter

Packagist

symfony-guard

Symfony adapter

Packagist

psr15-guard

PSR-15 adapter

Packagist

slim-guard

Slim 4 adapter

Packagist

guard-agent-php

Telemetry agent

Packagist

TypeScript / JavaScript

Published under the @guardcore npm scope; source in the guard-core-ts monorepo. Production-ready.

Package

Role

npm

@guardcore/core

Core engine

@guardcore/express

Express adapter

npm

@guardcore/nestjs

NestJS adapter

npm

@guardcore/fastify

Fastify adapter

npm

@guardcore/hono

Hono (edge) adapter

npm

guardagent

Telemetry agent

npm

Rust

Published on crates.io. Production-ready.

Package

Role

crates.io

guard-core-engine

Core engine crate

crates.io

guard-core-rs

Facade crate (consumer entry point)

crates.io

actix-guard-rs

Actix Web adapter

crates.io

axum-guard-rs

Axum adapter

crates.io

tower-guard-rs

Tower adapter

crates.io

rocket-guard-rs

Rocket adapter

crates.io

guard-agent-rs

Telemetry agent

crates.io

AI Coding Agents

Package

Role

PyPI

guard-core-mcp

MCP server: config validation, docs search, detection sandbox

PyPI


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-mcp

uvx 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

versions

Which Guard libraries are installed here, and at what version

validate_config

Is this config valid, including typo'd keys pydantic silently ignores

config_fields

What is this setting, what does it default to, does a setting for X exist

search_docs

Where do the docs cover this

get_doc

The full text of one documentation page

check_payload

Would this request be blocked, and by which pattern

ecosystem

The full registry matrix: 5 languages, engines, adapters, agents, conformance, SaaS contract

adapter_setup

Install plus a verified minimal integration for one adapter (e.g. go + gin)

wire_agent

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 tools
adapter_setupAdapter setupA
Read-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 payloadA
Read-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 lookupA
Read-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 registryA
Read-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 pageA
Read-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 docsA
Read-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 configA
Read-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 versionsA
Read-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 agentA
Read-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

    A4.6/5.0

    Scored across 9 tools

    Disambiguation5/5

    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.

    Naming Consistency4/5

    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.

    Tool Count5/5

    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.

    Completeness4/5

    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

    ActivityActive
    ResponsivenessNo recent community issues

    Related MCP Connectors

    Related MCP Servers

    • A
      license
      Not graded
      quality
      D
      maintenance
      AI-powered security scanner for Python projects and GitHub repositories. Detects vulnerabilities, secrets, and provides AI risk assessment.
      11
      MIT
    • A
      license
      A
      quality
      B
      maintenance
      Local-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.
      10
      358 npm
      51
      Apache 2.0