Recipe Nutrition Calculator
Server Details
Recipe nutrition from ingredient lines: USDA FoodData Central values, per serving, FDA rounding.
- Status
- Healthy
- Last Tested
- Transport
- Streamable HTTP · MCP 2025-11-25
- URL
- Repository
- theluckystrike/recipe-nutrition-calculator-mcp
- GitHub Stars
- 0
- Server Listing
- Recipe Nutrition Calculator MCP
TDQS
Scored across 4 tools
Each tool has a recognizable core job: lookup single-ingredient data, calculate a full recipe, scale a recipe, and apply FDA rounding rules. The only real overlap is between calculate_recipe_nutrition and scale_recipe_nutrition, since scaling essentially recomputes a recipe with a factor and also returns rounded per-serving values; the descriptions distinguish them by input (ingredient lines vs. factor/servings), but an agent could still pick the wrong one. round_nutrition_label is separable because it operates on arbitrary unrounded values rather than a recipe.
All four names are snake_case with a verb_object pattern (calculate_, lookup_, round_, scale_) and a shared nutrition/recipe domain suffix. The convention is uniform and predictable, so an agent can infer a tool's role from its name alone.
Four tools is on the lean side but appropriate for a narrowly scoped nutrition calculator, and each tool covers a distinct step (lookup, calculate, scale, round). It is slightly under-provisioned given the domain, but no tool feels redundant or padded.
The core lifecycle—look up an ingredient, compute a recipe, scale it, and format the label—is covered end to end, with graceful handling of unmatched lines. The notable gap is discovery: with 406 embedded ingredients there is no search or list tool, so an agent must already know exact ingredient names and has no fallback for unmatched entries. A unit-conversion or ingredient-browse helper would close that hole.
Available Tools
4 toolscalculate_recipe_nutritionCalculate nutrition for a whole recipe and per servingARead-onlyIdempotentInspect
Parses ingredient lines ("2 cups flour", "1 stick butter" as 8 tbsp, "3 large eggs", "1 lb ground beef"), converts cups, spoons and counted items to grams with USDA household measure weights for that specific food, and sums USDA FoodData Central nutrients. Returns per-line grams and matches, recipe totals, per-serving values, and the per-serving values rounded by the FDA Nutrition Facts rules (21 CFR 101.9) with percent Daily Value. Lines it cannot match are listed, never guessed.
| Name | Required | Description | Default |
|---|---|---|---|
| lines | Yes | Ingredient lines, one per item, amount first: "2 cups all-purpose flour", "1/2 cup butter", "2 large eggs", "200 g chicken breast", "1 tsp salt". | |
| servings | No | Number of servings the recipe makes. Default 1. |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already cover the safety profile (readOnly, idempotent, non-destructive, closed-world), and the description goes well beyond them: it discloses the conversion methodology (USDA household measure weights per food), the full return payload (per-line grams and matches, totals, per-serving, FDA-rounded with %DV), and crucially the failure behavior — unmatched lines are listed, never guessed. That failure-mode disclosure is exactly the kind of context annotations cannot carry.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The capability statement is front-loaded and the return-value inventory follows; no filler sentences. The first sentence is very long and packs parsing, conversion, and summation into one clause chain, which costs a little readability.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
There is no output schema, and the description compensates fully by enumerating the return fields and the FDA rounding basis. Combined with 100% schema coverage on inputs, an agent has everything needed to call this correctly and interpret results.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100%, so the baseline is 3; the description adds real meaning by explaining how 'lines' are interpreted (amount first, household units converted to grams via USDA weights) and that 'servings' drives the per-serving outputs. It stops short of stating unit/edge-case rules for the lines array beyond the examples the schema already gives.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
Specific verb chain (parses, converts, sums) with a concrete resource (recipe nutrition) and worked examples of the input format, so the agent knows exactly what it does. It never names the sibling tools it overlaps with (lookup_ingredient_nutrition for single items, round_nutrition_label for FDA rounding, scale_recipe_nutrition for rescaling), so differentiation is left to inference.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Usage is implied by the scope statement (whole recipe, totals plus per-serving), but there is no explicit 'use this when' or 'use X instead' guidance. The mention of FDA rounding hints at overlap with round_nutrition_label without resolving it.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
lookup_ingredient_nutritionLook up USDA nutrients for an ingredientARead-onlyIdempotentInspect
Returns USDA FoodData Central nutrient values per 100 g (calories, protein, total fat, saturated fat, carbohydrate, fiber, total sugars, sodium) for a common recipe ingredient, with its FDC id, the USDA household measures (1 cup, 1 tbsp, 1 large, 1 clove) in grams, and optionally the nutrients for an amount such as 1.5 cup or 3 large. 406 ingredients from SR Legacy and Foundation Foods, embedded, no API key. Use it instead of estimating nutrition from memory.
| Name | Required | Description | Default |
|---|---|---|---|
| unit | No | Unit for amount: g, oz, lb, kg, cup, tbsp, tsp, fl oz, ml, or "each" for a counted item (uses the USDA medium or large size). Default g. | |
| amount | No | Optional amount to compute nutrients for, e.g. 1.5. | |
| ingredient | Yes | Ingredient name, e.g. "cheddar cheese", "brown rice", "olive oil", "large egg". |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnly/idempotent/closed-world, and the description adds real operational context: 406 ingredients, SR Legacy and Foundation Foods source, embedded data with no API key. What is missing is failure behavior — whether lookups are fuzzy, and what happens for an ingredient outside the 406.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two sentences, front-loaded with the return payload before the usage directive. The nutrient enumeration in the first sentence is somewhat long but earns its place by removing guessing about which fields come back.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
There is no output schema, and the description fully compensates by enumerating returned fields (per-100 g macros, FDC id, household measure weights, optional amount-scaled nutrients) as well as data provenance and coverage size. An agent has enough to call it and interpret the response.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100%, so every parameter is already documented, making 3 the baseline. The description adds only modest value by showing amount and unit used together ('1.5 cup or 3 large') and noting that household measures are returned in grams, but no new syntax or constraints beyond the schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
States a precise verb+resource: returns USDA FoodData Central nutrient values per 100 g for a single recipe ingredient, plus FDC id and household measures. The per-ingredient/per-100 g scoping implicitly separates it from recipe-level siblings, but no sibling is named, so an agent must infer the boundary from the name alone.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
It gives one useful directive — 'Use it instead of estimating nutrition from memory' — which sets a positive trigger. There is no explicit when-not (e.g., whole-recipe calculations vs. single ingredient, what to do for ingredients outside the 406) and no named alternative such as calculate_recipe_nutrition.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
round_nutrition_labelRound values for an FDA Nutrition Facts labelARead-onlyIdempotentInspect
Applies the FDA Nutrition Facts rounding rules from 21 CFR 101.9(c) to unrounded per-serving values: calories (under 5 = 0, nearest 5 up to 50, nearest 10 above), fat and saturated fat (nearest 0.5 g under 5 g), sodium (nearest 5 mg up to 140 mg, nearest 10 above), carbohydrate, fiber, sugars, added sugars and protein (nearest gram, "less than 1g" rules). Adds percent Daily Value from the 2,000-calorie DRVs (fat 78 g, saturated fat 20 g, sodium 2,300 mg, carbohydrate 275 g, fiber 28 g, added sugars 50 g). Rules copied from the eCFR text.
| Name | Required | Description | Default |
|---|---|---|---|
| kcal | Yes | Calories per serving, unrounded. | |
| fat_g | No | Total fat, g per serving. | |
| carbs_g | No | Total carbohydrate, g per serving. | |
| fiber_g | No | Dietary fiber, g per serving. | |
| sugars_g | No | Total sugars, g per serving. | |
| protein_g | No | Protein, g per serving. | |
| sat_fat_g | No | Saturated fat, g per serving. | |
| sodium_mg | No | Sodium, mg per serving. | |
| added_sugars_g | No | Added sugars, g per serving. |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already cover read-only, idempotent, non-destructive, and closed-world behavior, so the bar is lower. The description still adds real substance: the exact rounding tiers per nutrient, the added-sugars/fiber 'less than 1g' handling, and the specific DRV values used for percent Daily Value — all beyond what annotations provide.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
A single dense paragraph that front-loads the governing regulation and then enumerates rule groups efficiently; nothing is filler. The nested parentheticals make it slightly harder to scan, keeping it just below a 5.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a pure computation tool with no output schema, the description should hint at the return shape; it names what is produced (rounded values plus percent Daily Value) and implies some outputs may be strings via the 'less than 1g' rule, but never enumerates output fields. That is a minor gap, not a blocking one.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100% and every parameter already carries a description with units and bounds, so the baseline is 3. The description adds meaning by mapping nutrients to their specific rounding treatment (e.g., sodium rounds to 5 mg up to 140 mg, then 10), which is useful but partially redundant with the schema's unit labels.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
States a specific verb and resource — applies FDA Nutrition Facts rounding rules from 21 CFR 101.9(c) — to explicitly scoped inputs (unrounded per-serving values). This is clearly distinct from the sibling tools that calculate, look up, or scale nutrition; nothing overlaps.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The phrase 'to unrounded per-serving values' tells the agent the required input state, which implicitly positions this tool as the step after calculate_recipe_nutrition. It does not, however, explicitly name a sibling or state when not to use it, so it stops short of a 5.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
scale_recipe_nutritionScale a recipe and recompute its nutritionARead-onlyIdempotentInspect
Scales ingredient lines by a factor or from original to target servings (parses mixed numbers and fraction characters), then recomputes total and per-serving nutrition with USDA FoodData Central values and FDA label rounding for the scaled recipe.
| Name | Required | Description | Default |
|---|---|---|---|
| lines | Yes | Ingredient lines, one per item, amount first: "2 cups all-purpose flour", "1/2 cup butter", "2 large eggs", "200 g chicken breast", "1 tsp salt". | |
| factor | No | Multiply every quantity by this, e.g. 2 or 0.5. Or give servings instead. | |
| target_servings | No | Servings you want. | |
| original_servings | No | Servings the recipe makes now. |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare read-only, idempotent, non-destructive, and closed-world behavior. The description adds useful behavioral detail beyond those annotations: parsing mixed numbers and fraction characters, using USDA FoodData Central values, and applying FDA label rounding.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
A single dense sentence with the core action front-loaded. The parenthetical parsing detail and nutrition sourcing/rounding are relevant and no sentence is wasted.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
There is no output schema, so the description appropriately states that total and per-serving nutrition are recomputed. It does not specify the exact response fields or error behavior, but it is complete enough for an agent to understand and invoke the tool.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100%, so parameter meanings are already well documented. The description still adds value by clarifying that factor and original-to-target-servings are alternative scaling modes and by noting mixed-number and fraction-character parsing.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
States a specific verb and resource: scales ingredient lines and recomputes nutrition. It clearly conveys the scaling-plus-nutrition purpose, though it does not explicitly differentiate itself from sibling tools such as calculate_recipe_nutrition.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Explains the two supported scaling modes: by a factor, or from original to target servings. This gives clear usage context, but it does not state when to prefer this tool over the related nutrition-calculation or rounding siblings.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
4 tool updates
- First observed
calculate_recipe_nutrition - First observed
lookup_ingredient_nutrition - First observed
round_nutrition_label - First observed
scale_recipe_nutrition
Related MCP Connectors
USDA FoodData Central nutrition data: search foods, compare macros, and analyze meals.
Search foods, compare nutrients, and look up the full USDA FoodData Central database.
Barcode lookup, nutrition search, and product comparison for 3M+ crowd-sourced food products.
Food and nutrition data: search, macros, and comparisons
Related MCP Servers
- AlicenseAqualityBmaintenanceEnables deterministic recipe and portion math with USDA-sourced macros, gram conversions, cooked yields, and per-eater portions.12MIT
- AlicenseBqualityBmaintenanceEnables querying a global food nutrition database of generic and branded products, including search by name, lookup by barcode, and retrieval of resolved nutrient values pinned to a dated snapshot. Coverage spans USDA FoodData Central and Open Food Facts sources, with freshness health checks available.9AGPL 3.0
- AlicenseAqualityDmaintenanceEnables natural language access to USDA's FoodData Central database with 1M+ foods, supporting search, nutrition facts, food comparison, and daily value calculations.8MIT
- FlicenseAqualityBmaintenanceEnables LLMs to retrieve verified macronutrient data (calories, protein, carbs, fat) for real ingredients and quantities from USDA FoodData Central, with structured caveats for uncertain matches.8-
Glama MCP Gateway
Add one secure layer between your agents and this server.