Model Context Protocol

Connect any AI to your MIND in one paste.

One command, one click, done. Claude, Cursor, Windsurf — every MCP-compatible AI gets persistent memory backed by your personal knowledge graph. No API key needed.

claude mcp add --transport http mind https://m-i-n-d.ai/mcp

What is the MIND MCP Server?

The MIND MCP Server is a Model Context Protocol server that connects any MCP-compatible AI agent to your personal MIND knowledge graph — remotely at https://m-i-n-d.ai/mcp, or locally over stdio via the open-source npm package.

Once connected, your AI agent can query your knowledge graph, store memories, manage tasks and goals, track contacts, run deep research, and read your emotional context — with full persistence across sessions, devices, and tools. What you teach Claude Code is available in Cursor. What you decide in one session is remembered in the next. 

Your AI Agent  ←→  MCP Protocol  ←→  MIND MCP Server  ←→  MIND Knowledge Graph
   (Claude,         (HTTP or stdio)     (m-i-n-d.ai/mcp)    (entities + relationships)
    Cursor,
    Windsurf...)

Connect in One Paste (Recommended)

No API key. No config files. Sign in once in your browser and you're connected.

1

Claude Code — paste this

claude mcp add --transport http mind https://m-i-n-d.ai/mcp

Then run /mcp in Claude Code. Your browser opens to MIND — click Connect — done. Claude Code now has your full MIND: memory, tasks, contacts, research, everything.

2

Claude Desktop & claude.ai

Go to Settings → Connectors → Add custom connector and enter the URL https://m-i-n-d.ai/mcp. Click through the sign-in, hit Connect, and MIND is available in every conversation.

3

Cursor & Windsurf

Add MIND to your remote-MCP config (.cursor/mcp.json in Cursor, ~/.codeium/windsurf/mcp_config.json in Windsurf) with the same URL:

{
  "mcpServers": {
    "mind": {
      "url": "https://m-i-n-d.ai/mcp"
    }
  }
}

On first use, your browser opens for the same one-click Connect.

How sign-in works: the one-paste flow uses standard OAuth. When you click Connect, MIND creates a dedicated access key for that tool — the same kind of API key you'd make by hand. You can see and revoke every connected tool anytime in Settings → Developer → API Keys. Your password is never shared.

Alternative: Local Install via npm for offline / self-hosted or key-based setups

Prefer to run the server locally over stdio — for self-hosted MIND deployments, air-gapped machines, or setups where you manage keys explicitly? Use the open-source npm package.

1

Get a MIND API Key

Sign up at m-i-n-d.ai (free tier available — no credit card required), then navigate to Settings → Developer → Create API Key. Your key will start with mind_.

2

Install the MCP Server

Requires Node.js 18 or higher.

npm install -g @astramindapp/mcp-server
3

Add it to your tool

Claude Code:

claude mcp add mind -- env MIND_API_KEY=mind_your_key_here mind-mcp

Or any MCP-compatible tool (Claude Desktop, Cursor, Windsurf, VS Code):

{
  "mcpServers": {
    "mind": {
      "command": "mind-mcp",
      "env": {
        "MIND_API_KEY": "mind_your_key_here",
        "MIND_BASE_URL": "https://m-i-n-d.ai"  // optional — point at a self-hosted MIND
      }
    }
  }
}

MCP Tools Reference

Once connected, your AI agent has access to all 30 MIND tools. Each tool's description below is exactly what the AI sees.

Memory & Knowledge
mind_query
Search your MIND knowledge graph. Returns AI-synthesized answer from your stored documents, entries, and feed posts. Use this BEFORE making decisions — MIND is your memory.
When to use: Before any decision or claim — retrieve what MIND already knows about the topic.
mind_remember
Store and manage content in your MIND knowledge graph. Use for facts, decisions, learnings, research, notes — anything worth remembering. Auto-categorized. Always log outcomes here after completing tasks. Supports create (default), delete, search, get, and list. ⚠️ PRIVATE vs PUBLIC: `document` and `entry` are PRIVATE to the user's knowledge graph. `feed_post` is a PUBLIC social-media post that appears on the user's public feed for everyone to see. Default to `entry` for all agent outcomes, logs, decisions, and research. NEVER use `feed_post` unless the user explicitly says "post", "share", "tweet", "feed", or "thought to my feed" — deploy logs, PR notes, work outcomes, and agent activity belong in `entry`, NOT on the public feed.
When to use: After completing work or learning something worth keeping — log it privately so the next session knows.
mind_context
Get your persistent context from MIND — identity, preferences, rules, and recent activity. Call this at the start of every session to know who you are, who the user is, and what matters right now.
When to use: At the start of every session, before anything else.
mind_folders
Organize your MIND documents into folders. Folders are a presentation layer — the knowledge graph still indexes and retrieves across every document regardless of folder. Use mind_remember to create a document, then mind_folders move_documents to file it. Actions: list, create, rename, move, delete, move_documents, set_hint (set the agent-routing hint read by mind_folder_suggest).
When to use: When filing new documents or reorganizing the document tree.
mind_folder_routes
Configure deterministic system-folder routing — which folder each kind of system-generated doc (life items, CRM, chat saves, tasks, training, reasoning trajectories, playbooks, trader signals, cloud imports) is filed into automatically. Actions: list, set, clear, apply_recommended (idempotent one-tap setup that creates Life/CRM/Chats/Reasoning/Trader folders and wires every source_type to its destination). User uploads are unaffected — this is system writes only.
When to use: When setting up or adjusting automatic filing for system-generated documents.
mind_folder_suggest
Ask MIND which folder a piece of content belongs in. Reads every folder's routing_hint (set via mind_folders set_hint) and uses a cheap LLM to pick the best match. Returns folder_id=null when no folder's hint clearly applies — in that case leave the doc unfiled rather than guess. Typical agent flow: suggest → mind_remember (create the doc) → mind_folders move_documents (file it to the suggested folder).
When to use: When unsure which folder a new piece of content belongs in.
mind_list_templates
List the 16 MIND Front Layer template types (SOUL, IDENTITY, BELIEFS, USER, AGENTS, TOOLS, SENSES, SKILLS, BEHAVIOR, LESSON, DECISION, POLICY, WORKFLOW, PREFERENCE, GOAL, RELATIONSHIP). Use this first to see what typed documents an agent can fill in. Each entry includes a short description and the source_tag used when storing filled documents.
When to use: Before writing a typed document — see which of the 16 template types fits.
mind_get_template
Fetch the full augmented markdown for one MIND Front Layer template. Returns a self-contained spec — when to create a document of this type, what slots to fill, and how to store the filled copy. Always read the template before writing a typed document.
When to use: Right before filling in a typed document — read its full spec first.
mind_save_typed
Save a filled-out Front Layer document with the proper type tag so retrieval can filter by it later. Wraps mind document creation and pre-bakes the source tag (`front-layer-<type>`). Use this — not raw mind_remember — for any SOUL/IDENTITY/BELIEFS/USER/BEHAVIOR/LESSON/POLICY/etc. document. Pass the markdown body (frontmatter + content) as the `content` field.
When to use: When saving a completed SOUL/IDENTITY/LESSON/POLICY-style typed document.
mind_bootstrap_templates
Seed all 16 MIND Front Layer templates into this MIND tenant as system documents. After running, the templates become queryable through mind_query so agents can ask 'what should I fill out for SOUL?' and retrieve the spec from their own knowledge graph. Idempotent — re-runs create fresh copies. Run once per new tenant.
When to use: Once, when provisioning a brand-new MIND tenant.
Life & Tasks
mind_life
Manage Focus → Project → Outcome hierarchy + calendar in MIND Life. Items are either projects (top-level domain/client buckets that live inside a Focus) or outcomes (deliverables that live under a parent project). Use `item_type` + `parent_id` + `focus_id` on create/update to wire the hierarchy. Use list filters (item_type, parent_id, focus_id, top_level_only) to slice the board. Share a project with another MIND account using share/list_shares/revoke_share (requires LIFE_SHARING_ENABLED on the backend; grantee gets the project + its outcomes on their board).
When to use: When creating, updating, or completing projects, outcomes, and calendar events.
mind_focuses
Manage Focuses — the top-level buckets that group Life Projects. Every project lives inside one focus (or 'No Focus'). Use list to see all focuses + their project counts, create to add a new bucket (e.g. 'Astra', 'Atlas', 'Fundraising'), update/delete to maintain them. Pass the returned focus_id to mind_life when creating projects.
When to use: When organizing the Life board into top-level focus buckets.
mind_tasks
Manage site-wide tasks in MIND — assignable, completable, reportable work items. A task can attach to a Life project (parent_type=life_item), a CRM contact (parent_type=contact), an agent (parent_type=agent), or stand alone. Assign tasks to a MIND member, an agent, or an external email. Use action=reports for completion analytics.
When to use: When assigning trackable work to a person, agent, or email — or pulling completion reports.
CRM
mind_crm
Manage contacts and relationships in MIND CRM. Use for tracking people, companies, leads, interaction history, and activity logging.
When to use: Whenever a person, company, or interaction enters the conversation — log it.
Emotional Intelligence
mind_sense
Access MINDsense emotional intelligence — the user's living emotional state, signal history, emotional timeline, and KG entity weights. Use this to understand how the user is feeling and what emotionally significant events have occurred.
When to use: When you need to know how the user is feeling before acting or responding.
Research & Training
mind_research
Launch and manage deep research jobs. Research runs autonomously — it gathers information, analyzes it, and stores findings in the knowledge graph. Use for competitive analysis, market research, technical deep-dives.
When to use: When a question needs autonomous multi-source research rather than a quick lookup.
mind_train
Train MIND's knowledge graph. Start guided training sessions to teach it about yourself, or save existing chat conversations into the knowledge graph for persistent memory.
When to use: When teaching MIND about the user, or preserving a whole conversation as memory.
mind_osint
Operate Ozzie — the autonomous OSINT analyst — through MIND. Investigate a target (domain, IP, org, person) and get a cited intelligence dossier; or set up live-feed alerts and watchlists in plain English. Ozzie's dossiers and alerts persist in its MIND knowledge graph, so use mind_query to recall past intelligence and mind_osint to run new work.
When to use: When investigating a domain, IP, org, or person — or setting up live intelligence watchlists.
Social
mind_social
Interact with MIND's social layer — create thoughts (PUBLIC feed posts), browse the feed, manage communities, and engage with other users' content. ⚠️ create_thought posts to the user's PUBLIC social feed for everyone to see — NEVER call unless the user explicitly said "post", "share", "tweet", "feed", or "thought to my feed". For private agent outcomes, deploy logs, or work updates, use mind_remember with type=entry instead.
When to use: Only when the user explicitly asks to post publicly, or to browse the feed and communities.
mind_social_analytics
Read social media analytics from MIND's Social Dashboard — YouTube/LinkedIn/X/Twitch channel stats, recent videos with performance, retention curves, traffic sources, comment sentiment, and goal progress. Use this to answer questions like 'how did Tuesday's video do?' or 'am I on pace for 1k subs?'
When to use: When the user asks how their channels or content are performing.
Profile & Insights
mind_profile
Manage your MIND profile, AI prompt settings, and model preferences. Update your bio, set custom system prompts for chat and thought generation, and choose your preferred LLM model.
When to use: When updating the user's bio, system prompts, or preferred model.
mind_insights
Access insights from MIND's Autonomous Learning Engine — patterns detected in your knowledge graph, weekly summaries, and proactive intelligence. Also trigger on-demand analysis.
When to use: When checking what MIND has proactively learned, or requesting on-demand analysis.
mind_graph
Get MIND knowledge graph statistics, diagnostics, and label details. Use to check graph health, growth, and entity breakdown.
When to use: When checking the knowledge graph's size, health, or entity breakdown.
Automations & Notifications
mind_automate
Create and manage automations in MIND — scheduled workflows, event triggers, and rules that run automatically. Connect CRM events to actions, schedule recurring tasks, and build custom pipelines.
When to use: When something should happen on a schedule or trigger without being asked.
mind_notify
Read and manage MIND notifications — alerts, reminders, insight notifications, and system messages.
When to use: When checking or clearing the user's MIND notifications.
Admin & Multi-account
mind_admin
Admin-only tool for managing MIND users and the Featured Minds Portal. Requires an admin API key. Full CRUD over featured minds (create / list / get_full / update / update_owner_profile / reorder / delete), plus user provisioning and tier/credit management. The Featured Minds Portal at /admin/featuredmindsportal uses these same endpoints — get_featured_mind_full + update_featured_mind_owner_profile let you edit the linked user's LLM model, public chat prompt, temperature, reasoning effort, brand fields, and avatar/banner from any MCP client.
When to use: Admin keys only — provisioning users and managing Featured Minds.
mind_agents
Admin-only Agent Command Center — canonical registry of every Astra AI agent (running on VPS, planned, archived). Query before scaffolding a new agent. Update status / current_job / responsibilities after non-trivial work. Every agent is owned by a MIND account (owner_username) and can be transferred or shared with other accounts as owner/viewer. Backed by /admin/agents on the MIND backend; admin API key required.
When to use: Admin keys only — before scaffolding a new agent, and after agents do notable work.
mind_tickets
Agent ticket queue — file, view, answer, triage, and resolve tickets on any agent in the Command Center. A ticket is client feedback / critique / an idea / a feature request / a bug. Every ticket lives on an agent (agent_slug is always required) and auto-assigns to the Ernie triage agent. Use action=create to file one, action=comment to answer a thread, action=update or action=resolve to triage. Backed by /admin/agents/{slug}/tickets; admin API key required.
When to use: Admin keys only — filing, answering, and resolving feedback on fleet agents.
mind_accounts
Manage multi-MIND accounts. A 'MIND' is a knowledge-graph account; one person can own or be granted access to many. Use to discover every MIND you can access (list), spin up a new one (create), permanently delete one (delete), see who can access a MIND (members), grant an existing user access (grant), or email an invitation (invite).
When to use: When working across multiple MINDs — list, create, switch, or share access.
mind_personas
Influencer Factory Command Center — synthetic-persona creators that publish across Blotato platforms. Admin-only. Phase 1 surface: persona CRUD (auto-creates a Featured MIND row with IF fields), face anchor (AI-generate via Nano Banana Pro OR user-uploaded with rights affirmation), face variants (image-to-image via n8n + Fal.ai, always pinned to anchor — never chained), voice (ElevenLabs library search + clone + sample), per-platform bios (with optional LLM draft), Blotato account registration (YouTube/IG/LinkedIn/X/Threads/Pinterest; TikTok marked manual_upload). Each persona is publicly chattable at /m/{username} via its linked Featured MIND.
When to use: Admin keys only — building and managing synthetic-persona creators.

How Agents Should Use MIND

MIND is the persistent memory and knowledge-graph layer for AI agents — identity, memories, decisions, tasks, contacts, and emotional context that survive across every session, every tool, and every agent. The server ships these instructions to every connected agent; the protocol is three moves:

// 1. SESSION START — always do this first
mind_context()             → Load identity, operating rules, priorities, recent activity. Never skip it.

// 2. BEFORE deciding or asserting anything
mind_query(topic)          → MIND is authoritative memory — do not guess or claim something
                             does not exist without querying.

// 3. AFTER completing non-trivial work
mind_remember(outcome)     → Log the outcome. Unlogged work is invisible to the next session.
                             Use type: "entry" (PRIVATE — default) for agent outcomes, logs,
                             decisions, and research.
Private vs public: document and entry (via mind_remember) are private to the user's knowledge graph. feed_post and mind_social create_thought are public — they post to the user's social feed where everyone can see them. Agents should never write to the public feed unless the user explicitly says "post", "share", "tweet", or "feed". Deploy logs, work outcomes, and agent activity belong in private entries.

Runtimes that aren't MCP hosts can call the same surface as a REST API at https://m-i-n-d.ai/developer/v1 with an X-API-Key header — every tool maps 1:1 to an endpoint.

Authentication & Revoking Access

Both flows authenticate with the same thing: a standard MIND API key. The one-paste OAuth flow mints one automatically when you click Connect; the npm flow uses one you create by hand. Either way, every connected tool shows up in m-i-n-d.ai → Settings → Developer → API Keys, where you can see its usage and revoke it instantly. Revoking the key disconnects that tool — nothing else changes.

Why MIND vs Flat File Memory (MEMORY.md)

CapabilityMEMORY.md / flat filesMIND MCP
Size limit~20K chars, then truncatedUnlimited knowledge graph
RetrievalLoads everything every turnOnly retrieves relevant memories
StructureUnstructured textEntities + relationships + embeddings
SearchKeyword on small fileHybrid semantic + graph traversal
Cross-toolLocked to one toolShared across all MCP-compatible agents
DocumentsManualUpload PDFs, Word, URLs, text
TasksManual text editingStructured task management via mind_life
ContactsNot supportedFull CRM via mind_crm

Programmatic / SDK Usage

You can also import the server directly in your own Node.js application:

import { createMindMcpServer, MindClient } from "@astramindapp/mcp-server";

const client = new MindClient({
  baseUrl: "https://m-i-n-d.ai",
  apiKey: process.env.MIND_API_KEY,
});

const server = createMindMcpServer(client);
// Connect to any MCP transport (stdio, SSE, etc.)

Links & Resources

Get Started

Documentation

MIND Skill for Claude Code

A one-line install that teaches Claude Code exactly when and how to use the MIND MCP tools — session-start protocol, decision protocol, storage protocol, anti-patterns. After installing, Claude Code automatically loads context at session start, queries MIND before decisions, and logs outcomes at session end.

curl -fsSL https://m-i-n-d.ai/developer/mind-skill/install.sh | bash

Installs to ~/.claude/skills/mind/SKILL.md. Pairs with either connection flow above.