dev.kaimeilabs/guardian-engine

Official6 tools

by kaimeilabs · Python

Guardian Engine

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

Verifies AI-generated recipes against master standard operating procedures.

Captured live from the server via tools/list.

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 a formatted text report or structured JSON (response_format="json"). In Oracle Mode (default), proprietary data is protected — exact values are replaced with directional hints.

Parameters (7)

dish_namestring
Name of the dish to verify against (e.g. 'carbonara', 'rendang', 'roast-chicken', 'confit', 'cheesecake', 'kung-pao', 'fried-chicken', 'brisket', 'wellington', 'cheese-souffle'). Use list_dishes() to see all available recipes and their aliases.
candidate_jsonany
The full candidate recipe as a JSON string or object. Expected schema: {"title": "<string>", "cuisine": "<string>", "serves": <int>, "ingredients": [{"name": "<string>", "quantity": "<string>"}], "steps": [{"step_number": <int>, "title": "<string>", "instruction_english": "<string>", "technique": "<string>", "estimated_temperature_c": <number or [min, max]>, "duration_minutes": <number or [min, max]>, "cooking_medium": "<string>"}]}
original_promptany
RECOMMENDED for best results. Include the user's original cooking request. Copy the user's exact message that triggered this recipe (e.g., 'Make me a spicy vegan rendang' or 'Generate a traditional carbonara, but healthier'). WITHOUT this parameter: Guardian returns actionable findings with specific ingredient names and technique details — enough to fix most recipes. WITH this parameter: Guardian additionally activates safety context awareness (e.g., flagging honey for infants, raw egg for pregnant users) and personalised feedback matched to dietary needs and flavour preferences. Include it when the user's context matters for safety or personalisation.
response_formatstring
Response format: 'text' (default) or 'json'. Use 'json' for machine-actionable patches.
session_idany
Optional session ID to track an agent's improvement loop across multiple attempts.
dishany
Alias for dish_name — for backward compatibility with production clients.
operator_idany
Optional audit identifier for the calling operator (letters, digits, hyphens; max 64 chars). Tags the verification in the tamper-evident log and compliance record. Defaults to 'anonymous'.

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.

Parameters (5)

dish_namestring
Name of the dish to repair against (e.g. 'carbonara', 'rendang', 'roast-chicken'). Use list_dishes() to see all available recipes and their aliases.
candidate_jsonany
The full candidate recipe as a JSON string or object — same schema as verify_recipe's candidate_json (title, cuisine, ingredients[], steps[]).
original_promptany
Optional. The user's original cooking request, used only for safety-context awareness during verification. Does not change which fixes are applied.
response_formatstring
Response format: 'text' (default) or 'json'. Use 'json' to receive the full fixed_recipe object.
dishany
Alias for dish_name — for backward compatibility with production clients.

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.

Parameters (1)

cuisine_filterstring
Optional cuisine to filter by. Case-insensitive exact match against the dish's cuisine field. Valid values: italian | french | spanish | british | thai | chinese | indian | indonesian | japanese | malaysian | korean | mexican | american | moroccan | turkish | levantine. Leave empty to return all available dishes.

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.

Parameters (2)

dish_namestring
Name or alias of the dish to fetch the canonical master recipe for (e.g. 'carbonara', 'spaghetti bolognese', 'angel food cake'). Alias resolution and slug normalisation are applied. Use list_dishes() to browse.
response_formatstring
Response format: 'json' (default, structured) or 'text' (human-readable summary).

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.

Parameters (5)

ingredientsarrayrequired
List of ingredient names (freeform or canonical IDs). Examples: ['butter', 'wheat_flour', 'eggs', 'peanut_butter']
restrictionsany
Allergen group IDs to check against user restrictions. Valid IDs: gluten, crustaceans, eggs, fish, peanuts, soy, dairy, tree_nuts, celery, mustard, sesame, sulphites, lupin, molluscs. If None and check_all_eu_allergens=True, reports all detected allergens.
dish_nameany
Optional dish name for reporting context.
check_all_eu_allergensboolean
If True, scans for all 14 EU Annex II allergens regardless of restrictions list. Use this for food labelling (declare all allergens present).
response_formatstring
Response format: 'text' (default) or 'json'. Use 'json' for machine-actionable output.

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.

Parameters (3)

candidate_jsonstring
Recipe JSON string (CandidateRecipe schema). Expected shape: {"title": "...", "ingredients": [{"name": "..."}, ...], "steps": [...]}. Only the ingredient list is required for dietary verification.
claimstring
Dietary claim to verify: vegan | vegetarian | gluten_free | dairy_free | nut_free | halal | kosher.
response_formatstring
Response format: 'text' (default, human-readable) or 'json' (machine-actionable).

README.md12 KBView on GitHub

Guardian Engine — API & MCP Integration Guide

Deterministic verification infrastructure for AI agent outputs. Guardian Engine catches hallucinated temperatures, missing techniques, wrong ingredients, and impossible cooking steps before they reach the pan. Recipes are the first vertical — the same deterministic approach generalises to any procedural domain where correctness matters.

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 come from an automated knowledge base that may be incomplete or wrong. A PASSED verdict 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.

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:

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:

json

{
  "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"):

json

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

Windsurf

Add to your Windsurf MCP config:

json

{
  "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)

python

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())

bash

pip install mcp>=1.2.1 httpx>=0.27.0

Tools

`verify_recipe`

Verify a candidate recipe against a Guardian master recipe. Returns a structured report with a PASSED/FAILED verdict and detailed findings (each citing the rule it violated).

Parameter	Type	Required	Description
`dish`	string	Yes	Name or alias of the dish (e.g. `"carbonara"`, `"rendang"`, `"kung-pao"`, `"bourguignon"`)
`candidate_json`	string	Yes	Full recipe as a JSON string — see schema.md
`original_prompt`	string	No	The user's original request that generated the recipe
`response_format`	string	No	`"text"` (default) or `"json"`. Use `"json"` for machine-actionable patches in agentic self-correction loops

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 (e.g. flagging which specific issue conflicts with a "vegan" or "spicy" intent), 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.

`list_dishes`

List all master recipes Guardian can verify against.

Parameter	Type	Required	Description
`cuisine_filter`	string	No	Filter by cuisine (e.g. `"french"`, `"chinese"`, `"thai"`)

Available Recipes (161 dishes, 5 regions)

Region	Dishes
Europe	Basque Cheesecake · Beef Bourguignon · Beef Wellington · Butternut Squash Soup · Cacio e Pepe · Caprese Salad · Cassoulet · Cheese Soufflé · Chicken Cacciatore · Chicken Marsala · Chicken Piccata · Chocolate Soufflé · Confit de Canard · Coq au Riesling · Coq au Vin · Crème Brûlée · Crêpes · Fettuccine Alfredo · Fish & Chips · Florentine Biscuits · Focaccia Barese · French Omelette · French Onion Soup · Frittata · Gazpacho · Gnocchi di Patate · Goulash · Greek Salad · Köttbullar · Mille-Feuille · Minestrone · Niçoise Salad · Osso Buco · Pasta alla Norma · Pasta Carbonara · Pasta Pomodoro · Patatas Bravas · Penne alla Vodka · Pesto alla Genovese · Pierogi · Pissaladière · Potato-Leek Soup · Ratatouille · Risotto alla Milanese · Roast Chicken · Sauerbraten · Shepherd's Pie · Spanakopita · Spaghetti Aglio e Olio · Spaghetti all'Amatriciana · Spaghetti Bolognese · Spanish Paella · Steak Frites · Stollen · Tarte Tatin · Tiramisu · Tomato Soup · Tortilla Española
Asia & Southeast Asia	Banh Mi · Beef Rendang · Biryani · Bulgogi · Butter Chicken · Cantonese Steamed Fish · Char Kway Teow · Chicken Tikka Masala · Chow Mein · Dan Dan Noodles · Jianbing · Khao Soi · Kimchi Fried Rice · Kung Pao Chicken · Laksa · Lo Mein · Massaman Curry · Nasi Goreng · Nasi Lemak · Okonomiyaki · Pad See Ew · Pad Thai · Palak Paneer · Rogan Josh · Som Tum · Sushi Rice · Sweet & Sour Chicken · Teriyaki Chicken · Thai Green Curry · Tonkatsu · Tonkotsu Ramen · Yakisoba
Middle East & North Africa	Falafel · Hummus · Koshary · Lentil Soup · Moroccan Lamb Tagine · Mutabal · Pita Bread · Shakshuka · Shish Taouk · Tabbouleh
Americas	Angel Food Cake · Baked Potato · Baked Salmon · Baked Ziti · Banana Bread · BBQ Ribs · Biscuits & Gravy · Buttermilk Pancakes · Caesar Salad · Carnitas · Ceviche · Cheese Quesadilla · Chicken Fajitas · Chicken Noodle Soup · Chicken Parmesan · Chili con Carne · Chocolate Chip Cookies · Classic Chocolate Cake · Cobb Salad · Crab Cakes · Creamed Spinach · Eggs Benedict · Fish Tacos · French Dip Sandwich · French Toast · Fudge Brownies · Garlic Butter Shrimp · Ground Beef Tacos · Italian-American Meatballs · Jerk Chicken · Key Lime Pie · Lobster Roll · Lomo Saltado · Macaroni & Cheese · Mashed Potatoes · Mole Poblano · Pan-Seared Pork Chops · Pan-Seared Scallops · Pão de Queijo · Pastel de Choclo · Pecan Pie · Philly Cheesesteak · Pot Roast · Pozole · Pulled Pork · Roasted Brussels Sprouts · Roasted Cauliflower · Sautéed Mushrooms · Shrimp Scampi · Southern Fried Chicken · Tamales · Texas Smoked Brisket · Turkey Meatballs · Vanilla Cupcakes · Vegetable Fried Rice · Waldorf Salad
Africa	Bunny Chow · Efo Riro · Melktert · Muamba de Galinha · Suya

All recipes accept multiple aliases (e.g. "rendang", "tikka-masala", "risotto", "bourguignon", "carbonara"). Use list_dishes for the full live catalog.

Missing a Dish?

The catalog is regularly expanding. If your agent requires verification for a dish not currently supported, please open an issue on GitHub to request it. We prioritize additions based on developer demand.

Example Verification Output

What does a Guardian verification report actually look like? Here's the response structure when an AI agent submits a recipe with authenticity issues:

json

{
  "verdict": "FAILED",
  "response_format_version": "v3",
  "findings": [
    {
      "issue": "MISSING_REQUIRED_INGREDIENT",
      "severity": "CRITICAL",
      "justification": "This ingredient provides a signature flavour component essential to the dish's identity."
    },
    {
      "issue": "WRONG_COOKING_MEDIUM",
      "severity": "WARNING",
      "justification": "Cooking medium fundamentally affects texture and flavour."
    }
  ],
  "allergen_warnings": ["milk", "eggs"],
  "summary": {"INFO": 1, "WARNING": 1, "CRITICAL": 2}
}

Each finding includes a severity and a justification grounded in culinary science — letting the agent fix only what's wrong instead of guessing.

Files in This Repository

File	Purpose
`schema.md`	Complete `candidate_json` structure required by `verify_recipe`
`client.py`	Python example: submit a recipe for verification
`test_integration.py`	Live connectivity test against the public API
`smithery.yaml`	Smithery MCP registry configuration
`glama.json`	Glama.ai MCP server claim configuration

Data & Privacy

No PII collected — we do not store user names, emails, or API keys. Underlying cloud infrastructure may temporarily process IP addresses for routing.
Data for Compute Exchange — the free service is provided in exchange for usage data. Submitted recipes are used to improve verification accuracy and create anonymized derived datasets. See our Terms of Service.
Do not include PII in recipe payloads.
Fair use quotas enforced via compute limits.

CAUTION

Not a Substitute for Food Safety Knowledge
While Guardian Engine catches explicitly dangerous AI hallucinations (like serving poultry below safe temperatures), it cannot guarantee a recipe is 100% safe to consume. Pathogen destruction relies on variables (time, mass, equipment) that text-based AI models cannot perfectly control. Verification results are informational and must always be paired with human common sense and standard kitchen safety practices.

Support & Contact

Building an AI cooking assistant, smart kitchen platform, or agentic food-tech product? We'd love to hear from you.

Email: partners@kaimeilabs.dev
Website: kaimeilabs.dev
GitHub: github.com/kaimeilabs

License

Client code in this repository (client.py, test_integration.py) is released under the MIT License. The Guardian Engine verification logic and master recipe datasets are proprietary.

Install

claude_desktop_config.json

{
  "mcpServers": {
    "guardian-engine": {
      "command": "npx",
      "args": [
        "-y",
        "mcp-remote",
        "https://api.kaimeilabs.dev/mcp"
      ]
    }
  }
}

Desktop config is stdio-only; this bridges via mcp-remote. Native remote: Settings > Connectors.