mcp-wikibooks-cookbook

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

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.0.1"]
    }
  }
}

`-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.0.1.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.

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

`search_recipes`

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

titles alone.

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.

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.

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.

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.

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.

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

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.0.1"]
    }
  }
}

`-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.0.1.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

`search_recipes`

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

seuls titres.

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é.

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.

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.

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.

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.

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.