Your memory inside every AI tool

One command gives Claude Code, Claude Desktop, Cursor, or any MCP host a long-term memory backed by your WOS account. No integration code - the agent gets nine memory tools and decides when to use them.

Install

Claude Code - one line (create a key in the console first):

claude mcp add wontopos --env WONTOPOS_API_KEY=wos-live-... -- npx -y wontopos-mcp
# pick which store it remembers into (optional): add --env WONTOPOS_USER_ID=my-project

# ~/.cursor/mcp.json
{ "mcpServers": {
    "wontopos": {
      "command": "npx",
      "args": ["-y", "wontopos-mcp"],
      "env": { "WONTOPOS_API_KEY": "wos-live-...",
               "WONTOPOS_USER_ID": "my-project" }
    } } }

# .vscode/mcp.json
{ "servers": {
    "wontopos": {
      "command": "npx",
      "args": ["-y", "wontopos-mcp"],
      "env": { "WONTOPOS_API_KEY": "wos-live-...",
               "WONTOPOS_USER_ID": "my-project" }
    } } }

# ~/.codeium/windsurf/mcp_config.json
{ "mcpServers": {
    "wontopos": {
      "command": "npx",
      "args": ["-y", "wontopos-mcp"],
      "env": { "WONTOPOS_API_KEY": "wos-live-...",
               "WONTOPOS_USER_ID": "my-project" }
    } } }

# Claude Desktop and any other MCP host
{ "mcpServers": {
    "wontopos": {
      "command": "npx",
      "args": ["-y", "wontopos-mcp"],
      "env": { "WONTOPOS_API_KEY": "wos-live-...",
               "WONTOPOS_USER_ID": "my-project" }
    } } }

Add to Cursor →  ·  Add to VS Code →

Optional env: WONTOPOS_USER_ID picks the default store, WONTOPOS_MODEL the engine, WONTOPOS_BASE_URL a different API host. WONTOPOS_READ_ONLY=1 switches to read-only (recall/search/list only).

Before you share one store

• Use a dedicated key. Keys carry their workspace, so a key made just for MCP scopes what connected tools can ever touch - and you can rotate it in the console without touching your app's keys.
• Read-only mode. WONTOPOS_READ_ONLY=1 registers no write tools at all: the agent can recall, search, list memories, run engrams, and read stats, but cannot store, update, forget, or delete. Right for agents that should consult memory, not own it.
• Keep tool confirmation on. MCP hosts ask before running tools by default - leave that on for forget in particular, since deletes are shared by every tool on the store.
• Anything stored is recallable by every tool holding the key. Never store secrets - API keys, passwords - as memories.
• Recalled memories are data, not instructions. The tool descriptions tell the agent this explicitly. Still, don't store untrusted third-party text as memories in a store an autonomous agent obeys.
• Deletes are shared too. A forget or delete_all from one tool erases for all of them.
• "me" means whichever agent writes the store. If several agents share one store, their "me" voices merge. Give each agent its own store (WONTOPOS_USER_ID) for separate identities.
• One account pays. Every connected tool draws from the same balance and rate limit.

Then just talk

Things to say

• "This repo uses pnpm, remember that" → remember stores it; the next session already knows.
• "What error format did we settle on last week?" → recall pulls the decision back into context.
• "Actually, the deadline moved to Friday" → the agent sees it contradicts what it recalled and calls update to fix that memory in place, keeping the history.
• "That's wrong, forget it" → the agent finds the memory id and calls forget - your host asks for confirmation first.
• "What do you remember about me?" → list_memories pages through everything stored, so the agent can answer or tidy up.

There is nothing special to phrase - these are plain sentences, not commands. The agent reads each tool's description and picks on its own.

The nine tools

• recall - One-call context: recent turns plus relevant long-term memories. Its description tells the agent to call it first whenever past context matters.
• remember - Store a durable fact or decision. speaker: "me" marks the agent's own words; a registered name marks who said it.
• search - Semantic search, with an optional per-person speaker filter — and filters to bound it by TIME or topic ("what did we decide in June?"), the one axis meaning alone cannot narrow.
• update - Supersede a memory whose fact changed, keeping the trail instead of deleting it.
• forget - Delete one memory by id.
• list_memories - Page through everything stored, so the agent can answer "what do you remember about me?" or tidy up.
• engram - Run a built-in multi-hop pipeline (deep_recall, timeline, gather) when one search is not enough.
• stats - How much is in a store - useful before a cleanup, and to confirm a write landed.
• create_store - Stores are explicit - one per end-user, project, or agent.

SDK or MCP?

• The SDK goes inside an app you are writing. Your code decides exactly when to store and what to recall - deterministic, typed, versioned. Building a product? Use the SDK.
• MCP plugs into an AI tool you did not write. The agent decides when to use memory, guided by the tool descriptions - zero code. Right for Claude Code, Claude Desktop, Cursor, or giving a finished assistant a memory.

Same API, same stores underneath - an app built on the SDK and a Claude Code session on MCP share one memory. Pick per surface, not either-or.

One memory across every tool

Memory belongs to the account, not the tool. The same store written from ChatGPT (Actions plus the OpenAPI spec) recalls in Claude Code and in your own agents, and back - a conversation started in one tool continues in another.

And because it is one store, you can leave Claude Code and keep talking where you build: an SDK agent with the same key and store recalls everything Claude Code just learned - and what your agent stores, Claude Code recalls next session.

MCP - memory for AI tools

The core of WOS is the API and SDKs. The MCP server is an add-on on top of them: the same memory, plugged into tools you did not build - Claude Code, Claude Desktop, Cursor.

One install line gives the agent nine memory tools it uses on its own. And because memory lives in your account, what one tool writes, every other tool recalls - including agents you build on the SDK.

What you can do with it

• Claude Code that remembers your project. Decisions, bug fixes, preferences - recalled next session without re-explaining anything.
• Start in ChatGPT, continue in Claude. Same store, same memory - the conversation crosses tools instead of restarting.
• Your own agent stays in the loop. What Claude Code learns, an SDK agent recalls - and what your agent stores, Claude Code recalls back.

Works in Claude Code, Claude Desktop, Cursor, Windsurf, and any MCP host. ChatGPT reaches the same memory through Actions plus the OpenAPI spec.

Install

claude mcp add wontopos --env WONTOPOS_API_KEY=wos-live-... -- npx -y wontopos-mcp

The agent gets nine tools - recall · remember · search · update · forget · list_memories · engram · stats · create_store - each described so it knows on its own when to use them.

Open the developer page →

Claude Code

The flagship path: one command in your terminal, and every session starts with memory.

1. Create an API key in the console. A key carries its workspace, so one key = one memory space.
2. Register the server. --scope user makes it available in every project; without it, only the current project sees it.
3. Check it: run /mcp inside Claude Code - wontopos should be listed with nine tools.
4. Make it automatic: one line in your CLAUDE.md - "when past context matters, call wontopos recall first" - and every session starts with memory without being asked.

claude mcp add wontopos --scope user \
  --env WONTOPOS_API_KEY=wos-live-... -- npx -y wontopos-mcp
# pick a store (optional): add --env WONTOPOS_USER_ID=my-project

Claude Desktop

Add the block below to claude_desktop_config.json (Settings → Developer → Edit Config), restart the app, and the nine tools appear. Note: claude.ai on the web and mobile needs a remote MCP server, which WOS does not offer yet - the desktop app is the supported path.

# claude_desktop_config.json
{ "mcpServers": {
    "wontopos": {
      "command": "npx",
      "args": ["-y", "wontopos-mcp"],
      "env": { "WONTOPOS_API_KEY": "wos-live-...",
               "WONTOPOS_USER_ID": "my-project" }
    } } }

Cursor

Add the block below to ~/.cursor/mcp.json - or press the one-click button - and restart Cursor. The agent picks up the nine tools.

# ~/.cursor/mcp.json
{ "mcpServers": {
    "wontopos": {
      "command": "npx",
      "args": ["-y", "wontopos-mcp"],
      "env": { "WONTOPOS_API_KEY": "wos-live-...",
               "WONTOPOS_USER_ID": "my-project" }
    } } }

Add to Cursor →

VS Code

VS Code (Copilot agent mode) reads MCP servers from .vscode/mcp.json in the project - add the block below or press the one-click button.

# .vscode/mcp.json
{ "servers": {
    "wontopos": {
      "command": "npx",
      "args": ["-y", "wontopos-mcp"],
      "env": { "WONTOPOS_API_KEY": "wos-live-...",
               "WONTOPOS_USER_ID": "my-project" }
    } } }

Add to VS Code →

Windsurf

Windsurf (Cascade) reads ~/.codeium/windsurf/mcp_config.json: add the block below and reload - the same nine tools appear.

# ~/.codeium/windsurf/mcp_config.json
{ "mcpServers": {
    "wontopos": {
      "command": "npx",
      "args": ["-y", "wontopos-mcp"],
      "env": { "WONTOPOS_API_KEY": "wos-live-...",
               "WONTOPOS_USER_ID": "my-project" }
    } } }

ChatGPT

ChatGPT's MCP connectors only accept remote servers, so the supported path today is a custom GPT with an Action: create a GPT, add an Action, paste the OpenAPI spec URL below, and set your API key as the auth header. The GPT then calls the same memory your other tools use.

# GPT → Configure → Actions → Import from URL
https://api.wontopos.com/openapi.json
# Authentication: API Key · Header name: X-API-Key

Same store, same memory: what ChatGPT stores through the Action, Claude Code recalls through MCP - and back.

Gemini CLI

Gemini CLI reads MCP servers from ~/.gemini/settings.json: add the block below, restart the CLI, and the same nine tools appear there too.

# ~/.gemini/settings.json
{ "mcpServers": {
    "wontopos": {
      "command": "npx",
      "args": ["-y", "wontopos-mcp"],
      "env": { "WONTOPOS_API_KEY": "wos-live-...",
               "WONTOPOS_USER_ID": "my-project" }
    } } }