Documentation

Overview

Reflect Memory gives your AI tools shared memory. Store something in one tool and every connected tool can access it: ChatGPT, Claude, Cursor, Gemini, and more. All data is scoped to your account and privacy-first.

Base URL: https://api.reflectmemory.com

Authentication

All requests require a Bearer token in the Authorization header:

Authorization: Bearer <your-api-key>

User key: Full access. Used for direct API calls, scripts, and the dashboard. Get this from your account settings.

Agent keys: Scoped per vendor (e.g., chatgpt, claude). Used by AI integrations. Each agent only sees memories where allowed_vendors includes"*" or their vendor name.

API Endpoints

Agent endpoints (used by AI integrations):

• POST /agent/memories Create a memory.
• GET /agent/memories/latest Most recent memory. Optional ?tag= filter.
• GET /agent/memories/{id} Full memory by UUID.
• PUT /agent/memories/{id} Replace title, content, tags, and vendor visibility. Keeps version history.
• DELETE /agent/memories/{id} Soft-delete (recoverable from trash).
• GET /agent/memories/{id}/versions Prior versions of a memory.
• POST /agent/memories/{id}/children Reply on a thread. Threads are one level deep.
• GET /agent/memories/{id}/thread Parent plus replies. Accepts the parent id or any reply id.
• POST /agent/memories/search Full-text search with full content.
• POST /agent/memories/list Recent memories with full content.
• POST /agent/memories/browse Summaries only (no content).
• POST /agent/memories/by-tag Full memories matching any of the given tags.
• GET /agent/briefing Condensed snapshot: identity, tags, open threads, Ambient preference.
• GET /agent/team/memories Organization pool (path name is legacy). Not the sub-team pool.
• POST /agent/team/share Share one memory into the organization pool.
• POST /query AI query with memory context.
• GET /whoami Resolve identity from the key.

User endpoints (dashboard, scripts): POST /memories,PUT /memories/:id,DELETE /memories/:id,POST /memories/list.

MCP Server

Reflect Memory exposes a Model Context Protocol (MCP) server for Claude and other MCP-compatible hosts. Connect to:

https://api.reflectmemory.com/mcp

Transport: Streamable HTTP. MCP clients must use streamable-http (or streamableHttp in Cursor settings). The legacy SSE transport is not supported.

Auth: OAuth 2.1 (for Claude native connector) or Bearer token (for Cursor, xAI API, n8n, and other MCP clients). Claude handles OAuth automatically when you add the connector URL.

Cursor config

Create .cursor/mcp.json in your project root:

{
  "mcpServers": {
    "reflect-memory": {
      "type": "streamable-http",
      "url": "https://api.reflectmemory.com/mcp",
      "headers": {
        "Authorization": "Bearer YOUR_AGENT_KEY"
      }
    }
  }
}

Get your agent key from your dashboard (API Keys section). Restart Cursor after saving.

Tools (22)

Reads default to everything the caller can see: personal, organization, and sub-team. Pass scope to narrow.

• read_memories - recent memories (full content)
• get_memory_briefing - identity, tag index, open threads, Ambient preference
• get_memory_by_id - full memory by UUID
• get_latest_memory - most recent memory, optional tag filter
• browse_memories - summaries without content
• search_memories - search title and content
• get_memories_by_tag - full memories matching any tag
• list_projects - project folders you can access
• file_memories_in_project - move existing memories into a folder
• write_memory - create a top-level memory (personal unless you set a share scope or folder)
• update_memory - replace a memory you authored and keep version history
• delete_memory - soft-delete (recoverable from trash)
• write_child_memory - reply on a thread (one level deep)
• read_thread - parent plus replies
• get_graph_around - parent, children, siblings, and nearby memories
• get_topic_cluster - recent memories for a topic tag
• read_org_memories - organization pool
• read_team_memories - sub-team pool only
• share_memory - share to org (default) or team
• retrieve_relevant_memories - Ambient On: pull a relevant block before answering
• capture_session_memories - Ambient On: write durable facts; Ambient Off: stage them
• suggest_memories - Ambient Off: stage candidates for approve, edit, or reject

All tools are scoped to the authenticated user. Sharing tools need an organization. Sub-team tools need a team assignment. See Sharing.

Integrations

• ChatGPT Custom GPT (per-user OAuth): Use our ready-made Reflect Memory GPT. Each user authenticates individually via OAuth 2.1 - no shared API keys. 17 OpenAPI operations covering read, write, update, delete, search, browse, tags, latest, versions, threads, briefing, query, identity, and organization share.
• Claude (native connector): Go to Claude.ai Settings, Connectors, click +, paste https://api.reflectmemory.com/mcp as the URL, and click Add. Claude discovers all 22 memory tools automatically via OAuth. No extension or downloads needed.
• Cursor (remote MCP): Add a .cursor/mcp.json file to your project with the MCP URL and your agent key as a Bearer token header. Cursor discovers all 22 memory tools automatically. No npm install or local server needed.
• Grok: Add Reflect as a remote MCP tool with the same URL and a Bearer agent key. Grok discovers the memory tools from that server.
• Other MCP clients: Any client that speaks streamable HTTP can use the same URL and Bearer key. A browser extension for clients that cannot attach a remote MCP server is not available yet.

Setup guides: /integrations

Sharing

New memories are personal. Sharing is explicit, and a memory lives in one pool at a time.

• Organization - company-wide. MCP: read_org_memories and share_memory with scope org (the default).
• Sub-team - one team inside the org. MCP: read_team_memories and share_memory with scope team.

Calling share_memory again with the other scope moves the memory. It does not appear in both pools.

The ChatGPT paths GET /agent/team/memories and POST /agent/team/share use the organization pool. The path name is older than the org and sub-team split. Sub-team sharing is available through MCP.

Team is $200/month with unlimited members and 10 API keys for the team. The 30-day trial requires a card and is not charged until it ends. If the trial ends without payment, the org becomes read-only: existing memories stay readable, and new shares pause. Nothing is deleted.

Project folders

Folders sit under personal, organization, or sub-team scope. Each folder has a stable proj_ tag that does not change when you rename the folder.

• list_projects lists folders you can read and write.
• Pass project (tag, name, or id) on write, search, browse, retrieve, and capture.
• file_memories_in_project moves existing memories into a folder without rewriting the text.

An organization or sub-team folder shares the memory into that pool unless you set a different share scope.

Self-Hosted / Private Deploy

Run Reflect Memory on your own infrastructure so data stays on your machine or private network. Hosted, isolated-hosted, and self-host options are available - see deployment architecture.

Private deploy packages, install guides, and networking recipes are delivered under NDA for active evaluations - not via a public GitHub clone. Contact vm@reflectmemory.com or start from Enterprise.

Data Model

Each memory has:

• id: UUID
• title: Short descriptor
• content: Full text
• tags: Array of strings
• memory_type: "semantic", "episodic", or "procedural"
• origin: Which AI/service wrote it (chatgpt, claude, cursor, etc.)
• allowed_vendors: Which AI tools can see it (["*"] = all)
• parent_memory_id: Set on a reply. Empty on a top-level memory.
• created_at, updated_at: ISO 8601 timestamps
• version: Integer, auto-incremented on every edit (version history)

Version History

Every edit creates a new version. The dashboard shows a full diff history for each memory, and you can restore any prior version. Versions are also accessible via the REST API at GET /memories/:id/versions.

Memory Types

Memories can be classified into three types to improve retrieval and context:

• semantic: Facts, knowledge, and general information (default)
• episodic: Events, experiences, and decisions tied to specific moments
• procedural: Workflows, patterns, and how-to knowledge

Support

Documentation: this page. Privacy: /privacy. Terms: /terms. Support: vm@reflectmemory.com.