What can you do with this server?

Explore and scale recipes from the English Wikibooks Cookbook without an API key. * Search recipes by dish name or ingredient (full-text or title search), getting IDs, titles, URLs, and excerpts. * Read a full recipe including ingredients, equipment, steps, tips, times, difficulty, nutrition, and license info. * Rescale ingredients to a target number of servings, with smart rounding for countable items, unit conversions, and flags for unscalable lines. Works on any English ingredient list, even from outside the cookbook. * Browse recipes by cuisine, dish type, or main ingredient (returns a ranked sample). * Read-only: No edits or uploads; attribution support with CC BY-SA 4.0 credit.

Which integrations are available for this server?

Searches, reads, and scales recipes from the English Wikibooks Cookbook, including browsing by cuisine, dish type, or main ingredient.

How do I use mcp-wikibooks-cookbook?

1. Click on "Deploy Server". 2. Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state. 3. In the chat, type @ followed by the MCP server name and your instructions, e.g., "@mcp-wikibooks-cookbook find a recipe for butter chicken and scale it to 4 servings" That's it! The server will respond to your query, and you can continue using it as needed. Here is a step-by-step guide with screenshots.

mcp-wikibooks-cookbook

by smeet666

Overview Schema Source Related Servers Discussions Admin

TypeScript

Remote

mcp-wikibooks-cookbook

npm license MCP Registry Glama M8ven LobeHub Install in Cursor Install in VS Code

The Cookbook is the recipe collection of the English Wikibooks, a Wikimedia project. Thousands of recipes are written and maintained there in the open, each with its ingredients, the equipment it calls for, its steps, the tips and variations its authors added, and the categories it files itself under: a cuisine, a kind of dish, a main ingredient. The pages are published under Creative Commons Attribution-ShareAlike 4.0.

This server connects a chat client to that collection. You can search the recipes by dish or by ingredient, list them by cuisine, kind of dish or main ingredient, read one with its ingredients rescaled to the number of people at your table, and rescale any ingredient list of your own. It needs no API key and no account.

Version française

Install

One-click install

Install in Cursor Install in VS Code

Claude Code

claude mcp add wikibooks-cookbook -- npx -y mcp-wikibooks-cookbook

Claude Desktop, Cursor, and any client using the standard config format

{
  "mcpServers": {
    "wikibooks-cookbook": {
      "command": "npx",
      "args": ["-y", "mcp-wikibooks-cookbook"]
    }
  }
}

Node 24 or later is required, and no environment variable has to be set.

With Docker

{
  "mcpServers": {
    "wikibooks-cookbook": {
      "command": "docker",
      "args": ["run", "-i", "--rm", "ghcr.io/smeet666/mcp-wikibooks-cookbook:2.1.0"]
    }
  }
}

-i keeps stdin open, which is where the protocol travels, and -t is left out because a TTY rewrites the stream. The container needs outbound HTTPS to api.wikimedia.org, and nothing else: no volume, no port, no credential.

Bundle, without npm

Download mcp-wikibooks-cookbook-2.1.0.mcpb from the latest release and open it. A client that supports MCP bundles installs it on its own, with no npm and no configuration file to edit. The bundle carries its dependencies, so nothing is fetched at install time.

Related MCP server: yes_chef_mcp

What you can ask

"Find me a carbonara recipe in the Cookbook."
"Read it for six people instead of four."
"What Thai soups does the collection hold?"
"Which recipes are built on lentils?"
"Scale this ingredient list by 2.5 for me."

The ordinary path runs from a search to a reading: a row carries an id, the page key, and get_recipe takes that key.

Tools

Tool	What it does
`search_recipes`	Finds recipes by dish or by ingredient.
`get_recipe`	Reads one recipe, rescaled to a number of servings on request.
`scale_ingredients`	Rescales any ingredient list, with no request to the wiki.
`list_recipes`	Lists recipes by cuisine, kind of dish or main ingredient.

`search_recipes`

Searches the Cookbook, either across the whole text of its pages or across their titles alone.

Argument	Type	Required	What it does
`query`	string, 1 to 300 characters	yes	A dish, such as `carbonara`, or an ingredient, such as `guanciale`.
`search`	`text` or `title`, default `text`	no	`text` reads the whole page; `title` matches the page name alone.
`limit`	integer, 1 to 50, default `10`	no	Rows to serve.

In return: rows carrying id, the page key get_recipe takes; title; url; image_url; description, the short gloss the wiki keeps for a page; and excerpt, the matching passage with the highlight markup taken off. Each of the last three is null where the search offered none. total_available is always null: the search route publishes no total and no paging, so result_count counts the rows this call returned.

`get_recipe`

Reads one recipe, and rescales its ingredients when a number of servings is given.

Argument	Type	Required	What it does
`id`	string, 1 to 300 characters	yes	The page key, such as `Cookbook:Spaghetti_alla_Carbonara`.
`servings`	integer, 1 to 500	no	Rescale the ingredients to this many servings.
`max_description_chars`	integer, 100 to 20000, default `1200`	no	How much of the page's prose to serve.

In return: title, url, ingredients, equipment, steps, tips for the notes and variations the page publishes, prep_minutes, cook_minutes, total_minutes, time_text in the page's own wording, time_phases, category and categories for every category the page files itself under. A figure the page states nothing for is null. id names the page that was read, which differs from the key asked for after a redirect, and redirected_from then names the key that led there. yield says what the recipe was written for and what it was rescaled to, and each ingredient carries scaling, reading scaled, rounded or unscaled.

`scale_ingredients`

Applies the same arithmetic to any list of ingredient lines, with no request to the wiki.

Argument	Type	Required	What it does
`ingredients`	array of 1 to 100 strings, up to 300 chars	yes	The lines to rescale.
`factor`	number, above 0 and up to 100	one of two	The multiplier to apply.
`from_servings`	number, above 0 and up to 500	one of two	How many servings the list is written for.
`to_servings`	number, above 0 and up to 500	one of two	How many servings are wanted.

Pass factor, or the from_servings and to_servings pair.

In return: the factor used, the rescaled ingredients in the shape get_recipe returns, and scaled_count, rounded_count and unscaled_count.

`list_recipes`

Lists recipes along the categories the Cookbook files them under. The arguments combine, and the answer says which search was built from them.

Argument	Type	Required	What it does
`cuisine`	string, up to 80 characters	no	A cuisine or a country, such as `Italian` or `Thai`.
`dish_type`	string, up to 80 characters	no	A kind of dish, such as `soup`, `dessert` or `bread`.
`main_ingredient`	string, up to 80 characters	no	The ingredient a recipe is built on.
`limit`	integer, 1 to 50, default `15`	no	Rows to serve.

In return: the rows search_recipes returns, with query naming the search this server built from the arguments, and each argument echoed back or null where it was left out.

Rescaling the quantities

A quantity is stated in the unit that suits it, so a line can come back in a different unit from the one the recipe used: 200 g multiplied by twenty reads 4 kg.

How finely an ingredient can be divided depends on what it is. A loaf can be cut in two, in three or in four; an egg cannot be shared out. A quantity landing between the two is rounded, and the rescaled recipe then departs a little from the proportions of the original. The line carries rounded, and its note says what was done.

The figures are this server's arithmetic, so say they were recomputed when you show them. A recipe whose page states no number of servings cannot be put to a number of people, and the answer says so.

Licence and attribution

Cookbook pages are published under Creative Commons Attribution-ShareAlike 4.0. Repeating a recipe means crediting Wikibooks and the page it came from, and sharing what is built on it under the same licence. get_recipe returns both license and the page url, so an answer carries the credit with it.

Configuration

Every variable is optional. Set them in the env block of your client config.

Variable	Default	What it does
`WB_USER_AGENT`	the project identity	Names your application to Wikimedia, with an address where a person can be reached.
`WB_MIN_INTERVAL_MS`	`1000`	Gap between two requests, from 500 to 60000.
`WB_TIMEOUT_MS`	`20000`	Deadline for one request, from 1000 to 120000.
`WB_MAX_RETRIES`	`3`	Attempts after a transient failure, from 0 to 8.
`WB_CACHE_TTL_MS`	`900000`	How long a page stays in memory, from 0 to 86400000.
`WB_CACHE_MAX_ENTRIES`	`200`	Pages held in memory at once, from 1 to 5000.
`WB_MAX_BODY_BYTES`	`8000000`	Largest page this reads, in bytes, from 100000 to 64000000.
`WB_LOG_LEVEL`	`error`	`silent`, `error`, `info` or `debug`, written to stderr.

A value outside its range falls back to the default, and the reason is written to stderr.

Errors

Every failure carries one of six codes, a message, and where it helps a hint naming the next move.

Code	What happened	What to do
`not_found`	The wiki answered, and holds no such page.	Check the page key with `search_recipes`.
`invalid_input`	The arguments were refused before any request went out.	Read the message, which names the argument.
`rate_limited`	Wikimedia asked this client to slow down.	Wait the number of seconds the hint names and call again with the same arguments. The recipe is still there.
`parse_failure`	The page loaded and the expected content was absent.	Report it at the issue tracker.
`network_error`	The request did not complete.	Try again shortly.
`timeout`	The request passed its deadline.	Raise `WB_TIMEOUT_MS`, or ask for fewer rows.

As a library

The layer reading the wiki is published on its own, with its pacing, its cache and its errors, and with no protocol attached.

import { WikibooksClient } from "mcp-wikibooks-cookbook/client";

const client = new WikibooksClient();
const { data, cached } = await client.getRecipe("Cookbook:Spaghetti_alla_Carbonara");
console.log(data.title, data.ingredients.length, cached);

search and getRecipe each answer { data, cached }, and throw an error carrying one of the six codes. The floor between two requests holds here as well.

Pacing and attribution

Requests go out one at a time with at least a second between them, and the floor of half a second holds however the server is configured. The User-Agent always ends with the project identity and an address where a person can be reached.

Reads go to api.wikimedia.org, the host Wikimedia documents and maintains for developers. Every result carries the address of the page it was read from, and the licence it is published under.

This MCP server is an unofficial project, with no affiliation to Wikimedia or to the Wikibooks community.

Privacy

This server collects nothing about you and sends nothing to its author. It runs on your machine, contacts api.wikimedia.org and nothing else, holds its answers in memory while it runs, and writes nothing to disk. PRIVACY.md states what a request carries and which settings change any of it.

Development

npm install
npm run build:fixtures
npm test
npm run check

Tests run against generated fixtures and make no network request. The live suite, npm run test:live, makes one request per route and runs nightly against the service itself.

Contributing

Bugs, questions and ideas belong in the issue tracker. Pull requests are welcome; opening an issue first helps agree on the shape of the change. See CONTRIBUTING.md.

License

MIT for this server's own code, see LICENSE. The Cookbook pages belong to their authors and to the Wikibooks community, under CC BY-SA 4.0.

mcp-wikibooks-cookbook (français)

English version

Le Cookbook est la collection de recettes des Wikibooks anglophones, un projet Wikimedia. Des milliers de recettes y sont écrites et entretenues à découvert, chacune avec ses ingrédients, le matériel qu'elle demande, ses étapes, les conseils et variantes que ses auteurs ont ajoutés, et les catégories sous lesquelles elle se range : une cuisine, un type de plat, un ingrédient principal. Les pages sont publiées sous Creative Commons Attribution-Partage dans les mêmes conditions 4.0.

Ce serveur relie un client de conversation à cette collection. On peut y chercher des recettes par plat ou par ingrédient, les lister par cuisine, type de plat ou ingrédient principal, en lire une avec ses ingrédients adaptés au nombre de convives, et adapter n'importe quelle liste d'ingrédients. Aucune clé d'API, aucun compte.

Installation

Installation en un clic

Install in Cursor Install in VS Code

Claude Code

claude mcp add wikibooks-cookbook -- npx -y mcp-wikibooks-cookbook

Claude Desktop, Cursor, et tout client au format de configuration standard

{
  "mcpServers": {
    "wikibooks-cookbook": {
      "command": "npx",
      "args": ["-y", "mcp-wikibooks-cookbook"]
    }
  }
}

Node 24 ou plus récent est nécessaire, et aucune variable d'environnement n'est à renseigner.

Avec Docker

{
  "mcpServers": {
    "wikibooks-cookbook": {
      "command": "docker",
      "args": ["run", "-i", "--rm", "ghcr.io/smeet666/mcp-wikibooks-cookbook:2.1.0"]
    }
  }
}

-i garde l'entrée standard ouverte, qui est le canal du protocole, et -t est omis parce qu'un TTY réécrit le flux. Le conteneur a besoin d'un accès HTTPS sortant vers api.wikimedia.org, et de rien d'autre : aucun volume, aucun port, aucun identifiant.

Bundle, sans npm

Téléchargez mcp-wikibooks-cookbook-2.1.0.mcpb depuis la dernière publication et ouvrez-le. Un client qui gère les bundles MCP l'installe seul, sans npm et sans fichier de configuration à modifier. Le bundle emporte ses dépendances, donc rien n'est téléchargé à l'installation.

Ce qu'on peut demander

« Trouve-moi une recette de carbonara dans le Cookbook. »
« Lis-la pour six personnes au lieu de quatre. »
« Quelles soupes thaïes la collection contient-elle ? »
« Quelles recettes sont bâties sur les lentilles ? »
« Multiplie cette liste d'ingrédients par 2,5. »

Le chemin ordinaire va d'une recherche à une lecture : une ligne porte un id, la clé de page, et get_recipe reprend cette clé.

Les outils

Outil	Ce qu'il fait
`search_recipes`	Trouve des recettes par plat ou par ingrédient.
`get_recipe`	Lit une recette, adaptée à un nombre de parts sur demande.
`scale_ingredients`	Adapte n'importe quelle liste d'ingrédients, sans requête au wiki.
`list_recipes`	Liste des recettes par cuisine, type de plat ou ingrédient principal.

`search_recipes`

Cherche dans le Cookbook, soit dans tout le texte de ses pages, soit dans leurs seuls titres.

Argument	Type	Requis	Ce qu'il fait
`query`	chaîne, 1 à 300 caractères	oui	Un plat, comme `carbonara`, ou un ingrédient, comme `guanciale`.
`search`	`text` ou `title`, défaut `text`	non	`text` lit toute la page ; `title` ne correspond qu'au nom de la page.
`limit`	entier, 1 à 50, défaut `10`	non	Lignes à servir.

En retour : des lignes portant id, la clé de page que get_recipe reprend ; title ; url ; image_url ; description, la courte glose que le wiki garde pour une page ; et excerpt, le passage correspondant débarrassé de son balisage de surlignage. Chacun des trois derniers vaut null là où la recherche n'en a proposé aucun. total_available vaut toujours null : la route de recherche ne publie ni total ni pagination, donc result_count compte les lignes rendues par cet appel.

`get_recipe`

Lit une recette, et adapte ses ingrédients quand un nombre de parts est donné.

Argument	Type	Requis	Ce qu'il fait
`id`	chaîne, 1 à 300 caractères	oui	La clé de page, comme `Cookbook:Spaghetti_alla_Carbonara`.
`servings`	entier, 1 à 500	non	Adapte les ingrédients à ce nombre de parts.
`max_description_chars`	entier, 100 à 20000, défaut `1200`	non	La quantité de prose de la page à servir.

En retour : title, url, ingredients, equipment, steps, tips pour les notes et variantes que la page publie, prep_minutes, cook_minutes, total_minutes, time_text dans les termes de la page, time_phases, category et categories pour chaque catégorie sous laquelle la page se range. Un chiffre que la page n'indique pas vaut null. id nomme la page qui a été lue, qui diffère de la clé demandée après une redirection, et redirected_from nomme alors la clé qui y a mené. yield dit pour quoi la recette est écrite et vers quoi elle a été adaptée, et chaque ingrédient porte scaling, valant scaled, rounded ou unscaled.

`scale_ingredients`

Applique la même arithmétique à n'importe quelle liste d'ingrédients, sans requête au wiki.

Argument	Type	Requis	Ce qu'il fait
`ingredients`	tableau de 1 à 100 chaînes, jusqu'à 300 caractères	oui	Les lignes à adapter.
`factor`	nombre, au-delà de 0 jusqu'à 100	l'un des deux	Le multiplicateur à appliquer.
`from_servings`	nombre, au-delà de 0 jusqu'à 500	l'un des deux	Le nombre de parts de la liste d'origine.
`to_servings`	nombre, au-delà de 0 jusqu'à 500	l'un des deux	Le nombre de parts voulu.

Passez factor, ou le couple from_servings et to_servings.

En retour : le factor employé, les ingredients adaptés dans la forme que rend get_recipe, et scaled_count, rounded_count et unscaled_count.

`list_recipes`

Liste des recettes selon les catégories sous lesquelles le Cookbook les range. Les arguments se combinent, et la réponse dit quelle recherche en a été bâtie.

Argument	Type	Requis	Ce qu'il fait
`cuisine`	chaîne, jusqu'à 80 caractères	non	Une cuisine ou un pays, comme `Italian` ou `Thai`.
`dish_type`	chaîne, jusqu'à 80 caractères	non	Un type de plat, comme `soup`, `dessert` ou `bread`.
`main_ingredient`	chaîne, jusqu'à 80 caractères	non	L'ingrédient sur lequel une recette est bâtie.
`limit`	entier, 1 à 50, défaut `15`	non	Lignes à servir.

En retour : les lignes que rend search_recipes, avec query qui nomme la recherche bâtie par ce serveur à partir des arguments, et chaque argument redonné ou null là où il a été omis.

L'adaptation des quantités

Une quantité est exprimée dans l'unité qui lui convient. Après adaptation, une ligne peut donc apparaître dans une autre unité que celle de la recette : 200 g multipliés par vingt donnent 4 kg.

La finesse à laquelle un ingrédient se coupe dépend de sa nature. Un pain se coupe en deux, en trois ou en quatre ; un oeuf ne se partage pas. Une quantité qui tombe entre les deux est donc arrondie, et la recette adaptée s'écarte alors un peu des proportions de l'originale. La ligne porte rounded, et sa note dit ce qui a été fait.

Les chiffres sont l'arithmétique de ce serveur, donc dites qu'ils ont été recalculés quand vous les montrez. Une recette dont la page n'indique aucun nombre de parts ne peut pas être portée à un nombre de convives, et la réponse le dit.

La licence et l'attribution

Les pages du Cookbook sont publiées sous Creative Commons Attribution-Partage dans les mêmes conditions 4.0. Reprendre une recette demande de créditer Wikibooks et la page d'où elle vient, et de partager ce qu'on bâtit dessus sous la même licence. get_recipe rend à la fois license et l'url de la page, donc une réponse emporte le crédit avec elle.

Configuration

Chaque variable est facultative. Elles se posent dans le bloc env de la configuration du client.

Variable	Défaut	Ce qu'elle fait
`WB_USER_AGENT`	l'identité du projet	Nomme votre application auprès de Wikimedia, avec une adresse où joindre une personne.
`WB_MIN_INTERVAL_MS`	`1000`	Écart entre deux requêtes, de 500 à 60000.
`WB_TIMEOUT_MS`	`20000`	Délai d'une requête, de 1000 à 120000.
`WB_MAX_RETRIES`	`3`	Tentatives après un échec passager, de 0 à 8.
`WB_CACHE_TTL_MS`	`900000`	Durée pendant laquelle une page reste en mémoire, de 0 à 86400000.
`WB_CACHE_MAX_ENTRIES`	`200`	Pages gardées en mémoire à la fois, de 1 à 5000.
`WB_MAX_BODY_BYTES`	`8000000`	Plus grande page lue, en octets, de 100000 à 64000000.
`WB_LOG_LEVEL`	`error`	`silent`, `error`, `info` ou `debug`, écrit sur la sortie d'erreur.

Une valeur hors de sa plage retombe sur le défaut, et la raison est écrite sur la sortie d'erreur.

Erreurs

Chaque échec porte un des six codes, un message, et quand cela aide une indication du geste suivant.

Code	Ce qui s'est passé	Que faire
`not_found`	Le wiki a répondu, et n'a pas cette page.	Vérifiez la clé de page avec `search_recipes`.
`invalid_input`	Les arguments ont été refusés avant toute requête.	Lisez le message, qui nomme l'argument.
`rate_limited`	Wikimedia demande à ce client de ralentir.	Attendez les secondes indiquées et rappelez avec les mêmes arguments. La recette est toujours là.
`parse_failure`	La page a chargé et le contenu attendu est absent.	Signalez-le sur le suivi d'incidents.
`network_error`	La requête n'a pas abouti.	Réessayez sous peu.
`timeout`	La requête a dépassé son délai.	Augmentez `WB_TIMEOUT_MS`, ou demandez moins de lignes.

Comme bibliothèque

La couche qui lit le wiki est publiée seule, avec son rythme, son cache et ses erreurs, sans protocole attaché.

import { WikibooksClient } from "mcp-wikibooks-cookbook/client";

const client = new WikibooksClient();
const { data, cached } = await client.getRecipe("Cookbook:Spaghetti_alla_Carbonara");
console.log(data.title, data.ingredients.length, cached);

search et getRecipe répondent chacun { data, cached }, et lèvent une erreur portant un des six codes. Le plancher entre deux requêtes tient également ici.

Rythme et attribution

Les requêtes partent une à une avec au moins une seconde entre elles, et le plancher d'une demi-seconde tient quelle que soit la configuration. Le User-Agent se termine toujours par l'identité du projet et une adresse où joindre une personne.

Les lectures vont vers api.wikimedia.org, l'hôte que Wikimedia documente et maintient pour les développeurs. Chaque résultat porte l'adresse de la page d'où il a été lu, et la licence sous laquelle elle est publiée.

Ce MCP est un projet non officiel, sans affiliation à Wikimedia ni à la communauté Wikibooks.

Confidentialité

Ce serveur ne collecte rien sur vous et n'envoie rien à son auteur. Il tourne sur votre machine, ne joint que api.wikimedia.org, garde ses réponses en mémoire le temps qu'il tourne, et n'écrit rien sur le disque. PRIVACY.md dit ce qu'une requête emporte et quels réglages changent cela.

Développement

npm install
npm run build:fixtures
npm test
npm run check

Les tests s'exécutent sur des fixtures engendrées et n'émettent aucune requête. La suite en direct, npm run test:live, émet une requête par route et tourne chaque nuit contre le service lui-même.

Contribuer

Les anomalies, les questions et les idées ont leur place dans le suivi d'incidents. Les propositions de modification sont bienvenues ; ouvrir un ticket d'abord aide à s'accorder sur la forme du changement. Voir CONTRIBUTING.md.

Licence

MIT pour le code de ce serveur, voir LICENSE. Les pages du Cookbook appartiennent à leurs auteurs et à la communauté Wikibooks, sous CC BY-SA 4.0.

Available Tools

4 tools

get_recipeRead a recipeA

Read-onlyIdempotent

Read one Wikibooks Cookbook page: ingredients, equipment, steps, yield, time, difficulty, category, and the nutrition panel when the page carries one. 'id' is the page key from search_recipes or list_recipes, such as 'Cookbook:Spaghetti_alla_Carbonara'. A plain dish name is accepted and the Cookbook namespace is added. Pass 'servings' to rescale: a countable thing lands on the smallest share a cook can take out of one of it, which is a whole one where half of one cannot be measured out at all, such as an egg or a whole clove, a half where half of one pours, weighs or splits, such as a can or a packet, and a quarter where a knife or the size of the thing goes further, such as an onion, a slice of bread or a jar; a measurement is moved to a smaller unit before rounding so nothing disappears; and anything that cannot be multiplied is flagged instead. Read 'scaling' on each ingredient rather than doing the arithmetic yourself. A page that groups its ingredients by what they are for, such as a cake and its glaze, states that group on every line; a page that lists them flat states null. Two lines can read alike and belong to different parts of the dish. A page offering several versions of the dish states which one each line came from in 'variant'. Those lists replace one another: one of them is used, even where the procedure says to mix all the ingredients. A measurement the page writes as a conversion template is read as the value and the unit the page wrote, and the counterpart the template computes is left out: nothing here is converted between measuring systems. A line asking for as much as is needed and giving an indication in brackets, such as 'water as required (about 1 ½ cups)', states a quantity: the indication is scaled with the recipe and the wording in front of it is left as the page wrote it. A line offering an alternative in brackets, such as '4 eggs (or 8 egg yolks)', has both branches scaled, since a cook takes one of them. The Cookbook keeps recipes and the book's own chapter indexes in one namespace, and both write 'Ingredients' over a bulleted list. A page carrying no recipe box, no recipe banner and no procedure comes back with empty lists and a note: its bullets are links to other pages rather than things to buy. A heading owns what is nested under it and stops at the next heading of its own level, so a page carrying two recipes returns the first of each part and names the rest in a note. A page that only redirects elsewhere is followed to the page it points at, and 'id' and 'redirected_from' say which page was read. Rescaling needs a yield to scale from. A page that states none comes back as published, and says so. A page yielding no quantities is answered with 'factor' 1 and a note: an empty ingredient list was multiplied by nothing. 'author' and 'rating' are always null: the Cookbook is written collectively and carries no reader score. A time the page does not state is null, never zero, and never inferred from the steps. A page stating phases rather than a total, such as a fermentation and a cooking, publishes them in 'time_phases' with 'total_minutes' null: the phases measure different things and are never added. Pages are published under a licence that requires attribution; 'license' and 'url' carry what to credit.

ParametersJSON Schema

Name	Required	Description
`id`	Yes	Page key from a search, such as 'Cookbook:Spaghetti_alla_Carbonara'.
`servings`	No	Rescale the ingredients to this many servings.
`max_description_chars`	No

Output Schema

ParametersJSON Schema

Name	Required	Description
`id`	Yes	The page that was read, which differs from 'id' after a redirect.
`url`	Yes
`tips`	Yes	Notes, tips and variations the page publishes.
`notes`	Yes
`steps`	Yes
`title`	Yes
`yield`	Yes
`author`	Yes	Always null: the Cookbook is written collectively.
`energy`	Yes	Energy per serving as the page states it.
`rating`	Yes	Always null: the Cookbook carries no reader score.
`source`	Yes
`license`	Yes
`category`	Yes
`equipment`	Yes
`nutrition`	Yes
`time_text`	Yes	The time in the page's own wording.
`categories`	Yes	Every category the page files itself under.
`difficulty`	Yes
`revised_at`	Yes
`attribution`	Yes
`description`	Yes
`ingredients`	Yes
`time_phases`	Yes	Each duration the page states, in the order it states them.
`cook_minutes`	Yes	The phase the page labels as cooking. Null when it labels none.
`prep_minutes`	Yes	The phase the page labels as preparation. Null when it labels none.
`total_minutes`	Yes	The whole dish, stated only where the page states a total: one duration, or a phase the page itself calls the total. Null where the page states phases and no total, since a fermentation, a marinade or a rest is not cooking time and adding them would answer with a figure nobody published. Read 'time_phases' instead.
`difficulty_max`	Yes	The scale 'difficulty' sits on.
`redirected_from`	Yes	Redirect pages walked to reach this one. Empty when the page was reached directly.

TDQS

A4.5/5.0

Behavior5/5

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

Annotations already declare readOnlyHint, openWorldHint, idempotentHint, and non-destructive status. The description goes far beyond this by disclosing precise rescaling rules (whole, half, quarter rounding), ingredient grouping and variant behavior, redirect following, null conventions for author/rating/time, license attribution, and edge cases for pages without recipe boxes. This is exemplary behavioral transparency with no contradictions.

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

Conciseness3/5

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

The description is a dense, single-paragraph wall of text with many clauses and edge cases. It is front-loaded with the core action and every sentence adds distinct behavioral detail, but the lack of bullets or sectioning makes it hard to scan. Given the tool's complexity, the length is largely justified, but the structure does not aid quick comprehension.

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?

With an output schema present, the description does not need to restate every return field. It comprehensively covers the tricky semantics: rescaling arithmetic, ingredient grouping, variants, redirects, nulls, time phases, licensing, and pages that are just link lists. The only unmentioned parameter is max_description_chars, but its schema constraints are sufficient for an agent to infer its role. Overall, the tool is fully contextualized.

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?

Schema description coverage is 67%, and the description adds substantial meaning for the two core parameters: id is given an example and namespace behavior, and servings receives an extremely detailed explanation of how scaling rounds quantities. However, max_description_chars is never mentioned in the description, leaving its purpose entirely to the schema field's default and bounds. The two primary parameters are richly enriched, but the third is a gap.

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?

The description opens with a specific verb and resource: 'Read one Wikibooks Cookbook page', and enumerates the exact fields returned (ingredients, equipment, steps, yield, time, difficulty, category, nutrition panel). It clearly distinguishes itself from search/list siblings by framing id as a key obtained from search_recipes or list_recipes, leaving no ambiguity about the tool's purpose.

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?

Clear context is given: id comes from search_recipes or list_recipes, and the tool reads a single recipe. The description also explains when rescaling is triggered via 'servings' and instructs the agent to rely on the returned 'scaling' rather than doing arithmetic. It does not explicitly name exclusions or alternatives like scale_ingredients, but the workflow is evident from the text and sibling names.

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

list_recipesBrowse the CookbookA

Read-onlyIdempotent

Browse the Wikibooks Cookbook by cuisine, by kind of dish, or by main ingredient. Give at least one of the three; giving several narrows the result. This is built on the Cookbook's search, because the route this server is allowed to use publishes no way to list the members of a category. What comes back is therefore a ranked sample and not the category itself: it is neither complete nor ordered, and its length says nothing about how many recipes the Cookbook holds on the subject. The Cookbook also holds reference pages on ingredients and techniques, and those rank alongside recipes. Open a row with get_recipe before describing it as a recipe. Use search_recipes instead when there is a dish name to look up.

ParametersJSON Schema

Name	Required	Description
`limit`	No
`cuisine`	No	A cuisine or a country, such as 'Italian' or 'Thai'.
`dish_type`	No	A kind of dish, such as 'soup', 'dessert' or 'bread'.
`main_ingredient`	No	The ingredient a recipe is built on, such as 'chicken' or 'lentils'.

Output Schema

ParametersJSON Schema

Name	Required	Description
`notes`	Yes
`query`	Yes	The search this server built from the arguments.
`source`	Yes
`cuisine`	Yes
`results`	Yes
`dish_type`	Yes
`result_count`	Yes
`main_ingredient`	Yes
`total_available`	Yes	Always null: no route reports how many recipes a category holds.

TDQS

A4.7/5.0

Behavior5/5

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

Annotations declare readOnlyHint, openWorldHint, and idempotentHint, but the description goes far beyond those hints by explaining the underlying mechanism: it is built on the Cookbook's search because the allowed route cannot list category members. It explicitly warns that results are a ranked sample, not the full category, and that both recipes and reference pages appear. This extra context about incompleteness and ordering is exactly what an agent needs to avoid over-interpreting results.

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 concise yet dense with informationatrosphe: it states the purpose, gives usage guidance, discloses behavior, and names the sibling tool, all in a few sentences. It is front-loaded with the core purpose and scoping, and every sentence serves a clear function without redundancy. This is an efficient use of words.

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 tool has four parameters (all optional), an output schema exists, and the description covers the essential behavioral caveats and routing to sibling tools. Given the complexity of the tool (browsing vs search) and the presence of an output schema, the description is sufficiently complete. The agent has everything it needs to select and invoke the tool correctly: when to use, what to expect, and how to proceed.

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

Parameters3/5

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

The schema already provides descriptions for each parameter (cuisine, dish_type, main_ingredient), and the description reinforces the semantics by explaining that at least one is required and that giving several narrows the result. The description adds the nuance about ranking but doesn't alter the basic meaning of each parameter. With a schema coverage of 75%, the baseline is 3, and the description adds slight value beyond the schema.

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?

The description clearly states the tool's purpose: to browse the Cookbook by cuisine, dish type, or main ingredientchers. It specifies the resource (Wikibooks Cookbook) and the filtering dimensions, and it distinguishes itself from siblings by naming the alternative 'search_recipes' for dish name lookups. This is a specific verb+resource formulation that leaves no ambiguity.

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?

The description gives explicit when-to-use guidance: it says to use this tool for browsing by cuisine/dish/ingredient, and to use 'search_recipes' when there is a dish name to look up. It also advises opening rows with 'get_recipe' before describing something as a recipe, which clarifies the tool's role in a multi-step workflow. This level of situational guidance is exemplary.

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

scale_ingredientsRescale an ingredient listA

Read-onlyIdempotent

Rescale a list of English ingredient lines. This contacts no website and works on a list from anywhere, including one the user pasted in. Give either 'factor' directly, or 'from_servings' and 'to_servings' and the factor is computed. Grams, millilitres, ounces and pounds are multiplied and rounded to what a scale can show; a quantity that would fall below one is moved to a smaller unit first, so it never rounds away to nothing. Countable things land where a kitchen can follow, and what decides is the content rather than the container: a can, a packet, a sheet of gelatine or a spoon lands on a half, because half of one pours, weighs or cuts. An egg, a yolk, a white, a zest or a whole clove lands on a whole one, since there is no half of it to measure out, which is what stops an answer like '2.4 eggs'. A bottle, a jar, a block and a slice go one step further, to the quarter, as a whole food a knife shares out does. An approximate measure is scaled as a count, so a pinch taken from 6 servings to 25 is 4 pinches; the note gives the everyday equivalence, and the quantity stays in the unit the line used. That covers the gestures, such as a pinch, a dash, a glug or a handful, and anything named after what holds it, such as a capful or a spoonful. A line with no quantity at all comes back untouched and flagged. A bracketed equivalent, as in '450 g (1 pound)', is scaled with the amount it restates rather than left to contradict it, and so is one written after a slash, as in '500 g / 1.1 lb'. A line offering a choice, as in '2 tablespoons butter OR 30 g margarine', has both branches scaled, so whichever one the cook takes carries the same share. Prefer this over doing the arithmetic yourself.

ParametersJSON Schema

Name	Required	Description
`factor`	No	Multiplier to apply. Use this or the from/to pair.
`ingredients`	Yes	Ingredient lines, for example ['450 g (1 pound) spaghetti', '5 egg yolks', 'Salt'].
`to_servings`	No	How many servings are wanted.
`from_servings`	No	How many servings the list is written for.

Output Schema

ParametersJSON Schema

Name	Required	Description
`notes`	Yes
`factor`	Yes
`ingredients`	Yes
`scaled_count`	Yes	Lines whose arithmetic came out exact.
`rounded_count`	Yes	Lines whose value was moved to stay usable, not lines that could have been.
`unscaled_count`	Yes	Lines carrying nothing that can be multiplied.

TDQS

A4.8/5.0

Behavior5/5

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

The description goes far beyond the annotations. It discloses rounding behavior (rounded to what a scale can show), unit conversion (moving to smaller units to avoid rounding away), handling of countable items (eggs, yolks, cloves land on whole numbers), approximate measures (pinch, dash, glug scaled as counts), lines with no quantity (returned untouched and flagged), bracketed equivalents, slash-separated equivalents, and OR-choice branches. This is exceptionally transparent about edge-case behavior.

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?

The description is long but every sentence earns its place by explaining a distinct behavioral rule. It front-loads the core purpose and the key invocation modes, then systematically covers edge cases. It is not a tautology or filler; it is dense with useful information. The length is justified by the complexity of the tool's behavior, though it could be slightly tightened without losing meaning.

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?

Given the tool's complexity and the presence of an output schema, the description is remarkably complete. It covers input modes, rounding rules, unit handling, special cases (no quantity, equivalents, choices), and even tells the agent when to prefer this tool over manual arithmetic. The output schema exists, so return values need not be described. Nothing an agent needs to call this tool correctly is missing.

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?

Schema description coverage is 100%, so the baseline is 3. The description adds meaningful semantics beyond the schema: it explains the relationship between 'factor' and the 'from_servings'/'to_servings' pair, and clarifies that the factor is computed when the pair is given. It also explains how the ingredients parameter is interpreted (English lines, any source). It doesn't add syntax details for each parameter, but the schema already covers those, and the description adds the decision logic for choosing between the two modes.

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?

The description opens with a specific verb and resource: 'Rescale a list of English ingredient lines.' It immediately distinguishes itself from sibling tools (get_recipe, search_recipes, list_recipes) by stating it works on a list from anywhere, including user-pasted text, and explicitly says 'Prefer this over doing the arithmetic yourself.' The purpose is unmistakable.

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?

The description explicitly states when to use this tool: rescale an ingredient list, and contrasts it with alternatives by noting it contacts no website and works on a list from anywhere. It also gives clear guidance on how to invoke it: provide either 'factor' directly or 'from_servings' and 'to_servings'. The final sentence 'Prefer this over doing the arithmetic yourself' is a direct usage directive.

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

search_recipesSearch the CookbookA

Read-onlyIdempotent

Search the Wikibooks Cookbook for a recipe, by dish name or by an ingredient it uses. 'text' searches the whole of each page, which is what finds a dish from an ingredient inside it; 'title' matches the page name only, which is exact and misses a dish the Cookbook names differently. The Cookbook also holds reference pages on ingredients, techniques and cuisines, and those rank alongside recipes: a row is a page, and only get_recipe can say whether it carries an ingredient list. A full-text row can be a page that merely names the dish: when the titles do not say the words searched for, the notes say so, because the Cookbook links to dishes it does not hold. On a title search the same rows are pages the Cookbook files under another name, such as 'Eggplant' for 'aubergine', since that search opens no page. 'total_available' is null because the search route reports no total and offers no second page. Narrow the query rather than asking for more. Every row carries an 'id', which get_recipe takes.

ParametersJSON Schema

Name	Required	Description	Default
`limit`	No
`query`	Yes	A dish, such as 'carbonara', or an ingredient, such as 'guanciale'.
`search`	No	'text' reads the whole page; 'title' matches the page name only.	text

Output Schema

ParametersJSON Schema

Name	Required	Description
`notes`	Yes
`query`	Yes
`source`	Yes
`results`	Yes
`result_count`	Yes	Rows returned by this call.
`total_available`	Yes	Always null: the search route publishes no total and no paging.

TDQS

A4.8/5.0

Behavior5/5

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

Annotations already declare readOnlyHint, openWorldHint, idempotentHint, and non-destructive behavior. The description adds substantial beyond-annotation context: text search scans full pages, title search matches names only, reference pages compete with recipes, full-text rows may merely name a dish, title results can be aliases like 'Eggplant' for 'aubergine,' total_available is null, and there is no pagination. These are valuable operational traits that the schema and annotations do not convey.

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?

The description is lengthy but earns most of its length by explaining nontrivial search quirks (aliases, non-recipe pages, null total). It is logically structured: search modes, result semantics, caveats, then pagination guidance. Some phrases, such as 'since that search opens no page,' are slightly opaque and could be tightened, but overall the density is justified.

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?

Given the presence of an output schema IA and rich annotations, the description covers the remaining operational concerns: result ranking, full-text versus title semantics, absence of total and pagination, and the link to get_recipe via 'id'. An agent has everything needed to decide when to call this toolhive, set parameters correctly, and interpret the returned pages without further spelunking.

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?

Schema coverage is 67%, with descriptions for 'query' and 'search'; the description enriches both by explaining the real-world consequences of text versus title search and by framing 'query' as a dish or ingredient. The 'limit' parameter is not explicitly described in the schema, but the phrase 'offers no second page' implies limit is the only way to control result volume Chebyshev. This is helpful, though not fully explicit about limit being a maximum count.

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?

The description opens with a specific verb and resource: 'Search the Wikibooks Cookbook for a recipe,' and immediately enumerates the two search dimensions, dish name and ingredient. It distinguishes itself from siblings by noting that 'only get_recipe can say whether it carries an ingredient list,' and it clarifies that reference pages rank alongside recipes. The purpose is unambiguous, specific, and clearly differentiated.

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?

The description explicitly contrasts 'text' versus 'title' search and tells which to use: 'text' finds a dish from an ingredient inside it; 'title' is exact and misses differently named dishes. It also gives direct advice for behavior: 'Narrow the query rather than asking for more' and states 'Every row carries an id, which get_recipe takes,' routing the agent to the right next step. This is explicit when-to-use guidance with no gaps.

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 updatesv2.1.0Sep 11, 2026

Changedget_recipe47 fields changed

removedOutput schema / properties / author / anyOf

Removed value: -[
-  {
-    "type": "string"
-  },
-  {
-    "type": "null"
-  }
-]

addedOutput schema / properties / author / type
```
Added value: +[
+  "string",
+  "null"
+]
```

removedOutput schema / properties / category / anyOf

Removed value: -[
-  {
-    "type": "string"
-  },
-  {
-    "type": "null"
-  }
-]

addedOutput schema / properties / category / type
```
Added value: +[
+  "string",
+  "null"
+]
```

removedOutput schema / properties / cook_minutes / anyOf

Removed value: -[
-  {
-    "type": "number"
-  },
-  {
-    "type": "null"
-  }
-]

addedOutput schema / properties / cook_minutes / type
```
Added value: +[
+  "number",
+  "null"
+]
```

removedOutput schema / properties / description / anyOf

Removed value: -[
-  {
-    "type": "string"
-  },
-  {
-    "type": "null"
-  }
-]

addedOutput schema / properties / description / type
```
Added value: +[
+  "string",
+  "null"
+]
```

removedOutput schema / properties / difficulty / anyOf

Removed value: -[
-  {
-    "type": "number"
-  },
-  {
-    "type": "null"
-  }
-]

addedOutput schema / properties / difficulty / type
```
Added value: +[
+  "number",
+  "null"
+]
```

removedOutput schema / properties / energy / anyOf

Removed value: -[
-  {
-    "type": "string"
-  },
-  {
-    "type": "null"
-  }
-]

addedOutput schema / properties / energy / type
```
Added value: +[
+  "string",
+  "null"
+]
```

removedOutput schema / properties / ingredients / items / properties / amount / anyOf

Removed value: -[
-  {
-    "type": "number"
-  },
-  {
-    "type": "null"
-  }
-]

addedOutput schema / properties / ingredients / items / properties / amount / type
```
Added value: +[
+  "number",
+  "null"
+]
```
removedOutput schema / properties / ingredients / items / properties / amount_max / anyOf
```
Removed value: -[
-  {
-    "type": "number"
-  },
-  {
-    "type": "null"
-  }
-]
```
addedOutput schema / properties / ingredients / items / properties / amount_max / type
```
Added value: +[
+  "number",
+  "null"
+]
```

removedOutput schema / properties / ingredients / items / properties / group / anyOf

Removed value: -[
-  {
-    "type": "string"
-  },
-  {
-    "type": "null"
-  }
-]

addedOutput schema / properties / ingredients / items / properties / group / type
```
Added value: +[
+  "string",
+  "null"
+]
```

removedOutput schema / properties / ingredients / items / properties / unit / anyOf

Removed value: -[
-  {
-    "type": "string"
-  },
-  {
-    "type": "null"
-  }
-]

addedOutput schema / properties / ingredients / items / properties / unit / type
```
Added value: +[
+  "string",
+  "null"
+]
```

removedOutput schema / properties / ingredients / items / properties / variant / anyOf

Removed value: -[
-  {
-    "type": "string"
-  },
-  {
-    "type": "null"
-  }
-]

addedOutput schema / properties / ingredients / items / properties / variant / type
```
Added value: +[
+  "string",
+  "null"
+]
```

changedOutput schema / properties / nutrition / anyOf

Previous value: -[
-  {
-    "additionalProperties": false,
-    "properties": {
-      "calcium": {
-        "anyOf": [
-          {
-            "type": "string"
-          },
-          {
-            "type": "null"
-          }
-        ]
-      },
-      "calories": {
-        "anyOf": [
-          {
-            "type": "string"
-          },
-          {
-            "type": "null"
-          }
-        ]
-      },
-      "calories_from_fat": {
-        "anyOf": [
-          {
-            "type": "string"
-          },
-          {
-            "type": "null"
-          }
-        ]
-      },
-      "carbohydrates": {
-        "anyOf": [
-          {
-            "type": "string"
-          },
-          {
-            "type": "null"
-          }
-        ]
-      },
-      "cholesterol": {
-        "anyOf": [
-          {
-            "type": "string"
-          },
-          {
-            "type": "null"
-          }
-        ]
-      },
-      "fiber": {
-        "anyOf": [
-          {
-            "type": "string"
-          },
-          {
-            "type": "null"
-          }
-        ]
-      },
-      "iron": {
-        "anyOf": [
-          {
-            "type": "string"
-          },
-          {
-            "type": "null"
-          }
-        ]
-      },
-      "protein": {
-        "anyOf": [
-          {
-            "type": "string"
-          },
-          {
-            "type": "null"
-          }
-        ]
-      },
-      "saturated_fat": {
-        "anyOf": [
-          {
-            "type": "string"
-          },
-          {
-            "type": "null"
-          }
-        ]
-      },
-      "serving_size": {
-        "anyOf": [
-          {
-            "type": "string"
-          },
-          {
-            "type": "null"
-          }
-        ]
-      },
-      "servings": {
-        "anyOf": [
-          {
-            "type": "string"
-          },
-          {
-            "type": "null"
-          }
-        ]
-      },
-      "sodium": {
-        "anyOf": [
-          {
-            "type": "string"
-          },
-          {
-            "type": "null"
-          }
-        ]
-      },
-      "sugars": {
-        "anyOf": [
-          {
-            "type": "string"
-          },
-          {
-            "type": "null"
-          }
-        ]
-      },
-      "total_fat": {
-        "anyOf": [
-          {
-            "type": "string"
-          },
-          {
-            "type": "null"
-          }
-        ]
-      },
-      "vitamin_a": {
-        "anyOf": [
-          {
-            "type": "string"
-          },
-          {
-            "type": "null"
-          }
-        ]
-      },
-      "vitamin_c": {
-        "anyOf": [
-          {
-            "type": "string"
-          },
-          {
-            "type": "null"
-          }
-        ]
-      }
-    },
-    "required": [
-      "serving_size",
-      "servings",
-      "calories",
-      "calories_from_fat",
-      "total_fat",
-      "saturated_fat",
-      "cholesterol",
-      "sodium",
-      "carbohydrates",
-      "fiber",
-      "sugars",
-      "protein",
-      "vitamin_a",
-      "vitamin_c",
-      "calcium",
-      "iron"
-    ],
-    "type": "object"
-  },
-  {
-    "type": "null"
-  }
-]New value: +[
+  {
+    "additionalProperties": false,
+    "properties": {
+      "calcium": {
+        "type": [
+          "string",
+          "null"
+        ]
+      },
+      "calories": {
+        "type": [
+          "string",
+          "null"
+        ]
+      },
+      "calories_from_fat": {
+        "type": [
+          "string",
+          "null"
+        ]
+      },
+      "carbohydrates": {
+        "type": [
+          "string",
+          "null"
+        ]
+      },
+      "cholesterol": {
+        "type": [
+          "string",
+          "null"
+        ]
+      },
+      "fiber": {
+        "type": [
+          "string",
+          "null"
+        ]
+      },
+      "iron": {
+        "type": [
+          "string",
+          "null"
+        ]
+      },
+      "protein": {
+        "type": [
+          "string",
+          "null"
+        ]
+      },
+      "saturated_fat": {
+        "type": [
+          "string",
+          "null"
+        ]
+      },
+      "serving_size": {
+        "type": [
+          "string",
+          "null"
+        ]
+      },
+      "servings": {
+        "type": [
+          "string",
+          "null"
+        ]
+      },
+      "sodium": {
+        "type": [
+          "string",
+          "null"
+        ]
+      },
+      "sugars": {
+        "type": [
+          "string",
+          "null"
+        ]
+      },
+      "total_fat": {
+        "type": [
+          "string",
+          "null"
+        ]
+      },
+      "vitamin_a": {
+        "type": [
+          "string",
+          "null"
+        ]
+      },
+      "vitamin_c": {
+        "type": [
+          "string",
+          "null"
+        ]
+      }
+    },
+    "required": [
+      "serving_size",
+      "servings",
+      "calories",
+      "calories_from_fat",
+      "total_fat",
+      "saturated_fat",
+      "cholesterol",
+      "sodium",
+      "carbohydrates",
+      "fiber",
+      "sugars",
+      "protein",
+      "vitamin_a",
+      "vitamin_c",
+      "calcium",
+      "iron"
+    ],
+    "type": "object"
+  },
+  {
+    "type": "null"
+  }
+]

removedOutput schema / properties / prep_minutes / anyOf

Removed value: -[
-  {
-    "type": "number"
-  },
-  {
-    "type": "null"
-  }
-]

addedOutput schema / properties / prep_minutes / type
```
Added value: +[
+  "number",
+  "null"
+]
```

removedOutput schema / properties / rating / anyOf

Removed value: -[
-  {
-    "type": "number"
-  },
-  {
-    "type": "null"
-  }
-]

addedOutput schema / properties / rating / type
```
Added value: +[
+  "number",
+  "null"
+]
```

removedOutput schema / properties / revised_at / anyOf

Removed value: -[
-  {
-    "type": "string"
-  },
-  {
-    "type": "null"
-  }
-]

addedOutput schema / properties / revised_at / type
```
Added value: +[
+  "string",
+  "null"
+]
```

removedOutput schema / properties / time_phases / items / properties / label / anyOf

Removed value: -[
-  {
-    "type": "string"
-  },
-  {
-    "type": "null"
-  }
-]

addedOutput schema / properties / time_phases / items / properties / label / type
```
Added value: +[
+  "string",
+  "null"
+]
```

removedOutput schema / properties / time_phases / items / properties / minutes / anyOf

Removed value: -[
-  {
-    "type": "number"
-  },
-  {
-    "type": "null"
-  }
-]

addedOutput schema / properties / time_phases / items / properties / minutes / type
```
Added value: +[
+  "number",
+  "null"
+]
```
removedOutput schema / properties / time_phases / items / properties / minutes_max / anyOf
```
Removed value: -[
-  {
-    "type": "number"
-  },
-  {
-    "type": "null"
-  }
-]
```
addedOutput schema / properties / time_phases / items / properties / minutes_max / type
```
Added value: +[
+  "number",
+  "null"
+]
```

removedOutput schema / properties / time_text / anyOf

Removed value: -[
-  {
-    "type": "string"
-  },
-  {
-    "type": "null"
-  }
-]

addedOutput schema / properties / time_text / type
```
Added value: +[
+  "string",
+  "null"
+]
```

removedOutput schema / properties / total_minutes / anyOf

Removed value: -[
-  {
-    "type": "number"
-  },
-  {
-    "type": "null"
-  }
-]

addedOutput schema / properties / total_minutes / type
```
Added value: +[
+  "number",
+  "null"
+]
```

removedOutput schema / properties / yield / properties / original_count / anyOf

Removed value: -[
-  {
-    "type": "number"
-  },
-  {
-    "type": "null"
-  }
-]

addedOutput schema / properties / yield / properties / original_count / type
```
Added value: +[
+  "number",
+  "null"
+]
```

removedOutput schema / properties / yield / properties / original_text / anyOf

Removed value: -[
-  {
-    "type": "string"
-  },
-  {
-    "type": "null"
-  }
-]

addedOutput schema / properties / yield / properties / original_text / type
```
Added value: +[
+  "string",
+  "null"
+]
```

removedOutput schema / properties / yield / properties / requested / anyOf

Removed value: -[
-  {
-    "type": "number"
-  },
-  {
-    "type": "null"
-  }
-]

addedOutput schema / properties / yield / properties / requested / type
```
Added value: +[
+  "number",
+  "null"
+]
```

removedOutput schema / properties / yield / properties / unit / anyOf

Removed value: -[
-  {
-    "type": "string"
-  },
-  {
-    "type": "null"
-  }
-]

addedOutput schema / properties / yield / properties / unit / type
```
Added value: +[
+  "string",
+  "null"
+]
```

Changedlist_recipes12 fields changed
- removedOutput schema / properties / cuisine / anyOf
```
Removed value: -[
-  {
-    "type": "string"
-  },
-  {
-    "type": "null"
-  }
-]
```
- addedOutput schema / properties / cuisine / type
```
Added value: +[
+  "string",
+  "null"
+]
```
- removedOutput schema / properties / dish_type / anyOf
```
Removed value: -[
-  {
-    "type": "string"
-  },
-  {
-    "type": "null"
-  }
-]
```
- addedOutput schema / properties / dish_type / type
```
Added value: +[
+  "string",
+  "null"
+]
```
- removedOutput schema / properties / main_ingredient / anyOf
```
Removed value: -[
-  {
-    "type": "string"
-  },
-  {
-    "type": "null"
-  }
-]
```
- addedOutput schema / properties / main_ingredient / type
```
Added value: +[
+  "string",
+  "null"
+]
```
- removedOutput schema / properties / results / items / properties / description / anyOf
```
Removed value: -[
-  {
-    "type": "string"
-  },
-  {
-    "type": "null"
-  }
-]
```
- addedOutput schema / properties / results / items / properties / description / type
```
Added value: +[
+  "string",
+  "null"
+]
```
- removedOutput schema / properties / results / items / properties / excerpt / anyOf
```
Removed value: -[
-  {
-    "type": "string"
-  },
-  {
-    "type": "null"
-  }
-]
```
- addedOutput schema / properties / results / items / properties / excerpt / type
```
Added value: +[
+  "string",
+  "null"
+]
```
- removedOutput schema / properties / results / items / properties / image_url / anyOf
```
Removed value: -[
-  {
-    "type": "string"
-  },
-  {
-    "type": "null"
-  }
-]
```
- addedOutput schema / properties / results / items / properties / image_url / type
```
Added value: +[
+  "string",
+  "null"
+]
```
Changedscale_ingredients6 fields changed
- removedOutput schema / properties / ingredients / items / properties / amount / anyOf
```
Removed value: -[
-  {
-    "type": "number"
-  },
-  {
-    "type": "null"
-  }
-]
```
- addedOutput schema / properties / ingredients / items / properties / amount / type
```
Added value: +[
+  "number",
+  "null"
+]
```
- removedOutput schema / properties / ingredients / items / properties / amount_max / anyOf
```
Removed value: -[
-  {
-    "type": "number"
-  },
-  {
-    "type": "null"
-  }
-]
```
- addedOutput schema / properties / ingredients / items / properties / amount_max / type
```
Added value: +[
+  "number",
+  "null"
+]
```
- removedOutput schema / properties / ingredients / items / properties / unit / anyOf
```
Removed value: -[
-  {
-    "type": "string"
-  },
-  {
-    "type": "null"
-  }
-]
```
- addedOutput schema / properties / ingredients / items / properties / unit / type
```
Added value: +[
+  "string",
+  "null"
+]
```
Changedsearch_recipes6 fields changed
- removedOutput schema / properties / results / items / properties / description / anyOf
```
Removed value: -[
-  {
-    "type": "string"
-  },
-  {
-    "type": "null"
-  }
-]
```
- addedOutput schema / properties / results / items / properties / description / type
```
Added value: +[
+  "string",
+  "null"
+]
```
- removedOutput schema / properties / results / items / properties / excerpt / anyOf
```
Removed value: -[
-  {
-    "type": "string"
-  },
-  {
-    "type": "null"
-  }
-]
```
- addedOutput schema / properties / results / items / properties / excerpt / type
```
Added value: +[
+  "string",
+  "null"
+]
```
- removedOutput schema / properties / results / items / properties / image_url / anyOf
```
Removed value: -[
-  {
-    "type": "string"
-  },
-  {
-    "type": "null"
-  }
-]
```
- addedOutput schema / properties / results / items / properties / image_url / type
```
Added value: +[
+  "string",
+  "null"
+]
```

2 tool updatesv1.3.0Aug 10, 2026

Changedget_recipe11 fields changed

addedOutput schema / properties / cook_minutes / description

Added value: +"The phase the page labels as cooking. Null when it labels none."

addedOutput schema / properties / id / description

Added value: +"The page that was read, which differs from 'id' after a redirect."

addedOutput schema / properties / ingredients / items / properties / group

Added value: +{
+  "anyOf": [
+    {
+      "type": "string"
+    },
+    {
+      "type": "null"
+    }
+  ],
+  "description": "The part of the dish this line is for, such as 'Glaze'. Null when the page names none. Every part is made, so a caller buys all of them."
+}

changedOutput schema / properties / ingredients / items / properties / scaling / description

Previous value: -"'scaled' means the arithmetic was exact. 'rounded' means a countable item was moved to a whole or half unit, or a measurement was demoted to a smaller unit to stay usable. 'unscaled' means the line carries nothing that can be multiplied and was left alone."New value: +"'scaled' means the arithmetic was exact. 'rounded' means a countable item was moved to a whole, a half or a quarter, whichever is the smallest share a cook takes out of one of it, or a measurement was demoted to a smaller unit to stay usable. 'unscaled' means the line carries nothing that can be multiplied and was left alone."

addedOutput schema / properties / ingredients / items / properties / variant

Added value: +{
+  "anyOf": [
+    {
+      "type": "string"
+    },
+    {
+      "type": "null"
+    }
+  ],
+  "description": "The alternative list this line belongs to, such as 'Variation II'. Null when the line belongs to the recipe itself. Lines carrying different variants replace one another: exactly one of them is used, whatever the procedure says about mixing everything."
+}

changedOutput schema / properties / ingredients / items / required

Previous value: -[
-  "text",
-  "original",
-  "scaling",
-  "amount",
-  "amount_max",
-  "unit"
-]New value: +[
+  "text",
+  "original",
+  "scaling",
+  "amount",
+  "amount_max",
+  "unit",
+  "group",
+  "variant"
+]

addedOutput schema / properties / prep_minutes / description

Added value: +"The phase the page labels as preparation. Null when it labels none."

addedOutput schema / properties / redirected_from

Added value: +{
+  "description": "Redirect pages walked to reach this one. Empty when the page was reached directly.",
+  "items": {
+    "type": "string"
+  },
+  "type": "array"
+}

addedOutput schema / properties / time_phases

Added value: +{
+  "description": "Each duration the page states, in the order it states them.",
+  "items": {
+    "additionalProperties": false,
+    "properties": {
+      "label": {
+        "anyOf": [
+          {
+            "type": "string"
+          },
+          {
+            "type": "null"
+          }
+        ],
+        "description": "The phase as the page names it, such as 'Fermentation'. Null when it names none."
+      },
+      "minutes": {
+        "anyOf": [
+          {
+            "type": "number"
+          },
+          {
+            "type": "null"
+          }
+        ],
+        "description": "The duration in minutes, or the lower bound of a range."
+      },
+      "minutes_max": {
+        "anyOf": [
+          {
+            "type": "number"
+          },
+          {
+            "type": "null"
+          }
+        ],
+        "description": "The upper bound where the page gives a range, null where it gives one figure."
+      },
+      "text": {
+        "description": "The duration in the page's own wording.",
+        "type": "string"
+      }
+    },
+    "required": [
+      "label",
+      "text",
+      "minutes",
+      "minutes_max"
+    ],
+    "type": "object"
+  },
+  "type": "array"
+}

addedOutput schema / properties / total_minutes / description

Added value: +"The whole dish, stated only where the page states a total: one duration, or a phase the page itself calls the total. Null where the page states phases and no total, since a fermentation, a marinade or a rest is not cooking time and adding them would answer with a figure nobody published. Read 'time_phases' instead."

changedOutput schema / required

Previous value: -[
-  "id",
-  "title",
-  "url",
-  "yield",
-  "ingredients",
-  "equipment",
-  "steps",
-  "tips",
-  "prep_minutes",
-  "cook_minutes",
-  "total_minutes",
-  "time_text",
-  "category",
-  "categories",
-  "difficulty",
-  "difficulty_max",
-  "energy",
-  "author",
-  "rating",
-  "nutrition",
-  "description",
-  "attribution",
-  "license",
-  "revised_at",
-  "source",
-  "notes"
-]New value: +[
+  "id",
+  "title",
+  "url",
+  "redirected_from",
+  "yield",
+  "ingredients",
+  "equipment",
+  "steps",
+  "tips",
+  "prep_minutes",
+  "cook_minutes",
+  "total_minutes",
+  "time_text",
+  "time_phases",
+  "category",
+  "categories",
+  "difficulty",
+  "difficulty_max",
+  "energy",
+  "author",
+  "rating",
+  "nutrition",
+  "description",
+  "attribution",
+  "license",
+  "revised_at",
+  "source",
+  "notes"
+]

Changedscale_ingredients1 field changed

changedOutput schema / properties / ingredients / items / properties / scaling / description

Previous value: -"'scaled' means the arithmetic was exact. 'rounded' means a countable item was moved to a whole or half unit, or a measurement was demoted to a smaller unit to stay usable. 'unscaled' means the line carries nothing that can be multiplied and was left alone."New value: +"'scaled' means the arithmetic was exact. 'rounded' means a countable item was moved to a whole, a half or a quarter, whichever is the smallest share a cook takes out of one of it, or a measurement was demoted to a smaller unit to stay usable. 'unscaled' means the line carries nothing that can be multiplied and was left alone."

4 tool updatesv1.2.0Aug 7, 2026
- Changedget_recipe1 field changed
  - addedInput schema / additionalProperties
```
Added value: +false
```
- Changedlist_recipes1 field changed
  - addedInput schema / additionalProperties
```
Added value: +false
```
- Changedscale_ingredients1 field changed
  - addedInput schema / additionalProperties
```
Added value: +false
```
- Changedsearch_recipes1 field changed
  - addedInput schema / additionalProperties
```
Added value: +false
```
4 tool updatesv1.0.0Aug 5, 2026
- First observedget_recipe
- First observedlist_recipes
- First observedscale_ingredients
- First observedsearch_recipes

Deploy Server

One endpoint for every MCP toolRayrun runs every MCP server behind one URL and holds the credentials. Each call is decided per client, tool, and argument, then recorded.ray.runAd

TDQS

A4.7/5.0

Scored 2026-09-11 00:10 across 4 tools

Disambiguation5/5

Each tool has a distinct job: retrieving a specific recipe, searching by query, browsing by category, and scaling ingredient lines. There is no overlap in purpose, and the descriptions explicitly cross-reference when to use which.

Naming Consistency5/5

All four tools follow the same verb_noun pattern with underscores (get_recipe, search_recipes, scale_ingredients, list_recipes). The singular/plural variation is logical and predictable.

Tool Count5/5

Four tools is a well-scoped size for a read-only cookbook server: discovery (search, list), retrieval (get), and a utility (scale). Each tool earns its place.

Completeness5/5

The server covers the full read-only lifecycle: discovery via search and list, retrieval via get, and a value-added scaling utility. There are no dead ends—search and list both return IDs that get_recipe accepts, and scale_ingredients works independently.

Maintenance

ActivityActive

ResponsivenessUnresponsive

Resources

Need Help?

Related Servers

Related MCP Connectors

SpoonjoyOAuth
app.spoonjoy
Your personal recipe kitchen: save, fork, and cook recipes, build cookbooks, and shopping lists.
Note Taking
2
prep-itOAuth
com.recipe-clipper
Search, save, organize, cook, and share recipes with any AI assistant.
Note Taking Search
2
BakingTab — Baking Conversions for AI A
io.github.zhaoyaqi18
Baking unit conversion (cups/grams/temp/recipe scaling). convert_amount, convert_temperature
Data Platforms
51
HaliteOAuth
cc.halite
Search, read, and edit your Halite recipe collection and shopping lists.
Note Taking
1

Related MCP Servers

mcp-cookbook
Search Entertainment & Media
springdo
F
license
Not graded
quality
D
maintenance
Enables browsing recipes, searching by category, and viewing detailed recipe information from the Gousto cookbook API via natural language.
Updated 5 months ago (2026-04-09 10:27 UTC)
-
yes_chef_mcp
Health & Wellness Search
ltmorro
F
license
Not graded
quality
D
maintenance
Enables AI assistants to search recipes, compose nutritionally balanced meals, optimize weekly meal plans based on macro targets for family members, and generate consolidated grocery lists from a personal recipe database.
Updated 5 months ago (2026-04-05 23:31 UTC)
-
NYT Cooking MCP
Entertainment & Media Search Web Scraping
bramboe
A
license
A
quality
D
maintenance
Enables AI assistants to search New York Times Cooking recipes, fetch full recipes with ingredients and steps without login, and browse personal saved recipe box with optional authentication.
Updated 2 months ago (2026-07-05 17:05 UTC)
6
1
MIT
mcp-marmiton
Health & Wellness Search
smeet666
A
license
A
quality
B
maintenance
MCP server that searches French recipes from Marmiton, reads ingredients and steps, and rescales quantities to any number of servings without requiring an API key.
Updated 2 days ago (2026-09-14 06:00 UTC)
6
3
348 npm
MIT