mcp-wikibooks-cookbook

# mcp-wikibooks-cookbook

[![npm](https://img.shields.io/npm/v/mcp-wikibooks-cookbook.svg)](https://www.npmjs.com/package/mcp-wikibooks-cookbook)
[![CI](https://github.com/smeet666/mcp-wikibooks-cookbook/actions/workflows/ci.yml/badge.svg)](https://github.com/smeet666/mcp-wikibooks-cookbook/actions/workflows/ci.yml)
[![license](https://img.shields.io/npm/l/mcp-wikibooks-cookbook.svg)](LICENSE)
[![Glama](https://glama.ai/mcp/servers/smeet666/mcp-wikibooks-cookbook/badges/score.svg)](https://glama.ai/mcp/servers/smeet666/mcp-wikibooks-cookbook)

An MCP server for the [Cookbook](https://en.wikibooks.org/wiki/Cookbook:Table_of_Contents) on
the English Wikibooks: thousands of recipes written and maintained in the open, with their
ingredients, their equipment and their steps. **Search them, read one, and rescale it to the
number of people you are actually cooking for.** No API key, no account, read-only.

_(Version française plus bas / French version below)_

## Quickstart

**One-click install**

[![Install in Cursor](https://cursor.com/deeplink/mcp-install-dark.svg)](https://cursor.com/en/install-mcp?name=wikibooks-cookbook&config=eyJjb21tYW5kIjoibnB4IiwiYXJncyI6WyIteSIsIm1jcC13aWtpYm9va3MtY29va2Jvb2siXX0%3D)
[![Install in VS Code](https://img.shields.io/badge/VS_Code-Install-0098FF?style=flat&logo=visualstudiocode&logoColor=white)](https://insiders.vscode.dev/redirect/mcp/install?name=wikibooks-cookbook&config=%7B%22name%22%3A%22wikibooks-cookbook%22%2C%22command%22%3A%22npx%22%2C%22args%22%3A%5B%22-y%22%2C%22mcp-wikibooks-cookbook%22%5D%7D)

**Claude Code**

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

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

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

Node 20 or later.

**Bundle, without npm**

Download `mcp-wikibooks-cookbook-<version>.mcpb` from
[the latest release](https://github.com/smeet666/mcp-wikibooks-cookbook/releases/latest) and
open it. A client that supports MCP bundles installs it on its own, with no npm and no
configuration file to edit.

## Tools

| Tool                | What it does                                               | Key parameters                                     |
| ------------------- | ---------------------------------------------------------- | -------------------------------------------------- |
| `search_recipes`    | Finds a page by dish name or by an ingredient it uses.     | `query`, `search`, `limit`                         |
| `get_recipe`        | Reads one page, optionally rescaled.                       | `id`, `servings`, `max_description_chars`          |
| `scale_ingredients` | Rescales any English ingredient list, without the network. | `ingredients`, `factor`, `from_servings`           |
| `list_recipes`      | Browses by cuisine, kind of dish or main ingredient.       | `cuisine`, `dish_type`, `main_ingredient`, `limit` |

The server is **read-only**. It edits nothing on the wiki and uploads nothing.

## The arithmetic is the point

Ask for a six-serving recipe scaled to four and a naive multiplication gives you 3.33 egg yolks
and 0.67 of a pinch of pepper. Neither is something a kitchen can produce, and a model that
repeats them is confidently wrong about a dish somebody is about to cook.

Six rules do the work.

**A countable thing lands where a cook can divide it.** Half an egg cannot be measured out, so a
count of eggs, yolks or whites lands on a whole number. Half a clove of garlic can be cut, so a
clove lands on a half. The rounded line says which way it moved.

**A sealed packet is never cut.** A can, a jar, a packet, a sheet of gelatine: opening one is
all or nothing, so those land on a whole one whatever the factor says.

**A measurement moves to a smaller unit before it is rounded.** A quantity that would fall below
one is demoted first, so 1 tablespoon quartered reads as 1 teaspoon rather than rounding away to
nothing. A large result climbs the other way, so 200 g scaled tenfold reads as 2 kg. Read
`amount` together with `unit` and never on its own: the bare number can shrink while the
quantity grows.

**An approximate measure is multiplied as a count, never converted.** A pinch, a dash, a glug, a
dollop, a capful, a spoonful: the size of one of them belongs to whoever pours it, and the count
is what carries the recipe's proportion. A pinch taken from six servings to twenty-five is four
pinches. The everyday equivalence goes in the note, never in the quantity. English says as much
in the word itself: the -ful suffix means "as much as one of these holds", so a container that
has never come up is understood the first time it appears, and the gestures whose names give
nothing away are named one by one in the vocabulary.

**A line publishing two quantities has both of them scaled.** `450 g (1 pound) spaghetti` comes
back with the metric figure and the imperial figure in step, so they cannot contradict each
other, and so does 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.

**What cannot be multiplied is flagged rather than multiplied.** "Salt to taste" comes back as
published, marked `unscaled`, and counted in the summary.

### What a scaled ingredient looks like

Every line comes back in one shape:

```json
{
  "text": "300 g (11 ounces) flat noodles",
  "original": "450 g (1 pound) flat noodles",
  "scaling": "rounded",
  "amount": 300,
  "amount_max": null,
  "unit": "g",
  "note": "The amount is exact; the equivalent in brackets was rounded to stay readable."
}
```

`scaling` carries the honesty of the tool:

- `scaled` — the arithmetic was exact.
- `rounded` — a countable thing was moved to a whole or a half, or a measurement was demoted to
  a smaller unit to stay usable.
- `unscaled` — the line carries nothing that can be multiplied, so it was left as published and
  flagged.

## Reading a page

### `search_recipes`

Find a page by dish name or by an ingredient it uses.

| Argument | Type              | Default | Meaning                                                            |
| -------- | ----------------- | ------- | ------------------------------------------------------------------ |
| `query`  | string            | —       | A dish, such as `carbonara`, or an ingredient, such as `guanciale` |
| `search` | `text` \| `title` | `text`  | `text` reads the whole page; `title` matches the page name only    |
| `limit`  | integer 1–50      | 10      | Rows to return                                                     |

Returns `{ query, results, result_count, total_available, source, notes }`. Each row carries
`id`, `title`, `url`, `image_url`, `description` and `excerpt`.

`total_available` is always `null`. The gateway publishes no total and offers no second page, so
any number here would be invented, and a short list is not evidence that little exists. Narrow
the query instead.

### `get_recipe`

Read one page, optionally rescaled.

| Argument                | Type          | Default | Meaning                                                             |
| ----------------------- | ------------- | ------- | ------------------------------------------------------------------- |
| `id`                    | string        | —       | Page key from a search, such as `Cookbook:Spaghetti_alla_Carbonara` |
| `servings`              | integer 1–500 | —       | Rescale the ingredients to this many                                |
| `max_description_chars` | integer       | 1200    | Ceiling on the introduction                                         |

Returns `{ 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 }`.

`yield` is `{ original_count, original_text, requested, unit, factor }`. `original_text` keeps
the page's own wording, because "4 to 6" and "4" are different claims. Rescaling needs a stated
yield: a page that publishes none comes back as published, and says so.

Ingredients are read from a bulleted list and from a table alike. Where a page lays them out as
a `wikitable`, the amount comes from whichever of the Count, Volume and Weight columns the row
fills, and a baker's percentage column is left out of it.

`author` and `rating` are always `null`: the Cookbook is written collectively and carries no
reader score. A time, a difficulty or a nutrition panel the page does not publish is `null`,
never zero and never inferred from the steps.

### `scale_ingredients`

Rescale any English ingredient list. Makes no network request, so it works on a list pasted in
from anywhere.

| Argument                        | Type     | Meaning                                 |
| ------------------------------- | -------- | --------------------------------------- |
| `ingredients`                   | string[] | Ingredient lines                        |
| `factor`                        | number   | Multiplier. Use this, or the pair below |
| `from_servings` + `to_servings` | number   | The factor is computed from the two     |

Returns `{ factor, ingredients, scaled_count, rounded_count, unscaled_count, notes }`.

### `list_recipes`

Browse by cuisine, kind of dish, or main ingredient. Give at least one of `cuisine`,
`dish_type`, `main_ingredient`; `limit` defaults to 15.

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 a ranked sample rather
than the category itself: it is neither complete nor ordered, and its length says nothing about
how many recipes exist on the subject. The tool say