# Booboo [Health: Active]

**Category:** 🧠 Knowledge & Memory  
**Repository:** https://github.com/jessymariau/booboo  
**GitHub Stars:** 1  
**npm Downloads (last month):** 227  
**Views:** 0  
**Installs:** 0  
**Upvotes:** 0  
**Directory Page:** https://allmcps.com/mcp/booboo

## Description
Query your AI system's wiring, knowledge, memory, agents and crons as one rooted graph over MCP.

## Tools
Capabilities this server exposes over MCP:

- **booboo_stats** — Node/link counts for the whole graph, broken down by layer.
- **booboo_count** — Counts alone, without pulling the payload — use when sizing a query.
- **booboo_search** — Search nodes by label or id (ranked: exact > prefix > substring). Use this first to find a node's id.
- **booboo_node** — Fetch a single node (all fields + data) by its exact id.
- **booboo_neighbors** — The neighbourhood around a node: connected nodes + links out to `depth` hops.
- **booboo_path** — Shortest path (chain of nodes) between two node ids; null if unreachable.
- **booboo_remember** — Write** a durable memory — one atomic fact, tied to an agent. Appended to the journal beside the snapshot; queryable the same session, survives every rebuild.
- **booboo_report** — Write** a report — what an agent just closed. Lands on the panel's Reports timeline.

## Claude Desktop Quick Installation
Install path detected from listing signals. Uses `npx` (confidence: high):

```json
"mcpServers": {
  "booboo": {
    "command": "npx",
    "args": ["-y","@booboo-brain/cli"]
  }
}
```

## Documentation

## What Booboo MCP server does

Booboo MCP server presents an AI system as one rooted graph rather than separate stores for structure, knowledge, memory, agents, and automations. The graph is represented by a JSON snapshot produced from supported data sources, including JSON and PostgreSQL-based configurations. An optional organization file adds agent hierarchy and related operating context.

The server is intended for agents that need to discover how a system is connected. It can return graph-wide counts, locate nodes by label or identifier, retrieve complete node data, inspect nearby connections, and find the shortest route between two node IDs. It also supports durable write-back: an agent can append an atomic memory tied to an agent or file a report about completed work.

## How it works

A typical deployment builds a graph snapshot from configuration, then starts the MCP command against that snapshot. The MCP process communicates over stdio, so an MCP client launches it on demand rather than requiring a separately hosted service. Snapshot and organization paths can be supplied as command-line arguments; absolute paths are useful when the client uses a different working directory.

Search is the normal starting point when an agent does not know a node's exact ID. Results are ranked from exact matches to prefix and substring matches. After identifying a node, the agent can request its complete record, traverse connected nodes to a selected depth, or calculate a shortest path to another node. Count operations are available when an agent needs to estimate query size without retrieving the full payload.

With an organization file, the documented MCP interface also includes agent boot and organization queries. The boot operation returns an agent-specific slice covering identity, authority, inherited rules, bucket access, skills, and children. The organization operation returns the broader agent hierarchy, buckets, and rule references.

## Setup and configuration

Create or obtain a Booboo graph snapshot, then run the CLI's MCP command with the snapshot path. A documented configuration uses `npx` and `@booboo-brain/cli`:

```json
{
  "mcpServers": {
    "booboo": {
      "command": "npx",
      "args": [
        "-y",
        "@booboo-brain/cli",
        "mcp",
        "--snapshot",
        "my.booboo.json",
        "--org",
        "org.booboo.json"
      ]
    }
  }
}
```

The `--org` argument is optional for graph queries and is needed for organization-backed agent features. Writes are enabled by default. Use `--no-write` or set `BOOBOO_READONLY=1` to make the server read-only; in that mode it can still read the journal but refuses memory and report writes. The project requires Node.js 18 or newer.

## Tools and capabilities

Booboo MCP server provides these graph operations:

- `booboo_stats`: returns node and link totals, including layer breakdowns.
- `booboo_count`: returns counts without the associated payload.
- `booboo_search`: ranks node matches by exact, prefix, and substring relevance.
- `booboo_node`: fetches all fields and data for an exact node ID.
- `booboo_neighbors`: returns connected nodes and links through a chosen depth.
- `booboo_path`: finds the shortest node chain between two IDs, or returns null when unreachable.
- `booboo_remember`: appends one durable, agent-linked fact to the journal.
- `booboo_report`: records an agent's completed work on the reports timeline.

When an organization file is supplied, `booboo_boot` and `booboo_org` provide agent boot context and the full organization structure, respectively.

## Limitations and notes

The project describes itself as alpha. MCP transport is documented as stdio, and the server operates on a snapshot rather than directly exposing an unspecified live database connection. The graph must therefore be built or refreshed through the project's build workflow when source data changes. Write operations can be disabled for public or locked-down deployments, but doing so prevents `booboo_remember` and `booboo_report` from modifying state.

_Full upstream README: https://allmcps.com/mcp/booboo/readme_