Reattend

Reattend MCP — Persistent Memory for AI Assistants

Give Claude, Cursor, Windsurf, and any AI assistant a persistent memory — across sessions, across tools, across time.

npx -y @reattend/mcp --token rat_your_token_here

---

The Problem

Every AI conversation starts blank. You re-explain your project, re-paste your decisions, re-describe your preferences — every single session. Claude doesn't remember what you discussed yesterday. Cursor doesn't know what your team decided last sprint. The context is gone the moment you close the window.

This is the persistent memory layer that fixes that.

---

What It Does

Reattend continuously captures context from your tools — meetings, Slack, Gmail, Notion, Linear, Jira, Google Docs — and builds a personal memory store. This MCP server connects that memory to any AI assistant that supports the Model Context Protocol.

Once connected:

• Claude remembers what you discussed in meetings last week
• Cursor knows your architecture decisions and code preferences
• Any AI tool you use has access to your full working context
• You stop re-explaining yourself to every AI, every session

---

Quickstart

Step 1 — Get your token

Sign up at reattend.com → Settings → API Tokens → create a token (rat_...).

Step 2 — Pick your AI tool and add 5 lines

Claude Desktop (~/Library/Application Support/Claude/claude_desktop_config.json on Mac, %APPDATA%\Claude\claude_desktop_config.json on Windows):

{
  "mcpServers": {
    "reattend": {
      "command": "npx",
      "args": ["-y", "@reattend/mcp", "--token", "rat_your_token_here"]
    }
  }
}

Cursor (.cursor/mcp.json or Settings → MCP):

{
  "mcpServers": {
    "reattend": {
      "command": "npx",
      "args": ["-y", "@reattend/mcp", "--token", "rat_your_token_here"]
    }
  }
}

VS Code with Copilot (.vscode/mcp.json):

{
  "servers": {
    "reattend": {
      "type": "stdio",
      "command": "npx",
      "args": ["-y", "@reattend/mcp", "--token", "rat_your_token_here"]
    }
  }
}

Windsurf / Continue / any MCP client — same pattern, command: npx, args: ["-y", "@reattend/mcp", "--token", "rat_xxx"].

Prefer an env var instead of inline token:

{
  "mcpServers": {
    "reattend": {
      "command": "npx",
      "args": ["-y", "@reattend/mcp"],
      "env": { "REATTEND_TOKEN": "rat_your_token_here" }
    }
  }
}

Restart your AI tool. Your memory is now live.

---

How It Works

Your tools (Slack, Gmail, Meetings, Notion...)
         ↓  Chrome extension captures automatically
    Reattend memory store
    (triage → embeddings → semantic index)
         ↓  MCP server bridges the gap
Your AI assistant (Claude, Cursor, Windsurf...)
         ↓  answers from real context, not hallucination
              You

1. Capture — The Reattend Chrome extension passively captures from the tools you already use. Meeting transcripts, Slack threads, emails, docs — no manual input required.
2. Process — Every capture is triaged by AI, embedded for semantic search, and stored in your personal memory.
3. Recall — This MCP server exposes your memory as tools that any AI assistant can call mid-conversation, automatically.

---

Tools Exposed

Tool	Description
search_memories	Semantic + keyword search across all captures. Used automatically by the AI when relevant context might exist.
ask_memory	AI-synthesised answer from your full memory. Best for questions that span multiple captures or time periods.
save_memory	Save something to memory from inside the AI conversation. Decisions, preferences, notes — anything.
recent_memories	Your N most recently captured memories. Good for "what have I been working on?" type questions.

The AI decides when to call these. You don't have to ask — it searches your memory proactively when a question might have relevant past context.

---

Real Examples

Meeting context, recalled automatically:

"I'm about to jump on a call with Acme Corp — give me a briefing"

→ Claude calls search_memories("Acme Corp") → "Last call was Feb 12. They raised concerns about pricing. Sarah is the decision maker. You agreed to a pilot before end of Q1."

Architecture decisions, persisted across sessions:

"What did we decide about the auth service?"

→ Claude calls ask_memory("auth service decision") → answers from the actual meeting where it was discussed, not a guess

Saving preferences mid-conversation:

"Remember — no Redux in this project, we're using Zustand"

→ Claude calls save_memory("Project preference: Zustand over Redux") → saved permanently, available in every future session

Weekly recap:

"What have I been working on this week?"

→ Claude calls recent_memories(20) → pulls everything captured in the past 7 days

Cross-tool context:

"What open tasks came out of last week's planning meeting?"

→ Claude searches memories, surfaces the action items from the meeting transcript captured by the extension

---

What Reattend Captures

Install the Chrome extension to start building your memory automatically:

Source	What's captured
Google Meet, Zoom, Teams	Full audio transcription, title, participants
Slack	Messages and threads you view
Gmail	Emails you read
Notion	Pages you open and work in
Linear	Issues and project updates
Jira	Tickets and boards
Google Docs	Documents you edit
Manual	Highlight anything in the browser → save to Reattend

Everything flows into the same unified memory that this MCP server reads from. No silos.

---

Why Not Just Paste Context Into the Prompt?

	Paste into prompt	Reattend MCP
Setup	Every session, manually	Once — automatic forever
Coverage	Whatever you remember to paste	Everything, captured automatically
Searchability	None	Full semantic + keyword search
Cross-session	❌	✅
Cross-tool	❌ (one AI at a time)	✅ (all MCP tools share same memory)
Context window cost	High — fills up fast	Low — only relevant memories retrieved
Works with meetings	❌	✅

---

Use Cases

For individuals:

• Personal second brain that feeds every AI tool you use
• Never re-explain your preferences, project history, or past decisions
• Meeting notes that are actually searchable and queryable
• Capture decisions as they happen; recall them months later

For developers:

• Cursor / Windsurf with memory of your codebase decisions, ADRs, team conventions
• Claude that knows your project history without a massive system prompt
• AI agent workflows with persistent state across runs

For teams:

• Shared workspace memory: everyone's captures contribute to a shared knowledge base
• New team members can ask "what's our approach to X?" and get real answers
• Meeting decisions preserved and queryable across the whole team

---

Building on the API

If you want to build something on top of Reattend's memory (agents, custom tools, automations), the same token works with the REST API directly:

# Search memories
curl https://reattend.com/api/tray/search?q=acme+pricing \
  -H "Authorization: Bearer rat_xxx"

# Save to memory
curl -X POST https://reattend.com/api/tray/capture \
  -H "Authorization: Bearer rat_xxx" \
  -H "Content-Type: application/json" \
  -d '{"text": "Decided to use Postgres over MySQL for the new service", "source": "agent"}'

# Ask a question
curl -X POST https://reattend.com/api/tray/ask \
  -H "Authorization: Bearer rat_xxx" \
  -H "Content-Type: application/json" \
  -d '{"question": "What database decisions have we made?"}'

# Recent memories
curl https://reattend.com/api/tray/recent?limit=10 \
  -H "Authorization: Bearer rat_xxx"

---

Requirements

• Node.js 18+
• A Reattend account — sign up free
• The Chrome extension (for automatic capture)

---

Related

• reattend.com — product, pricing, Chrome extension
• Model Context Protocol — the open standard this server implements
• MCP server list — other MCP servers
• npm package

---

License

MIT — use freely, modify, redistribute.

---

Reattend is the persistent memory layer for the AI tools you already use. Built for people who are tired of re-explaining themselves to Claude every morning.