Skip to main content

Knowledge Mindmaps

V2 only — invite-only edition. This is part of AI Partner V2 and is not in the open-source V1 you self-host from the Quick Start. V2 is available now, by invite. See V1 vs V2.

What mindmaps are​

A mindmap turns a topic into a structured, web-grounded knowledge page — Globe-Explorer style. Instead of a wall of text, you get sections of illustrated sub-concept tiles, each with a short summary, a deeper detail paragraph, and real source citations.

Type a command in chat:

/mindmap indian economy and falling rupee
/mindmap for kids under 7: photosynthesis
/mindmap expert: transformer architecture

The agent grounds the topic on live web search, synthesizes a structured tree, renders it inline in chat, and saves it to your workspace.

Mindmaps are audience-aware. Add a hint like for kids:, student:, or expert: to adapt the vocabulary, depth, and tone. Default is a general audience.

How grounding works (why it's current, not stale)​

Mindmap content is cited and current because grounding prefers live web search in this order:

  1. 1
    Active model's native search

    If your active/reasoning model has native web search (Perplexity, Gemini, Groq compound, …), its search is used directly.

  2. 2
    Ollama Cloud web search

    If the active model can't search and OLLAMA_API_KEY is set, Ollama Cloud's real-results web search is used as the fallback.

  3. 3
    External search providers

    Otherwise it falls back to your search stack — SearXNG → Brave → SerpAPI.

Each tile carries the source links the facts came from, so the map is verifiable rather than training-data recall.

The Explorer​

The chat card is a compact preview. Click Explore to open the interactive Explorer:

Drill in place

Click any tile and it expands in place into a deeper, cited level — no new instances, no chat-append. A breadcrumb lets you jump back to any level.

Concept-links graph

A zoomable, pannable node-link graph shows how concepts connect — solid = structure, dashed = related (from the persistent knowledge graph). Click a node to jump to it.

Web toggle

Each drill-down is web-grounded; you control freshness per node.

One download

Export the whole explored tree — everything you've opened — as a single self-contained HTML file.

Depth — without drilling​

The Explorer lets you drill interactively, but you can also generate a deep map in one shot with a depth dial — essential for messaging (no Explorer to click) and for when you just want a complete map:

/mindmap depth:2 indian economy and falling rupee
  • depth:N (1–3, default 1) auto-expands N levels at generation time — each level web-grounded and cited.
  • Bounded so cost can't explode: up to 3 tiles per section per level, a hard 24-expansion budget, 3-at-a-time concurrency.
  • Higher depth = slower (more grounded LLM calls): depth:2 ≈ a minute or two; depth:3 hits the budget cap.

Works everywhere the command does — web chat, messaging, and the MCP tool.

Continue from a conversation​

Have a good back-and-forth, crystallize it into a map, keep talking, then crystallize again — each map builds on the last instead of starting over. Run /mindmap with no topic:

/mindmap
  • First time in a conversation → it maps the conversation so far.
  • After a map already exists → it evolves that map: it carries forward the branches you actually drilled into in the Explorer (your revealed interest), folds in everything discussed since the last map, and drops what was abandoned.
  • Each crystallize is a new card in the thread, so you get a trajectory — how the thinking moved — not a pile of disconnected snapshots.

Continuation is grounded in the conversation itself (not a fresh web search), so the map stays faithful to what you actually said. The tiles you expanded matter — they tell the next map what you care about most.

Works in web chat and in messaging (a bare /mindmap from Telegram continues that chat's last map).

Build a mindmap from your own sources​

Point a mindmap at material you provide instead of a typed topic. The map is grounded in that source (retrieved, cited by document) rather than the open web.

A codebase (.zip)

Upload a zipped repo, then run /mindmap zip. It's extracted (skipping node_modules, .git, build output, lockfiles), read, and mapped as structure + concepts — the directory/module skeleton and what the code does, in one map.

Documents (PRD / PDF / docx / md)

Upload files to the chat, then /mindmap uploads to map them. Great for a spec, a research set, or a handful of reports.

Knowledge-base docs

Already ingested documents? /mindmap docs:<id,id> maps a chosen set from your knowledge base.

A connected database

With a database integration connected, /mindmap db:oracle maps it read-only: the schema (tables → columns) and data insights (row counts + sampled rows). Writes are impossible — every query goes through a read-only executor.

Add a focus after the token to steer the map, e.g. /mindmap db:oracle revenue by region or /mindmap zip the auth module.

Because /workspace lives inside the container, a whole codebase is provided as a .zip upload — no host paths or Docker setup needed. Individual documents use the normal chat file upload.

Database mindmaps are strictly read-only — schema introspection plus a few SELECT samples, every statement routed through a write-blocking, LIMIT-capped executor. The connection comes from your stored integration secret (e.g. the Oracle card's ORACLE_CONNECTION_STRING).

From messaging (Telegram / WhatsApp)​

/mindmap works from your connected chat channels too:

/mindmap depth:2 renewable energy in india
  • The bot replies with a text summary + the HTML file attached (chat apps can't render the interactive Explorer).
  • On Telegram, /mindmap appears in the / command menu; WhatsApp / Discord / Slack accept it as typed text.
  • Use the depth:N dial especially here — with no Explorer to drill, depth is how you get a complete map in one go.
  • Continue + sources work here too: a bare /mindmap continues the chat's last map; /mindmap db:<integration> and /mindmap docs:<ids> map a database or knowledge-base set.

Message your Telegram bot once so it records your chat. After that the agent can also push any generated file to you on demand ("send the mindmap to telegram") — the chat link is remembered across restarts.

Sharing the export​

The downloaded HTML is built to be shared:

  • Collapsible outline — explored sub-branches are collapsed by default (▸ Explore: N sub-topics), so even a deep map stays skimmable.
  • Table of contents with jump links to each section.
  • Self-contained — inline styles, emoji/SVG icons, clickable citation chips. No JavaScript, works offline, opens in any browser.

You can download from the chat card or the Explorer — both serve the live explored tree, so the file always reflects everything you've drilled into.

Use it inside larger tasks​

Mindmaps are also exposed as the generate_mindmap MCP tool, so the goal executor can build a mindmap as one step of a bigger autonomous task (e.g. "research X and produce a visual map"). It accepts query, optional audience, grounding (auto | web | llm), and depth (1–3).

Under the hood​

  • Persistent knowledge graph — every mindmap upserts concepts as nodes + edges (tenant-scoped), so later mindmaps build on earlier ones and the Explorer can show real cross-links.
  • One synthesis hook, many grounding sources — topic/web, the conversation (continuity), retrieved source documents (codebase / uploads / KB), or a read-only database all feed the same map builder.
  • Read-only by construction for databases — schema introspection and samples run through a write-blocking, LIMIT-injecting SQL executor; a mindmap can never modify your data.
  • Tenant-aware — all data is scoped per user; the same code runs on single-user (main) and multi-user (feat/multi-tenancy) deployments.
  • Editable prompt — synthesis is driven by server/prompts/mindmap-synthesize.md, tunable without a code change.

For the freshest, best-cited mindmaps, set OLLAMA_API_KEY (Ollama Cloud web search) or use an active model with native web search.