Cronometer MCP

create_recipe

Idempotent

Create or update Cronometer recipes from ingredient foods and gram amounts; Cronometer calculates nutrients automatically. Use search_foods first to find food and measure IDs.

Instructions

Create a recipe from ingredients, or update one by passing recipe_id.

Cronometer sums the nutrients from the ingredients itself, so unlike add_custom_food you give foods and amounts, not nutrient values. Use search_foods to find each ingredient's food_id and measure_id first.

Cronometer locks a recipe's serving type when it is created and it cannot be changed afterwards, so choose deliberately:

"weight" (default) measures the recipe in grams. Portions log as plain grams in every client, including the mobile app's own entry screen. The ingredient list is recorded in the notes rather than as editable ingredients, because Cronometer will not compute a correct weight from ingredients that use non-weight measures.
"servings" keeps an editable ingredient list in Cronometer, but the mobile app then offers only a 1 g serving and hides the amount field. Logging through this server is still correct in grams.

cooked_grams is the weight of the finished dish. Give it whenever the food was baked or simmered: nutrients are stored per 100 g, and a dish that lost water is denser than its raw ingredients, so without it a portion weighed off the plate logs too little.

Updating with recipe_id replaces the whole ingredient list, so pass every ingredient, not only new ones. Recipes are removed with retire_custom_food, the same as custom foods.

Args: name: Recipe name. ingredients: List of {"food_id": int, "grams": float, "measure_id": int (optional)}. servings: How many portions the batch makes. notes: Free-text note stored on the recipe. recipe_id: Existing recipe to update in place. serving_type: "weight" or "servings". Cannot be changed later. cooked_grams: Weight of the finished dish, if it lost water in cooking.

Tool call template

Replace each placeholder with a value matching the input schema. Only required parameters are included; add optional parameters as needed.

{
  "id": 1,
  "jsonrpc": "2.0",
  "method": "tools/call",
  "params": {
    "arguments": {
      "name": "<name>",
      "ingredients": "<ingredients>"
    },
    "name": "create_recipe"
  }
}

Input Schema

Name	Required	Default
`name`	Yes
`notes`	No
`servings`	No
`recipe_id`	No
`ingredients`	Yes
`cooked_grams`	No
`serving_type`	No	weight

Output Schema

Name	Required	Description	Default
`result`	Yes

Schema Changelog

Changes observed during successful MCP inspections.

First observedv2.1.0Nov 14, 2026

TDQS

A4.6/5.0

Behavior5/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

The description discloses significant behavior beyond the annotations: Cronometer sums nutrients itself, serving type is locked after creation, 'weight' stores ingredients in notes, and updating replaces the entire ingredient list. These are exactly the non-obvious behaviors an agent needs to avoid incorrect calls.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is long but deliberately structured: a front-loaded summary, then focused paragraphs on important tradeoffs, bullets for serving types, and a concise Args list. Every sentence carries meaningful guidance, and the length is justified by the tool's complexity.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness5/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

The definition covers prerequisites, alternatives, update semantics, serving-type constraints, and cooking-weight edge cases. With an output schema present, return values need no explanation, and no critical calling context appears missing.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters5/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 0%, but the description's Args section fully compensates by explaining each parameter, including the exact shape of ingredients and the meaning of cooked_grams, serving_type, and recipe_id. This is a complete parameter-semantics layer over the bare schema.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose4/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states a specific action ('Create a recipe from ingredients, or update one by passing recipe_id') and differentiates from add_custom_food by noting it takes foods and amounts, not nutrient values. However, it never mentions the sibling tool update_recipe, so the update path overlaps with a sibling without any distinction.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines4/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description gives explicit practical guidance: use search_foods first, use add_custom_food instead when providing nutrient values, and provide cooked_rams for baked or simmered dishes. It does not, however, explain when to use create_recipe vs the sibling update_recipe.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Deploy Server