Booboo

MCP文档知识

提供方 未标注

文档知识 stdio · 本地进程 未标注 社区 / 第三方 Claude DesktopClaudeCursorVS Code
查看接入方式

通过MCP将AI系统的连接、知识、记忆、代理和定时任务查询为一个根图,并配有实时3D查看器。

一句话选型结论

按资料字段整理

Booboo 属于文档知识类 MCP 服务器,stdio · 本地进程,鉴权方式未标注,可直接接入 Claude Desktop、Claude、Cursor 等,有可直接执行的安装命令。接入前先确认权限范围;涉及写入、删除或付款的操作,建议先在测试环境验证。

分类文档知识 传输方式stdio · 本地进程 鉴权未标注 部署方式本地部署
GitHub 星标 未标注 仓库热度,无公开仓库时显示未标注
工具数 未标注 暴露给模型的工具数量
资源 / 提示词 0 / 0 资源与提示词模板数量
维护方 社区 / 第三方 核验等级 仅资料核对

工具与能力

文档知识
数量来自来源目录的标注,具体工具清单以官方文档为准
工具数量未标注暴露给模型可调用的工具个数
资源数量0可读取的资源条目
提示词数量0内置提示词模板数量

能力标签

支持客户端

适用场景

记忆

安装与配置

stdio · 本地进程 未标注
客户端在本机拉起子进程,数据不出本机
npx @booboo-brain/cli view --demo --nodes 1000000

这条命令只是入口,具体启动参数请按官方文档补齐,不要直接照搬到别的服务器。

  1. 1
    准备运行环境

    stdio 服务在本地起进程,需要先装好 Node.js 等运行时,再按安装命令拉取依赖。

  2. 2
    安装服务

    复制上面的安装命令执行;命令里带占位符的位置,换成自己的密钥或路径。

  3. 3
    写入客户端配置

    在客户端的 MCP 配置里填好启动命令和参数,保存后完全退出客户端再打开,让新配置生效。

  4. 4
    验证是否可用

    连接成功后随便调一个只读工具,确认能返回结果,再接入正式流程。

典型使用场景

3 类
按分类与标签整理的常见用法,具体以官方文档为准
文档检索问答

在你的文档库里按问题找答案。

知识库读写

把新资料写进知识库,随用随取。

内容整理

把零散资料归纳成结构化笔记。

选择建议

选之前先看这几条
按条目字段给出的判断,不替你决定用不用

值得选的地方

  • 有现成的安装命令,不用自己找入口,照着跑就能起服务。
  • 已适配 Claude Desktop、Claude、Cursor,换客户端不用重新研究配置。

先想清楚的地方

  • stdio 方式要求本地装好运行时(如 Node.js),换机器要重新装一遍。
  • 资料没标注工具数量,实际能力要装好后确认。
  • 版本更新与行为细节以官方仓库为准。

更适合

  • 需要在文档知识场景里让模型直接调用外部能力的人。
  • 已经在用 Claude Desktop、Claude 的用户,接入路径最短。
  • 想先快速试一下、能接受在本地或自有环境跑服务的人。

不太适合

  • 完全不想在本地装环境的人。
  • 需要厂商级 SLA 和技术支持的生产环境。

同类对比

6 个同类
同分类里挑最接近的几条,字段以各自详情页为准
MCP 服务器工具数传输方式部署方式安装命令最后核验
Booboo当前 未标注 stdio · 本地进程 本地部署 有 未标注
dify 未标注 stdio · 本地进程 本地部署 有 2026-04-11
open-webui 未标注 stdio · 本地进程 本地部署 有 2026-04-11
JeecgBoot 未标注 stdio · 本地进程 本地部署 有 2026-04-11
Cherry Studio 未标注 未标注 未标注 无 2026-05-17
mempalace 未标注 stdio · 本地进程 本地部署 有 2026-04-11

服务器档案

文档知识
字段来自项目仓库与公开索引,中文说明由本站标注
提供方未标注上游标注的维护方 未标注
分类文档知识本站按上游分类展示
连接方式stdio · 本地进程客户端在本机拉起子进程,数据不出本机
鉴权方式未标注远程服务建议用最小权限凭据
维护方社区 / 第三方核验等级 仅资料核对
包名 / 运行时未标注 · 未标注本地安装时用到的包标识与运行时
部署类型本地部署上游给出的部署形态
最近核验未标注上游最后核验时间

详细介绍

10.7 KB
来自项目仓库与上游目录的原文,未做删改

🐾 Booboo — the unified operational brain

> Turn any AI system's data into one living, rooted 3D brain — structure + knowledge + memory + agents + automations fused into a single graph. Query it by REST or MCP, view it in your browser or as a desktop wallpaper, and boot your agents from it in one call.

See it before you install it → booboo.fractionalhq.uk · a live brain in your browser, no signup, nothing to clone.

Named after a dachshund who never forgets where the treats are buried. Fitting, because Booboo is about exactly that: memory and recall — seeing the whole system at once, fetching what's buried, never losing the thread.

Unretouched: booboo view --demo --nodes 50000 — 50k nodes, 4 layers, live in a browser tab, zero console errors. Try it yourself in one command.

Most tools show you one slice: a knowledge graph, an agent flow chart, a memory store, a trace viewer. Booboo fuses all of them into one graph rooted at a single point, so you can see — and query — how the whole system actually hangs together.

> Status: alpha — eight packages published: @booboo-brain/spec (the contract), @booboo-brain/build (config-driven postgres/json adapters), @booboo-brain/serve (REST + MCP query layer), @booboo-brain/viewer (million-node 3D render), @booboo-brain/panel (the organigram), @booboo-brain/vault (wiki-linked markdown export), @booboo-brain/cli (the unified booboo command), and create-booboo (project scaffolder). Per-package semver — see each package.json. MIT.


The one idea

Booboo is a tiny JSON spec at the center, with adapters that feed it and consumers that render/serve/query it:```
your data ──▶ ADAPTERS ──▶ GRAPH JSON ──▶ CONSUMERS
(postgres, (config- (the spec, (3D viewer ·
json, neo4j, driven, ~1 KB REST API ·
mcp, …) ~50 lines) contract) MCP server · wallpaper)


Emit the JSON → get the viewer, the API, and the MCP server **for free**. Weird data → a ~50-line adapter, not a fork. See `SPEC.md`.

## Quickstart

**One command. No database, no config, no signup.** A synthetic brain, running on your machine:```bash
npx @booboo-brain/cli view --demo --nodes 1000000

That's the headline flex: a million nodes at 60fps in a browser tab. Drop the count to --nodes 50000 on a modest laptop. See SCALE.md for how it holds up (one draw call over a single point cloud with a custom shader, plus tier-LOD on labels).

If it holds up on your machine, leave a star. There's no marketing behind this repo; stars are how the next builder finds it.

Then point it at your own stack:```bash

scaffold a project (json starter + postgres upgrade path)

npx create-booboo my-brain
cd my-brain
npm install
npm run build # booboo.config.yaml → brain.json (the snapshot)
npm run serve # REST API on http://localhost:8787
npm run mcp # MCP over stdio — point Claude / Cursor / Claude Code at it


Edit `booboo.config.yaml` to point at your own Postgres/Supabase (a commented example ships in the scaffold). Full reference: docs/CONFIG.md · stuck? docs/TROUBLESHOOTING.md.

> **Roadmap:** a single all-in-one command bundling build + REST + MCP + the 3D viewer together, and an interactive scaffold wizard — tracked in LAUNCH_CHECKLIST.md.

## What works today```bash
booboo build --config booboo.config.yaml    # any postgres/json → one graph snapshot (privacy walls + parent spines)
booboo serve --snapshot my.booboo.json --port 8787   # REST: /graph /stats /search /nodes/:id /neighbors/:id /path/:a/:b
booboo mcp   --snapshot my.booboo.json --org org.booboo.json  # MCP over stdio (+ booboo_boot: agents boot FROM the org)
booboo view  --snapshot my.booboo.json               # 3D viewer in your browser — no monorepo, no build step
booboo panel --org org.booboo.json --snapshot my.booboo.json  # THE ORGANIGRAM — see below
booboo vault --snapshot my.booboo.json --org org.booboo.json --out vault  # the brain as a markdown vault — see below

booboo view serves the @booboo-brain/viewer 3D renderer as a standalone app — any snapshot (or ?n=1000000 synthetic) in your browser, no monorepo. The build engine was
proven on a real 4,469-node production brain assembled straight from Supabase by config alone —
privacy-walled, validated, served. See each package's README for the details.

Connect it to Claude / Cursor (MCP)

booboo mcp speaks MCP over stdio. Point any MCP client at it — no server to host, it runs on demand:jsonc // Claude Desktop: claude_desktop_config.json · Cursor: .cursor/mcp.json · Claude Code: .mcp.json { "mcpServers": { "booboo": { "command": "npx", "args": ["-y", "@booboo-brain/cli", "mcp", "--snapshot", "my.booboo.json", "--org", "org.booboo.json"] } } }

Your agent can now query the whole system — search, neighbors, path, stats — booboo_boot('') returns an agent's rules, memory reach, and reports so it boots from the org, and booboo_remember / booboo_report let it write back durable memories and reports that persist across rebuilds (the live memory system). Point --snapshot/--org at absolute paths if the client's working directory differs.

Tools

Tool What it does
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_boot (with --org) An agent's boot slice of the organigram: identity, authority chain, inherited rules, bucket access, skills, children. Call this first, every session.
booboo_org (with --org) The full organigram: every agent, the hierarchy, buckets and rule refs.
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.

> booboo_remember / booboo_report are on by default — the live half of the memory system. Pass --no-write (or BOOBOO_READONLY=1) for a read-only server (public/locked-down deployments); it still reads the journal but refuses writes.

The Organigram — run your agents like a company

booboo panel opens your agent fleet as a real org chart — and the chart is not a diagram, it's the authority. Every agent is a card: its rules, skills, memory-bucket access, and latest reports. Drag an agent under a new parent, hit apply, and the org file changes — versioned in git, validated before every write (a cycle can never land). Agents that boot with booboo_boot obey the new shape on their next session. Reorganize your company at breakfast; the whole fleet knows by the first coffee.

Five tabs over one org file + one snapshot: organigram (drag-drop hierarchy) · buckets (who remembers what) · reports (what the fleet closed, newest first) · rules (who declares, who inherits) · graph (the 3D brain, embedded). Rules inherit top-down — declare once at a branch, everyone beneath is bound; every dossier shows the inherited stack in boot order.

Reports and buckets fill two ways: live, when an agent calls booboo_remember / booboo_report (durable journal writes, no rebuild), or in bulk from your own tables via config — see docs/CONFIG.md § Wiring fleet reports & memory.

The vault — your brain as plain markdown (Obsidian-ready)

booboo vault emits the same snapshot as a wiki-linked markdown vault: one page per
node with frontmatter and its links, index pages per layer and cluster, an agent dossier
per org member (chain of command, inherited rules, buckets, machines, contract). Open the
folder as an Obsidian vault and you have the "LLM second brain" pattern — except generated
from your real system instead of hand-fed notes. Plain files are the ultimate portability:
any human can read them, any agent from any provider can too. Emit it nightly and the vault
doubles as your insurance copy.

Author links yourself: put [[node-id]] (or [[exact label]]) refs inside a note's text and
set wikilinks: true in the config — the builder turns them into first-class authored edges
that outrank harvested relations, in the graph, the API, the 3D view and the vault. Every build
also prints an ingestion-quality line (authored · orphans · dump-suspects) so curation is
a number, not a vibe.

Your agent knows what to do — the contract ships with the scaffold

npx create-booboo scaffolds AGENTS.md (imported by CLAUDE.md) into the project: the
operating doctrine any AI agent working that folder reads automatically — boot from the org,
one atomic fact per note, author your [[links]], corrections replace, respect the walls,
watch the quality gate, close honestly. A fresh install leaves your agent already fluent in
the brain's conventions; edit the file as your own rules evolve — it is your system's
constitution, versioned next to the org.

Why it's different

The closest things on GitHub each do one layer — good tools, all of them, for their slice:

Whole-system view REST API MCP (agents query it) 3D at 1M nodes Privacy walls
Booboo ✅ ✅ ✅ ✅ ✅
Graph viewers (3d-force-graph) render only — — ✅ —
Note graphs (Obsidian, Logseq) your notes, not your system (booboo emits an Obsidian vault: booboo vault) — plugins — —
Agent frameworks (LangGraph, traces) flows & runs ✅ partial — —
Memory stores (Graphiti, Cognee) memory only ✅ ✅ — —

None fuse wiring + knowledge + episodic memory + agents + crons into one rooted, live, bootable brain that's simultaneously a view, a wallpaper, an API, and an MCP source. That operational fusion is the novel part.

Key in hand (optional — everything above stays free)

Every feature is MIT and always will be. If you'd rather not do the setup yourself,
Fractional HQ maps your stack: custom adapters,
hosted snapshot, refresh pipeline. Same repo, same config schema, never a fork, never a gate.

License

MIT — built to be forked, adapted, and shipped. By Fractional HQ.

常见问题

8 问
答案由本站依据条目字段整理,不引用上游原文
Booboo 怎么安装?

在客户端按下面的安装命令接入:npx @booboo-brain/cli view --demo --nodes 1000000。装完在客户端配置里引用同一个包或端点。

Booboo 怎么在 Claude Desktop、Claude、Cursor 里配置?

它的传输方式是stdio · 本地进程,在客户端的 MCP 配置里填好启动命令和参数,保存后完全退出客户端再打开,配置才会生效。

Booboo 收费吗?

本站不代收费用,也没有标注具体价格。是否收费取决于服务本身和背后的接口额度,正式使用前按官方说明确认。

Booboo 需要 API Key 吗?

资料没有标注鉴权方式,是否需要密钥取决于服务本身,接入前按官方文档确认。

Booboo 支持哪些客户端?

资料标注支持 Claude Desktop、Claude、Cursor、VS Code、Gemini CLI、Codex;其他客户端只要能配置 MCP Server,也能用同样的命令或地址接入。

Booboo 能提供哪些能力?

资料显示能力标签包括 记忆。具体工具清单以官方文档为准。

Booboo 需要什么运行环境?

属于本地进程,需要在本机装好运行环境。

Booboo 是本地还是远程?

它是本地进程(stdio),由客户端在本机拉起。传输方式为stdio · 本地进程。

热门专题

按标签挑服务器
全部专题 →

服务器信息以作者仓库与官方文档为准;分类、传输方式与鉴权方式的中文说明为中文整理,最近核验 未标注。