Product guide

XenoMind - How It Works

A visual thinking workspace: mind maps, flowcharts, concept maps and fishbone diagrams, full spreadsheets, and a deep Claude (AI) integration. This page explains what the app does and how to drive it with AI.

1. What XenoMind is

XenoMind is a web-based visual thinking and organization tool. You capture ideas as maps you can shape four different ways, keep structured data in full-featured spreadsheets, organize everything in folders, and share or collaborate with others. What sets it apart is how tightly it works with AI: you can let the built-in assistant draft and edit maps for you, or connect the app directly to Claude so Claude can read and build your maps and sheets as if they were its own tools.

2. Features

Maps - four types

Every map is built from nodes and connections, and you choose the thinking model that fits the problem:

Nodes are rich. Each can carry a topic, notes (Markdown), styles (fill, shape, text and branch colours, font size), icons, tags, a link, attachments and images, and tasks. You can draw relationships / connectors between any nodes, collapse branches to focus, and each map type applies its own layout automatically.

Spreadsheets ("Sheets")

Sheets are a full Excel-style grid, not a toy table. They support cell formats, borders, merge / unmerge, freeze panes, formulas, autofilter and checkboxes, across multiple worksheets. You can import .xlsx, .xls and .csv files and export back to .xlsx.

My Drive & folders

Everything lives in My Drive. Organize maps and sheets together in nested folders with drag-and-drop; folders show how many items are inside (counting everything in their sub-folders too). Search finds items by title or by the text inside their nodes.

Sharing & collaboration

Import / export

Bring existing work in from .mmjson / .json, Markdown, OPML, FreeMind, and plain text. Export maps in the native .mmjson format, and back up or restore your entire library as a single zip archive.

Help

Built-in support: a searchable knowledge base, an AI help assistant, and support tickets for when you need a person.

3. AI that works for you

The easiest way to use AI in XenoMind is to let the built-in assistant do the work. Add your own AI key once, then just describe what you want in plain words - "make a mind map for planning a wedding", "add a Risks branch", "turn this into a flowchart" - and it builds or reshapes the map for you.

Bring your own AI key

In Settings → AI, each person adds their own API key for one of three providers - Anthropic Claude, OpenAI ChatGPT or Google Gemini. Keys are stored encrypted; you validate the key and pick a model right in the app.

  1. Open Settings → AI.
  2. Pick a provider: Anthropic Claude, OpenAI ChatGPT or Google Gemini.
  3. Paste your API key and choose a model.
  4. Click Validate, then Save. The built-in assistant can now draft and edit maps from your prompts.
Want Claude to work on your maps directly? Developers and power users can connect XenoMind to Claude over MCP - see For developers & power users at the end.

4. Build a map with any AI (copy & paste)

The easy, no-setup way to brainstorm with any assistant - ChatGPT, Claude, Gemini, whatever you already use - and get a real mind map out of it. Copy a prompt, paste it into your AI, then paste its answer back into XenoMind. No key or connection needed.

  1. Copy the prompt below into your AI. Replace <MY TOPIC> with what you want to map - "a wedding plan", "my dissertation outline", "a product launch".
  2. The AI replies with a block of JSON. Copy all of it.
  3. In XenoMind, go to New → Import → Paste JSON, paste it, and confirm.
  4. Your map opens laid out and ready - rename it, restyle it, or ask the built-in AI to expand it.

Ready-to-copy prompt

It looks technical, but you don't need to read or understand any of it - just press Copy, paste it into ChatGPT, Claude, Gemini or any other assistant, and import what it gives back.

You are generating a mind map for XenoMind. Output ONLY valid JSON - no prose,
no explanation, no Markdown code fence - matching this EXACT schema.

Top-level object (a MindMapDocument):
- "formatVersion": the number 1
- "rootId": the string id of the root node
- "nodes": an OBJECT (flat map) keyed by node id - NOT nested. Each node:
    - "id": string, equal to its key
    - "parentId": the id of its parent, or null for the root node
    - "children": array of child node ids, in sibling order
    - "topic": the node's text
    - "createdAt" and "updatedAt": ISO 8601 strings (use "2026-01-01T00:00:00.000Z")
    - optional: "notes" (Markdown string)
- "relationships": array (use [])
- "theme": "classic"
- "layout": { "type": "map", "hGap": 64, "vGap": 16, "balanceRoot": true }
- "meta": { "createdAt": "2026-01-01T00:00:00.000Z", "updatedAt": "2026-01-01T00:00:00.000Z" }

Integrity rules you MUST follow:
- Every node id is a unique string.
- Every id in a node's "children" array must also exist as a key in "nodes".
- A node's "parentId" must equal the id of the node that lists it as a child.
- The root node's "parentId" is null.

Here is a complete, valid example to match exactly in structure:

{
  "formatVersion": 1,
  "rootId": "root",
  "nodes": {
    "root": { "id": "root", "parentId": null, "children": ["a", "b"], "topic": "My project", "createdAt": "2026-01-01T00:00:00.000Z", "updatedAt": "2026-01-01T00:00:00.000Z" },
    "a": { "id": "a", "parentId": "root", "children": [], "topic": "Goals", "createdAt": "2026-01-01T00:00:00.000Z", "updatedAt": "2026-01-01T00:00:00.000Z" },
    "b": { "id": "b", "parentId": "root", "children": [], "topic": "Timeline", "createdAt": "2026-01-01T00:00:00.000Z", "updatedAt": "2026-01-01T00:00:00.000Z" }
  },
  "relationships": [],
  "theme": "classic",
  "layout": { "type": "map", "hGap": 64, "vGap": 16, "balanceRoot": true },
  "meta": { "createdAt": "2026-01-01T00:00:00.000Z", "updatedAt": "2026-01-01T00:00:00.000Z" }
}

Now build a map about  with a root node and 5-8 branches, each with
2-4 sub-points. Give each node a short, unique id. Output ONLY the JSON object.
The exact JSON format (for a precise or hand-built map)

The map format

A XenoMind map document (MindMapDocument) has this shape:

  • formatVersion: always 1.
  • rootId: the id of the root node.
  • nodes: an object (a flat map keyed by node id) - not nested. Each node has required id (equal to its key), parentId (an id, or null for the root), children (array of child ids in order), topic, and createdAt + updatedAt (ISO 8601 strings). Optional: notes (Markdown), style (fill, textColor, shape ∈ rounded|rect|pill|ellipse|diamond|underline|none, branchColor, fontSize…), collapsed, icons, tags, link, edgeLabel (flowchart Yes/No branches).
  • relationships: array of {id, fromId, toId, label?, style?} cross-links (can be []).
  • theme: a string, e.g. "classic".
  • layout: {type, hGap, vGap, balanceRoot} where type ∈ map|free|fishbone|flowchart|tree-right|tree-down|org|timeline. Use "map" for a mind map, "flowchart" for flowcharts, "fishbone" for fishbone, and "map" or "free" for concept maps.
  • meta: {createdAt, updatedAt} (ISO strings).
Integrity rules (enforced on import): node ids must be unique strings; every id in a children array must exist in nodes; a node's parentId must match the node that lists it as a child; and the root's parentId must be null.

Import also accepts an envelope (the .mmjson export form): {application:"mindmap-studio", exportVersion:1, exportedAt, title, document:{…}}, where document is the shape above.

Minimal, valid, importable example

{
  "formatVersion": 1,
  "rootId": "root",
  "nodes": {
    "root": { "id": "root", "parentId": null, "children": ["a", "b"], "topic": "My project", "createdAt": "2026-01-01T00:00:00.000Z", "updatedAt": "2026-01-01T00:00:00.000Z" },
    "a": { "id": "a", "parentId": "root", "children": [], "topic": "Goals", "createdAt": "2026-01-01T00:00:00.000Z", "updatedAt": "2026-01-01T00:00:00.000Z" },
    "b": { "id": "b", "parentId": "root", "children": [], "topic": "Timeline", "createdAt": "2026-01-01T00:00:00.000Z", "updatedAt": "2026-01-01T00:00:00.000Z" }
  },
  "relationships": [],
  "theme": "classic",
  "layout": { "type": "map", "hGap": 64, "vGap": 16, "balanceRoot": true },
  "meta": { "createdAt": "2026-01-01T00:00:00.000Z", "updatedAt": "2026-01-01T00:00:00.000Z" }
}

5. Prebuilt templates

Don't want to start from a blank map? XenoMind ships with a library of ready-made templates - fully structured starter maps for common tasks. Pick one and it opens as a real, editable mind map in a single click, already filled with sensible branches you can rename, trim, restyle, or extend.

How to use a template

  1. Go to New (the Home screen).
  2. Scroll to "Start from a template" - the gallery below the four format tiles.
  3. Click a template. It creates the map and opens it in the editor, ready to edit.

The Home screen also rotates a "Did you know?" tip with a one-click Try it button that starts the matching template.

What's included

Templates span everyday and professional use - for example:

Each template becomes an ordinary map once created, so you can restyle it, add notes, links and connections, or hand it to the AI to expand.

6. Getting started

Create your first map from New, pick the type that matches how you think, and start adding nodes - or open a template and edit it. Add your AI key in Settings → AI to let the built-in assistant draft and edit maps from your prompts. Organize everything in My Drive, and share via a link, the Gallery, a public directory, or a Team when you're ready to bring others in. That's everything most people need.

7. For developers & power users

The deeper, more technical ways to drive XenoMind with AI. Safe to skip - everything above is enough to get full value from the app.

Connect Claude directly to your maps (MCP)

Beyond the built-in assistant, you can connect XenoMind directly to Claude over the Model Context Protocol (MCP). Once connected - from the Claude Code CLI, Claude Desktop, or a claude.ai custom connector - Claude can read, create and edit your maps and spreadsheets as native tools. Two connection methods:

Method A - Claude Code CLI (token / header)

  1. Open Settings → Connector and generate a connect token (copy it - it's shown once).
  2. Note the MCP URL: https://www.xenomind.studio/api/mcp.
  3. Run the command below (swap in the token you just copied).
claude mcp add --transport http mindmap https://www.xenomind.studio/api/mcp --header "Authorization: Bearer <YOUR_TOKEN>"

Method B - Claude Desktop / claude.ai custom connector (OAuth)

  1. Add a custom connector using just the MCP URL (https://www.xenomind.studio/api/mcp), with no headers.
  2. Complete the OAuth sign-in when Claude prompts you - no token to copy or paste.
Tip: Every node has a copyable ID in the UI. That ID is how Claude addresses a specific node when editing a map (for example to update, move or connect it).
MCP tools Claude gets

Once connected, Claude sees these tools:

list_maps
List your maps.
read_map
Read a map's full structure (nodes, relationships, layout).
create_map
Create a new map of any type.
edit_map
Modify a map: add / update / delete / move nodes, and connect nodes with relationships.
search_nodes
Find nodes across your maps by text.
list_sheets
List your spreadsheets.
read_sheet
Read a sheet's cells and structure.
create_sheet
Create a new spreadsheet.
edit_sheet
Modify a sheet: set_cell / clear_cell / set_style / merge / unmerge / freeze / checkbox / add_worksheet.

↑ Back to top

↑