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:

```bash