ask.recipes

Remember how the household eats

update_profile

DestructiveIdempotent

Save what the user says about how they eat so it holds across sessions and clients: "we don't eat cilantro" is add_dislikes, "my daughter can't have berries or tomatoes" is add_allergens, "we love meat" is add_likes, "weeknights are 30 minutes max" is time_budget_minutes, "we're five" is household_size, "grams please" is units=metric. Only the fields passed change; lists are added to or removed from, never replaced, so nothing already saved is lost. Pass 0 for a number to clear it. Something one person cannot or will not eat goes on that person under people, so a search with who can leave it out when they are not at the table; what everyone avoids goes on the household lists. Give each person a role (kid, adult, parent, guest) when the user says it, so who can name a group. From then on allergens and dislikes are excluded from every search as whole words, vegetarian, vegan, gluten_free, dairy_free and nut_free diets stay on, and the time budget is the default time limit. Returns the whole profile after the change; read it back to the user in one short list. When allergens were added it carries a note to pass on once: exclusions match whole words, so for a serious allergy the user should still read ingredients and labels themselves.

Input Schema

Name	Required	Description
`units`	No	metric or us, the measurements the user wants to read; get_recipe converts amounts and oven temperatures to it; empty string clears it
`people`	No	people in the household with a role and what applies to them alone: 'Sam, our kid, can't have berries' is people=[{name:'Sam', role:'kid', add_allergens:['berries']}]; what everyone avoids goes on the household lists instead. Each entry changes only that person and only the fields passed
`add_diets`	No	diets followed; vegetarian, vegan, gluten_free, dairy_free and nut_free switch the matching filter on for every search, any other value is stored for you to read
`add_likes`	No	ingredients or dishes the household loves, e.g. ['meat','pasta','spicy food']; nothing is filtered on them, read them to steer what you suggest
`add_cuisines`	No	cuisines the household likes, e.g. ['italian','mexican','thai']; stored for you to read
`add_dislikes`	No	ingredients the household avoids by taste, e.g. ['cilantro','mushrooms']; excluded from every search as whole words
`remove_diets`	No
`remove_likes`	No
`add_allergens`	No	ingredients nobody in the household may eat, medical or otherwise, one per entry, e.g. ['peanuts','berries','tomatoes']; excluded from every search as whole words
`fat_g_per_day`	No	daily fat goal in grams; 0 clears it
`remove_people`	No	names to take off the profile
`household_size`	No	how many people usually eat, e.g. 5 for two adults and three children; 0 clears it
`carbs_g_per_day`	No	daily carbohydrate goal in grams; 0 clears it
`remove_cuisines`	No
`remove_dislikes`	No
`calories_per_day`	No	daily calorie goal when the user tracks one; 0 clears it
`remove_allergens`	No
`protein_g_per_day`	No	daily protein goal in grams; 0 clears it
`time_budget_minutes`	No	most minutes a usual dinner may take in total; becomes the default time limit on every search; 0 clears it

Output Schema

Name	Required	Description
`set`	Yes	false when nothing has been saved yet
`note`	No
`diets`	Yes
`likes`	Yes
`units`	No
`people`	Yes
`cuisines`	Yes
`dislikes`	Yes
`allergens`	Yes
`household`	No	present when the user shares a kitchen with other ask.recipes accounts; their allergens and dislikes apply to searches for everyone
`fat_g_per_day`	No
`household_size`	No
`carbs_g_per_day`	No
`calories_per_day`	No
`protein_g_per_day`	No
`time_budget_minutes`	No

Schema Changelog

Changes observed during successful MCP inspections.

Changed1 schema field changedOct 31, 2026

addedOutput schema / properties / household

Added value: +{
+  "description": "present when the user shares a kitchen with other ask.recipes accounts; their allergens and dislikes apply to searches for everyone",
+  "properties": {
+    "in_household": {
+      "description": "false when this account shares a kitchen with nobody yet",
+      "type": "boolean"
+    },
+    "members": {
+      "items": {
+        "properties": {
+          "creator": {
+            "description": "the member who created the household; the only one who can remove others",
+            "type": "boolean"
+          },
+          "joined_on": {
+            "type": "string"
+          },
+          "name": {
+            "type": "string"
+          },
+          "you": {
+            "type": "boolean"
+          }
+        },
+        "required": [
+          "name",
+          "joined_on"
+        ],
+        "type": "object"
+      },
+      "type": [
+        "null",
+        "array"
+      ]
+    },
+    "name": {
+      "type": "string"
+    },
+    "note": {
+      "type": "string"
+    }
+  },
+  "required": [
+    "in_household",
+    "members"
+  ],
+  "type": [
+    "null",
+    "object"
+  ]
+}

Changed4 schema fields changedOct 31, 2026

changedInput schema / properties / add_allergens / description

Previous value: -"ingredients nobody at the table may eat, medical or otherwise, one per entry, e.g. ['peanuts','berries','tomatoes']; excluded from every search as whole words"New value: +"ingredients nobody in the household may eat, medical or otherwise, one per entry, e.g. ['peanuts','berries','tomatoes']; excluded from every search as whole words"

changedInput schema / properties / people / description

Previous value: -"people at the table with a role and what applies to them alone: 'Sam, our kid, can't have berries' is people=[{name:'Sam', role:'kid', add_allergens:['berries']}]; what everyone avoids goes on the household lists instead. Each entry changes only that person and only the fields passed"New value: +"people in the household with a role and what applies to them alone: 'Sam, our kid, can't have berries' is people=[{name:'Sam', role:'kid', add_allergens:['berries']}]; what everyone avoids goes on the household lists instead. Each entry changes only that person and only the fields passed"

changedInput schema / properties / people / items / properties / role / description

Previous value: -"one word for who they are at the table, e.g. 'kid', 'adult', 'parent', 'guest'; who on a search accepts a role as well as a name, so 'the kids are out' is who=['adults']; empty string clears it"New value: +"one word for who they are in the household, e.g. 'kid', 'adult', 'parent', 'guest'; who on a search accepts a role as well as a name, so 'the kids are out' is who=['adults']; empty string clears it"

addedOutput schema / properties / note
```
Added value: +{
+  "type": "string"
+}
```

Changed1 schema field changedOct 30, 2026

changedInput schema / properties / units / description

Previous value: -"metric or us, the measurements the user wants to read; empty string clears it"New value: +"metric or us, the measurements the user wants to read; get_recipe converts amounts and oven temperatures to it; empty string clears it"

Changed4 schema fields changedOct 29, 2026

addedInput schema / properties / people

Added value: +{
+  "description": "people at the table with a role and what applies to them alone: 'Sam, our kid, can't have berries' is people=[{name:'Sam', role:'kid', add_allergens:['berries']}]; what everyone avoids goes on the household lists instead. Each entry changes only that person and only the fields passed",
+  "items": {
+    "additionalProperties": false,
+    "properties": {
+      "add_allergens": {
+        "description": "ingredients this person cannot eat; excluded whenever they are eating",
+        "items": {
+          "type": "string"
+        },
+        "type": [
+          "null",
+          "array"
+        ]
+      },
+      "add_dislikes": {
+        "description": "ingredients this person avoids by taste; excluded whenever they are eating",
+        "items": {
+          "type": "string"
+        },
+        "type": [
+          "null",
+          "array"
+        ]
+      },
+      "add_likes": {
+        "description": "what this person loves; read, never filtered",
+        "items": {
+          "type": "string"
+        },
+        "type": [
+          "null",
+          "array"
+        ]
+      },
+      "name": {
+        "description": "the person's name as the user says it, e.g. 'Sam' or 'Dad'; matched case-insensitively, created on first use",
+        "type": "string"
+      },
+      "remove_allergens": {
+        "items": {
+          "type": "string"
+        },
+        "type": [
+          "null",
+          "array"
+        ]
+      },
+      "remove_dislikes": {
+        "items": {
+          "type": "string"
+        },
+        "type": [
+          "null",
+          "array"
+        ]
+      },
+      "remove_likes": {
+        "items": {
+          "type": "string"
+        },
+        "type": [
+          "null",
+          "array"
+        ]
+      },
+      "role": {
+        "description": "one word for who they are at the table, e.g. 'kid', 'adult', 'parent', 'guest'; who on a search accepts a role as well as a name, so 'the kids are out' is who=['adults']; empty string clears it",
+        "type": [
+          "null",
+          "string"
+        ]
+      }
+    },
+    "required": [
+      "name"
+    ],
+    "type": "object"
+  },
+  "type": [
+    "null",
+    "array"
+  ]
+}

addedInput schema / properties / remove_people

Added value: +{
+  "description": "names to take off the profile",
+  "items": {
+    "type": "string"
+  },
+  "type": [
+    "null",
+    "array"
+  ]
+}

addedOutput schema / properties / people

Added value: +{
+  "items": {
+    "properties": {
+      "allergens": {
+        "items": {
+          "type": "string"
+        },
+        "type": [
+          "null",
+          "array"
+        ]
+      },
+      "dislikes": {
+        "items": {
+          "type": "string"
+        },
+        "type": [
+          "null",
+          "array"
+        ]
+      },
+      "likes": {
+        "items": {
+          "type": "string"
+        },
+        "type": [
+          "null",
+          "array"
+        ]
+      },
+      "name": {
+        "type": "string"
+      },
+      "role": {
+        "type": "string"
+      }
+    },
+    "required": [
+      "name",
+      "role",
+      "allergens",
+      "dislikes",
+      "likes"
+    ],
+    "type": "object"
+  },
+  "type": [
+    "null",
+    "array"
+  ]
+}

changedOutput schema / required

Previous value: -[
-  "set",
-  "diets",
-  "allergens",
-  "dislikes",
-  "likes",
-  "cuisines"
-]New value: +[
+  "set",
+  "diets",
+  "allergens",
+  "dislikes",
+  "likes",
+  "cuisines",
+  "people"
+]

AddedOct 29, 2026

TDQS

A4.6/5.0

Behavior4/5

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

Goes well beyond the annotations: discloses additive list semantics ('added to or removed from, never replaced'), that 0 clears numeric fields, the downstream effects on every later search (whole-word exclusion, diet filters, default time limit), and the one-time allergy caveat to relay. Remaining gap: it never says whose profile is written when a household is shared (invite_to_household/update_household exist as siblings), so precedence between members' units and diets is unstated; the 'nothing already saved is lost' phrasing also sits slightly awkwardly with destructiveHint=true, though the explicit remove_* fields resolve that.

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

Conciseness4/5

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

Front-loaded with the highest-value content (the example-to-field mapping) and dense rather than padded; length is justified by 19 parameters. The single-paragraph block makes the allergy safety note and the return-value instruction easy to skim past, which costs it a point.

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?

For a 19-parameter mutation tool it covers what matters: which fields change, how clearing works, what happens downstream, and what comes back ('returns the whole profile after the change; read it back in one short list') even though an output schema exists. Nothing needed to call it correctly is absent.

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

Parameters4/5

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

At 74% schema coverage the schema already documents most fields, yet the description adds real value: worked examples for likes/dislikes/allergens, the 0-clears convention for all numeric goals, and the rule that a person's role makes them addressable by group in who. It does not, however, explain the four remove_* fields that have no schema description, nor fat/carbs/calories/protein interaction.

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

Purpose5/5

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

Specific verb+resource ('Save what the user says about how they eat') with the scope stated immediately: persistence across sessions and clients. It is clearly distinguished from read-side siblings (get_profile, get_household) and from update_household by naming exactly which household attributes it owns.

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

Usage Guidelines5/5

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

Gives explicit utterance-to-field routing ("we don't eat cilantro" → add_dislikes, "my daughter can't have berries" → people[].add_allergens, "grams please" → units=metric), plus the decision rule for household lists vs per-person lists. An agent can map free-form user speech to parameters without inference.

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

All ask.recipes tools Inspect

Try in Browser

Context All Your Agents Can ShareAgents share what they learn, hand off work, and hold it when you switch models. Start with 5 GB free.fulcradynamics.comAd

Glama MCP Gateway

Add one secure layer between your agents and this server.