mcpbeat

Guardian Engine MCP Server

dev.kaimeilabs/guardian-engine
answering

Guardian Engine is answering right now. Last checked 10 min ago. It exposes 7 tools. Last commit 19 Jul 2026.

Deterministic recipe verification engine — validates AI-generated recipes against master SOPs.

Uptime history 41 hours of history
41 hours agonow
100.0%
Uptime 24h
91 of 91 checks
7
Tools
read from the server
185 ms
Response time
average over 24h
0
Stars
last commit 19 Jul 2026

Connect this server

Endpoint below is the one we actually reach during checks — not the one copied from a README. Last verified 10 min ago.

run in your terminal
claude mcp add guardian-engine --transport http https://api.kaimeilabs.dev/mcp
~/Library/Application Support/Claude/claude_desktop_config.json
{
  "mcpServers": {
    "guardian-engine": {
      "url": "https://api.kaimeilabs.dev/mcp"
    }
  }
}
~/.codex/config.toml
[mcp_servers.guardian-engine]
url = "https://api.kaimeilabs.dev/mcp"
.cursor/mcp.json
{
  "mcpServers": {
    "guardian-engine": {
      "url": "https://api.kaimeilabs.dev/mcp"
    }
  }
}
.vscode/mcp.json
{
  "mcpServers": {
    "guardian-engine": {
      "url": "https://api.kaimeilabs.dev/mcp"
    }
  }
}

Available tools 7

Read directly from the server with tools/list, grouped by what they act on. If a tool disappears, we record the date.

verify
verify_dietary_claim
Verify that a recipe satisfies a dietary claim (vegan, halal, gluten-free, ...). Reuses the existing allergen-detection logic plus a curated forbidden-ingredient map (apps/guardian/knowledge/dietary_claims.yaml). Returns a structured verdict with the specific offending ingredients and a short justification — never a vague paraphrase.
verify_recipe
Verify a candidate recipe against a Guardian master recipe. Uses deterministic graph-based verification to check technique, temperature, timing, cooking medium, and required ingredients. **Verdict**: `verdict` is strictly PASSED or FAILED and is policy-driven — any CRITICAL finding fails the recipe; more than 5 WARNINGs also fail. There is no score in the response (ADR-013): gate on `verdict` and explain failures from `findings`. **Field audience**: `issue` is a machine-readable code for programmatic handling — never show it to end users. Use `title` and `suggested_correction` as the user-facing fields. Returns structured JSON by default (machine-actionable findings and patches); response_format="text" renders a human-readable report. Both formats are transparent (ADR-009 / ADR-018): exact values and ingredient names included.
allergens
check_allergens
Check ingredients for EU FIC 1169/2011 allergen compliance. Returns a detailed audit trace mapping each ingredient to its EU Annex II allergen group with entry numbers and labels. The safety verdict is deterministic — no LLM involvement in the decision. Use check_all_eu_allergens=True for food labelling (detect all allergens). Use restrictions=['dairy', 'gluten'] to check for specific user allergies.
dishes
list_dishes
List all available master dishes with rich metadata. Returns: Dictionary with `schema_version` and a `dishes` list. Each dish includes slug, title, cuisine, region, aliases, and complexity.
fix
fix_recipe
Deterministically repair a candidate recipe against a Guardian master. Verifies the candidate, applies every machine-actionable correction the symbolic engine produced (missing ingredients, quantities, temperatures, durations, cooking media, ingredient substitutions), then re-verifies the result. No LLM is used — the repair is a deterministic function of the candidate recipe and the master ruleset. Findings that need recipe-authoring judgement — adding a whole cooking phase, rewriting step instructions, ingredient-ratio rebalancing — are not auto-applied; they are returned under `patches_skipped`. Allergen findings are never auto-fixed. The response reports the verdict before and after so the caller can see exactly what was resolved. Note: `verdict_after` may still be FAILED when structural changes (e.g. adding a cooking step, rebalancing ingredient ratios) are needed. These require recipe-authoring judgement and are returned under `patches_skipped`. Callers should NOT assume a fixed recipe will pass verification.
master
get_master
Return the canonical master recipe for a dish (read-only, no LLM). Enables compare-then-verify agentic loops: fetch the master, diff it against the user's recipe, then call verify_recipe — instead of verifying blind. Pure knowledge-base lookup, no LLM in the hot path. Master content is transparent by default (ADR-009 / ADR-010): exact temperatures, timings, and EU FIC 1169/2011 allergen codes are returned verbatim, never obfuscated. No score is included (ADR-013) — this is reference data, not a verdict. Returns ingredients, steps (technique/temperature/timing/medium), and the EU FIC allergens derived from the required ingredients. Unknown dishes return a structured UNKNOWN_DISH error.
safety
check_safety
Run master-independent safety checks on a candidate recipe. Works for ANY recipe — no dish resolution, no master SOP required. Checks poultry internal-temperature safety and scans all ingredients for the 14 EU FIC 1169/2011 Annex II allergen groups. The verdict is a deterministic function of (candidate, kb_version_hash) — no LLM involvement. Use this when verify_recipe has no matching master for the dish: the safety layer still applies to every recipe. Returns: Safety envelope: verdict (PASSED/FAILED per the zero-critical policy gate), safe flag, issues found, and the pinned kb_version_hash.

Endpoints

URLTransportStateLatencyChecked
https://api.kaimeilabs.dev/mcp streamable-http answering 169 ms 10 min ago

Guardian Engine — questions

Answers built from our own checks of this server.

What can Guardian Engine do?
It exposes 7 tools, read directly from the server on our last check. Among them: check_allergens, check_safety, fix_recipe, get_master, list_dishes, verify_dietary_claim and 1 more. The full list with descriptions is on this page — we take it from the server itself via tools/list, not from a README. How MCP servers expose tools in the first place →
Is Guardian Engine working right now?
We send a real MCP handshake every 15 minutes. Over the last 24 hours 91 of 91 checks got a reply (100.0%), average response time 185 ms. The bar chart above shows every period we have measured.
How do I connect Guardian Engine?
Copy the ready config from this page — we generate it for Claude Code, Claude Desktop, Codex, Cursor and VS Code, each with the file path that client actually reads. It is a remote server, so there is nothing to install — the client connects to the address.
Does Guardian Engine need an API key?
No. Guardian Engine completed a full MCP handshake with us as an anonymous client and listed its tools without asking for anything. All 7 of them are readable on this page. This is what we observed, not what the docs claim.
How fast is Guardian Engine?
It answers our handshake in 185 ms on average, which is faster than 66% of all working MCP servers we measure. The comparison comes from our own checks across the whole registry, every 15 minutes.
Is Guardian Engine open source?
Yes — it is published under the MIT licence, written in Python and 0 stars on GitHub. The source link is on this page, so you can read exactly what it does with your data before you connect it.