# Library of Babel MCP Server

An MCP (Model Context Protocol) server granting access to the Library of Babel,
the largest knowledge base in the known universe.

## Setup

No install step — `npx` fetches the server on demand.

In Claude Code:

```bash
claude mcp add library-of-babel -- npx -y library-of-babel-mcp
```

In Claude Desktop or any other MCP client, add this to your MCP config (e.g.
`claude_desktop_config.json`):

```json
{
  "mcpServers": {
    "library-of-babel": {
      "command": "npx",
      "args": ["-y", "library-of-babel-mcp"]
    }
  }
}
```

Then restart the client. You should see the four tools listed below.

## How it works

- **Alphabet**: 29 symbols — `a-z`, comma, space, period.
- **Page length**: 3200 characters (40 lines x 80 chars).
- **Address**: `hexagon` (base-36 string, ~3004 digits), `wall` (1-4),
  `shelf` (1-5), `volume` (1-32), `page` (1-410) — 262,400 pages per hexagon.
- **Library size**: 29^3200 pages, a 4680-digit number.

The library is a *bijection* between addresses and page contents, following
the structure libraryofbabel.info uses. There is no PRNG and no special-cased
slot: every address maps to exactly one page, every possible page maps back to
exactly one address, and the mapping inverts in both directions.

1. Flatten the address into a single integer `index`.
2. Scramble it: `content = (index * MULTIPLIER) mod N`, where `N = 29^3200`.
3. Write `content` out as 3200 base-29 digits — that's the page text.

`MULTIPLIER` is coprime to `N`, so step 2 is a permutation of the entire space
and its inverse is another multiplication by `MULTIPLIER⁻¹ mod N` (computed by
Hensel lifting, since `N` is a prime power). So **searching** means: build the
exact page you want — your text plus padding — read it as a base-29 number,
multiply by the inverse, and unpack the index into coordinates. The page really
is at that address. Nothing is stored; nothing is scanned.

Because padding and offset are part of the page, changing either gives you a
genuinely different page at a different address.

### Fidelity to libraryofbabel.info

The structure and observable behaviour match the real site. The *particular*
permutation does not: libraryofbabel.info's own constants are deliberately
unpublished — [the author's reference
repo](https://github.com/librarianofbabel/libraryofbabel.info-algo) documents
the method (an invertible LCG plus xorshift scrambling) but withholds its `m`,
`a`, and `c`. Addresses produced here are therefore **not portable** to that
site, and vice versa.

## Tools

- `get_page(hexagon, wall, shelf, volume, page)` — read the text at an address.
- `search_text(text, padding, offset)` — find the address of a page containing
  your text. `padding` is `"spaces"` (default) or `"random"`; `offset` is a
  character position or `"random"`. Max 3200 chars; input is lowercased and
  restricted to the library's alphabet.
- `lookup_page(text)` — the exact inverse of `get_page`: give it a full
  3200-character page, get back its address.
- `random_page()` — jump to a uniformly random address.

## Configuration

- `LOB_API_KEY` — leave empty for provisional guest access, until you have
  located the volume containing your API key.

## Running from a local checkout

```bash
npm install
npm run build
node dist/index.js
```

It speaks MCP over stdio, so it expects a client on the other end — it will
just sit there logging "Library of Babel MCP server running on stdio" to
stderr, which is normal.

To point a client at the checkout instead of the published package, use the
built entrypoint:

```json
{
  "mcpServers": {
    "library-of-babel": {
      "command": "node",
      "args": ["/absolute/path/to/library-of-babel-mcp/dist/index.js"]
    }
  }
}
```