npm package: @reattend/mcp
Description: MCP server for Reattend — give Claude, Cursor, and any AI tool persistent memory
Author: Reattend
Latest version: 1.0.0

# Reattend MCP — Persistent Memory for AI Assistants

[![npm version](https://img.shields.io/npm/v/@reattend/mcp)](https://www.npmjs.com/package/@reattend/mcp)
[![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](LICENSE)
[![MCP Compatible](https://img.shields.io/badge/MCP-Compatible-8B5CF6)](https://modelcontextprotocol.io)

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

```bash
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](https://modelcontextprotocol.io).

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](https://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):

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

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

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

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

```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:**

```json
{
  "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](https://reattend.com) 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](https://reattend.com) 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
# 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](https://reattend.com)
- The Chrome extension (for automatic capture)

---

## Related

- [reattend.com](https://reattend.com) — product, pricing, Chrome extension
- [Model Context Protocol](https://modelcontextprotocol.io) — the open standard this server implements
- [MCP server list](https://github.com/modelcontextprotocol/servers) — other MCP servers
- [npm package](https://www.npmjs.com/package/@reattend/mcp)

---

## 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.*