Guardian Engine — API & MCP Integration Guide

A deterministic oracle inside your agent's generate→verify loop. Your LLM authors the recipe; Guardian judges it. Guardian Engine catches hallucinated temperatures, missing techniques, wrong ingredients, and impossible cooking steps before they reach the pan — and returns machine-actionable patches so your agent can fix exactly what's wrong. Recipes are the first vertical — the same deterministic approach generalises to any procedural domain where correctness matters.

Why an oracle instead of another LLM critique? An LLM critique is a sample — it misses differently on every run. Guardian's symbolic engine makes guarantees a generative model structurally cannot:

• Exhaustive checking — every rule is evaluated on every call, not a sample of them.
• Certified negatives — "no EU Annex II allergen source detected" is an absence claim an LLM cannot make.
• Replayable verdicts — same input + same spec + same knowledge-base version → byte-identical output. Every response pins kb_version_hash and master_hash so any verdict is reproducible as an audit record.
• Machine-actionable repair — findings come with structured patches (and fix_recipe can apply them deterministically); your agent authors the rest and re-verifies.
• Bring your own spec — verify against your house recipe or SOP via master_json, not just the bundled catalog.

Endpoint: https://api.kaimeilabs.dev/mcp
Transport: Streamable HTTP (MCP)
Auth: None — free during early access (fair use applies)

⚠️ Safety & Liability Notice

Guardian Engine is an automated, informational recipe-verification tool. It is not a food-safety, medical, nutritional, or regulatory-compliance authority, and its output is not professional advice.

• Allergens are not guaranteed. Allergen warnings (including check_safety, check_allergens, and the allergens field of every verification response) come from an automated knowledge base that may be incomplete or wrong. A PASSED verdict or an empty allergen list is NOT a guarantee that a recipe is free of any allergen or safe for any individual. Never rely on Guardian to decide whether a food is safe for someone with a food allergy or intolerance — always verify against the actual ingredient/product labelling and consult a qualified professional.
• Dietary and religious claims are not certifications. verify_dietary_claim results (vegan, vegetarian, gluten-free, dairy-free, nut-free, halal, kosher) are automated ingredient-level checks — they are not a substitute for certification by a recognised dietary or religious authority.
• Repaired recipes are not certified safe. fix_recipe output must be reviewed by a human before being cooked, served, or published; allergen findings are never auto-fixed and a repaired recipe may still fail verification.
• Cooking-safety findings are informational and must not replace certified guidance (e.g. USDA, EU FIC, or your local food-safety authority).
• No warranty. The Service is provided "AS IS", without warranty of any kind. To the maximum extent permitted by law, Kaimei Labs accepts no liability for any loss, injury, or damage arising from use of, or reliance on, Guardian output.

Use of the API constitutes acceptance of the full Terms of Service (warranty disclaimer, limitation of liability, indemnification).

Connect Your Agent

Guardian is a hosted MCP server. No install, no API key, no Docker. Pick your client and paste the config.

Claude Desktop

Add to your claude_desktop_config.json:

{
  "mcpServers": {
    "guardian": {
      "url": "https://api.kaimeilabs.dev/mcp",
      "transport": "streamable-http"
    }
  }
}

Restart Claude Desktop. Ask: "List the available dishes in Guardian Engine" to confirm.

Cursor

Open Settings → MCP Servers → Add new MCP server, then paste:

{
  "guardian": {
    "url": "https://api.kaimeilabs.dev/mcp",
    "transport": "streamable-http"
  }
}

VS Code (GitHub Copilot)

Add to your .vscode/mcp.json (or user settings.json under "mcp"):

{
  "servers": {
    "guardian": {
      "type": "http",
      "url": "https://api.kaimeilabs.dev/mcp"
    }
  }
}

Windsurf

Add to your Windsurf MCP config:

{
  "mcpServers": {
    "guardian": {
      "serverUrl": "https://api.kaimeilabs.dev/mcp"
    }
  }
}

Smithery (One-Click)

— auto-configures Claude Desktop, Cursor, and more.

[!WARNING] Smithery Proxy Limitation: The default Smithery proxy URL (guardian-engine--kaimeilabs.run.tools) does not support Streaming HTTP and will silently fail. You MUST edit your MCP config after installation to use the direct endpoint: https://api.kaimeilabs.dev/mcp.

Glama.ai

Guardian Engine is also listed on Glama.ai — discover and connect to MCP servers from the Glama directory.

Any MCP Client (Python SDK)

import asyncio
from mcp.client.session import ClientSession
from mcp.client.streamable_http import streamable_http_client
from httpx import AsyncClient

async def main():
    async with AsyncClient(timeout=30.0) as http:
        async with streamable_http_client("https://api.kaimeilabs.dev/mcp", http_client=http) as streams:
            read_stream, write_stream, _ = streams
            async with ClientSession(read_stream, write_stream) as session:
                await session.initialize()
                result = await session.call_tool("list_dishes", arguments={"cuisine_filter": "french"})
                print(result)

asyncio.run(main())

pip install mcp>=1.2.1 httpx>=0.27.0

Tools

The MCP server exposes seven tools. verify_recipe is the core loop; the rest support the compare → verify → repair cycle and master-independent safety checks.

verify_recipe

Verify a candidate recipe against a Guardian master spec. Returns a structured report with a strict PASSED/FAILED verdict (no scores) and detailed findings, each citing the rule it violated. The verdict is policy-driven: any CRITICAL finding fails the recipe; more than 5 WARNINGs also fail.

Tip — include the original prompt for personalised feedback: When you include original_prompt (e.g. "Make a spicy vegan rendang"), Guardian matches findings to the user's stated dietary needs and flavour preferences, and activates audience-sensitive safety checks (e.g. flagging honey in recipes for infants, raw egg for pregnant users). Without it, Guardian still returns the full verdict and all findings.

Unknown dish? If the dish isn't in the catalog, the UNKNOWN_DISH error carries a safety_fallback verdict — the master-independent safety layer (poultry temperature + allergen scan) still runs, so your agent always leaves with deterministic value.

Field audience: issue is a machine-readable code for programmatic handling — don't show it to end users. Use title and suggested_correction as the user-facing fields.

fix_recipe

Deterministically repair a candidate recipe against a master spec. Verifies, applies every machine-actionable patch the symbolic engine produced (missing ingredients, quantities, temperatures, durations, cooking media, substitutions), then re-verifies. No LLM is involved — the repair is a deterministic function of the candidate and the ruleset.