Power your agent
การติดตั้งจากผู้เผยแพร่ ไม่ใช่เอนด์พอยต์ของ PlugMCP
URL แบบรีโมตหรือคำสั่งบนเครื่องของคุณ? การติดตั้งสองแบบต่างกันอย่างไร
รันบน PlugMCP
A new server you create. It is not this listing's official endpoint. Use the publisher install when you want their URL and their credentials.
เปิดA self-hosted MCP memory server for trustworthy agent memory: hybrid semantic + keyword search, provenance, lifecycle controls, supersession, and durable recall. Deploy to Cloudflare Workers, run locally without any cloud dependencies, or self-host with Docker.
Not affiliated with Microsoft Windows Recall. This is an open-source memory server for AI coding assistants (Claude Code, Cursor, Windsurf, Cline, Claude Desktop, anything speaking MCP).
Give Claude, Cursor, Windsurf, or any MCP-compatible client a persistent memory that survives across sessions, projects, and devices. No SaaS, no per-token fees, no data leaving your infrastructure. Your Cloudflare account, your data, your rules.
Who is this for? Developers using AI coding assistants who are tired of re-explaining context every session. Teams who want a shared knowledge pool their agents can actually use. Anyone who wants memory without paying a subscription or shipping prompts to a third party.
flowchart TD
subgraph Clients
CC["Claude Code / Codex\n/ Cursor / Windsurf"]
end
subgraph CF["☁️ Cloudflare Workers"]
CFW["Worker"]
D1[("D1 SQLite")]
VEC[("Vectorize 1024D\nbge-m3")]
WAI["Workers AI"]
CFW --> D1
CFW --> VEC
CFW --> WAI
end
subgraph Local["💻 Local stdio (no cloud)"]
LST["stdio server"]
LSQL[("SQLite +\nsqlite-vec 1024D")]
LEMB["HF Transformers\nbge-m3"]
LST --> LSQL
LST --> LEMB
end
subgraph Docker["🐳 Docker HTTP"]
DSV["HTTP server"]
PG[("Postgres +\npgvector 1024D")]
DEMB["HF Transformers\nbge-m3"]
DSV --> PG
DSV --> DEMB
end
CC -->|"HTTP /mcp"| CF
CC -->|"stdio"| Local
CC -->|"HTTP :8788"| Docker
Three backends. Same tool surface. Choose what fits your infra:
Memory portability between backends: All three backends use the bge-m3 model (1024D embeddings). Local and Docker backends run the Xenova ONNX export with CLS pooling to match the reference recipe. Vector compatibility across backends is close in practice — semantic search works cross-backend — but exact bit-for-bit portability is not yet verified with an end-to-end smoke test. If strict portability matters, test your workload before migrating.
Most MCP memory servers do one of two things: dump text into SQLite with cosine similarity, or call a hosted vector DB. Recall does both — at the same time — and reranks the combined results with a cross-encoder.
source_type, URL/path/title/hash), confidence, verification time, expiration, and status make retrieved memories auditable instead of context-free snippets.episodic (7d, session events), semantic (69d, facts/concepts), procedural (693d, stable rules/credentials). Episodic context ages out fast; architecture decisions stay relevant for years. Tier design inspired by NornicDB.get_related_memories to find contextually adjacent knowledge without re-querying.*.workers.dev subdomain on signup, and Recall deploys to that by default. See Custom domain (optional) if you want a vanity URL.Total cost for personal use: $0. Recall runs entirely within Cloudflare's free tier for Workers, D1, Vectorize, and Workers AI. See Costs for limits and real-world usage profiles.
The easiest way: paste this into Claude Code.
Fetch https://raw.githubusercontent.com/cashcon57/recall/v1.1.3/SETUP_PROMPTS.md using Bash (curl -fsSL) so you get the raw markdown, not a summary. Verify it contains a section titled "Prompt 0 — First-time setup". Execute that section verbatim, step by step, adapted and optimized for my current project. Do not summarize. Do not skip. If the fetch fails or the section is missing, stop and tell me.
Claude becomes the setup wizard: inspects your project, checks your environment, walks you through Cloudflare signup if you don't have an account, handles the Workers AI terms page, deploys the worker tuned for how you actually work, wires Recall into your MCP client config, and runs a full functional smoke test (hybrid search, reranker, security gates, auth). It asks how you want to organize memory across your projects before touching anything, so a solo dev with one repo and a team with ten repos get different setups tailored to them. At the end, it prints a report showing exactly how your install was adapted.
No reading required. No copy-pasting commands. The command is pinned to the v1.1.3 release tag so it behaves identically every time.
Want to read what Claude will actually do? See SETUP_PROMPTS.md — including a short "Why is the one-liner written that way?" explainer covering the four levers (pinning, explicit tool, integrity check, verbatim execution) that make the command deterministic.
Prefer to run the script yourself?
git clone https://github.com/cashcon57/recall.git
cd recall
./setup.sh
wrangler.toml with the generated IDimportance and authorMEMORY_API_KEY and upload it as a secretchmod 600 file (.recall-api-key) so it doesn't land in your terminal scrollbackRetrieve the key with cat .recall-api-key, move it into a secret manager, then rm .recall-api-key.
No Cloudflare account needed. Runs fully offline after the first model download.
sqlite-vec native extension for your platform (releases)# 1. Clone and enter the local directory
git clone https://github.com/cashcon57/recall && cd recall/local
# 2. Install dependencies
npm install
# 3. Build
npm run build
# 4. Download sqlite-vec extension for your platform
# macOS (Apple Silicon):
curl -L https://github.com/asg017/sqlite-vec/releases/latest/download/sqlite-vec-macos-arm64.tar.gz | tar xz
# macOS (Intel):
# curl -L https://github.com/asg017/sqlite-vec/releases/latest/download/sqlite-vec-macos-x86_64.tar.gz | tar xz
# Linux (x86_64):
# curl -L https://github.com/asg017/sqlite-vec/releases/latest/download/sqlite-vec-linux-x86_64.tar.gz | tar xz
# 5. Test
echo '{"jsonrpc":"2.0","id":1,"method":"initialize","params":{"protocolVersion":"2025-06-18","capabilities":{},"clientInfo":{"name":"test","version":"1"}}}' | \
RECALL_DB_PATH=~/.recall/recall.db node dist/local/src/server.js
Add to your MCP client config (copy from examples/mcp-config-local.json):
{
"mcpServers": {
"recall-local": {
"command": "node",
"args": ["/absolute/path/to/recall/local/dist/local/src/server.js"],
"env": {
"RECALL_DB_PATH": "/Users/<you>/.recall/recall.db",
"SQLITE_VEC_PATH": "/absolute/path/to/recall/local/sqlite-vec"
}
}
}
}
Note: The first
retrieve_memoryorstore_memorycall downloads the bge-m3 model (~570MB) from HuggingFace. Subsequent calls use the local cache. better-sqlite3 appends the platform extension (.dylib/.so) toSQLITE_VEC_PATHautomatically — omit the extension in the config.
No Cloudflare account needed. Requires Docker and Docker Compose.
# 1. Clone
git clone https://github.com/cashcon57/recall && cd recall
# 2. Start Postgres + Recall server
cd docker
MEMORY_API_KEY=your-secret-key docker compose up -d
# 3. Verify
curl -s -X POST http://localhost:8788 \
-H "Authorization: Bearer your-secret-key" \
-H "Content-Type: application/json" \
-d '{"jsonrpc":"2.0","id":1,"method":"tools/list","params":{}}' | jq '.result.tools | length'
# Expected: 10
# 4. Tear down (keeps data in pgdata volume)
docker compose down
Add to your MCP client config (copy from examples/mcp-config-docker.json):
{
"mcpServers": {
"recall-docker": {
"url": "http://localhost:8788",
"headers": {
"Authorization": "Bearer your-secret-key"
}
}
}
}
.mcp.json)Create or edit .mcp.json in your project root with the actual worker URL and API key hardcoded (not env var substitution). Gitignore this file so the key stays local.
{
"mcpServers": {
"recall": {
"type": "http",
"url": "https://your-worker.workers.dev/mcp",
"headers": {
"Authorization": "Bearer your-api-key-here"
}
}
}
}
That's it. No source .env, no export, no shell setup. Claude Code reads .mcp.json on startup and connects automatically, just like every other MCP server.
claude_desktop_config.json)Claude Desktop doesn't currently support direct HTTP transports, so bridge it through mcp-remote:
{
"mcpServers": {
"recall": {
"command": "npx",
"args": [
"-y",
"mcp-remote",
"https://your-worker.workers.dev/mcp",
"--header",
"Authorization: Bearer your-api-key-here"
]
}
}
}
Config file locations:
~/Library/Application Support/Claude/claude_desktop_config.json%APPDATA%\Claude\claude_desktop_config.jsonUse the same HTTP config shape as Claude Code, in your editor's MCP config file. See your editor's docs for the exact path.
The default https://recall.<your-subdomain>.workers.dev/mcp URL works perfectly and requires no domain. If you want a nicer URL like https://memory.yourdomain.com/mcp:
Step 1 — Add your domain to Cloudflare (if it's not already). Follow their add-a-site flow. You'll update your registrar's nameservers — one-time DNS move.
Step 2 — Add a route in wrangler.toml:
[[routes]]
pattern = "memory.yourdomain.com/*"
zone_name = "yourdomain.com"
custom_domain = true
Step 3 — Redeploy: npx wrangler deploy. Cloudflare issues the TLS cert automatically.
Recall supports both Claude Code and Codex CLI. The session-start instructions differ slightly:
Codex setup: Copy examples/AGENTS.md to your project root (or append to your existing AGENTS.md).
Here's what using Recall looks like in practice. Say you're debugging a citext extension issue on Neon Postgres:
Session 1 — You explain it once to Claude, Claude writes it down:
You: The auth migration is failing because we didn't install citext before adding the email column. Now Neon is rejecting the migration on the pooled connection.
Claude: [Calls
store_memory]{ "key": "neon-citext-migration-order", "content": "citext extension must be installed BEFORE creating columns of type citext. Pooled Neon connections silently reject the migration if the order is reversed. Run `CREATE EXTENSION citext;` in a separate migration, let it commit, then add the column in the next.", "tags": ["database", "neon", "postgres", "migration", "gotcha"], "importance": 0.85, "author": "you" }Noted. I'll remember this for future migrations.
Session 2 — Three weeks later, different project, Claude recalls it automatically:
You: I'm adding case-insensitive username lookup to the new service. Any gotchas?
Claude: [Calls
retrieve_memorywith query "case insensitive text columns postgres"]Yes — there's a recorded gotcha from 3 weeks ago about citext on Neon. You need to install the extension in a separate migration BEFORE adding any citext columns, otherwise pooled connections silently reject the migration. Want me to structure the migration that way?
The memory is reranked by relevance, recency, and importance, so old-but-critical gotchas keep surfacing even as you accumulate thousands of entries.
All tools are callable via the standard MCP tools/call method.
Namespaces isolate memories per project or scope. A memory stored with namespace: "project-alpha" is only returned when the search/list call passes that same namespace. Memories stored without a namespace are global — they appear in un-filtered queries but are excluded when a namespace filter is active.
{ "name": "store_memory", "arguments": {
"key": "auth-flow", "content": "...", "author": "cash",
"namespace": "project-alpha"
}}
{ "name": "retrieve_memory", "arguments": {
"query": "auth token expiry", "namespace": "project-alpha"
}}
Format: alphanumeric, hyphens, underscores, dots (same as key). Max 128 chars.
store_memory example{
"name": "store_memory",
"arguments": {
"key": "postgres-migration-gotcha",
"content": "The citext extension must be installed BEFORE creating columns of type citext, otherwise the migration silently fails on some pooled Neon connections.",
"tags": ["database", "neon", "gotcha"],
"importance": 0.8,
"author": "alice"
}
}
retrieve_memory example{
"name": "retrieve_memory",
"arguments": {
"query": "neon case insensitive text columns",
"limit": 5,
"min_importance": 0.5
}
}
Results are ranked by:
0.5 × reranker_score (bge-reranker-base, sigmoid-normalized)0.3 × recency_decay (exp(-0.001 × hours_since_last_access))0.2 × importance (author-assigned 0–1)Recall supports two team modes. The wizard in SETUP_PROMPTS.md lets you pick either during Phase 2 scoping.
Everyone points at one worker, shares one API key, and distinguishes contributions via the author field on each memory. Team retrieves default to the pooled store; personal focus comes from filtering by author.
There is one API key. Teammates can read, overwrite, and delete each other's memories. Author is a convention, not access control. Don't store secrets. Don't store anything one teammate should keep private from another.
Good for: solo devs collaborating occasionally, small teams that trust each other completely, any setup where "everyone can see everything" is fine.
This is the only option that gives enforced privacy between teammates. Deploy two or more Recall instances on the same Cloudflare account:
Each teammate's .mcp.json has two server entries — recall-team and recall-personal — with different URLs and different env vars. The team URL is the same for everyone; the personal URL differs per teammate. When Claude retrieves, it queries both servers and merges the results. Personal entries override team conventions for that user only.
This is the setup where "Alice tells Claude to do X and Bob tells Claude to do Y without conflicting" is actually true — because each personal pool is a literally different database with a different key.
How to pick: if you have collaborators and want real privacy for personal preferences, pick mode 2. Otherwise mode 1 is simpler and fine. Cost is the same either way ($0/month on Cloudflare's free tier for typical use).
See TEAM_USAGE.md for full team setup, conventions, privacy tradeoffs, and per-project CLAUDE.md templates your agents can follow. The Claude Code setup wizard (via the one-liner at the top of this README) walks you through both modes interactively.
Once Recall is connected, your existing CLAUDE.md, scattered gotchas.md / notes.md files, and built-in agent memory start duplicating what Recall can now do on demand. Cleanup is optional but recommended. Claude Code can do it for you in one shot.
Keep in CLAUDE.md (paid on every turn, so it should stay small):
src/components/")Move to Recall (paid only when relevant):
Delete from both (derivable from the code itself):
package.json)git blame or grep could answerA 4 KB CLAUDE.md costs about 1,000 tokens on every single turn. At 300 turns per day that's 300K tokens of CLAUDE.md you're paying for, most of it irrelevant to the current task. Shrinking to 1 KB of always-on rules and moving the situational 3 KB into Recall saves roughly 225K tokens per day. You lose nothing, because retrieve_memory surfaces the relevant entries when they actually matter.
Paste this into Claude Code, running in the project you want to clean up:
I just connected the `recall` MCP memory server to this project. I want you
to migrate my existing context files into Recall so I stop paying tokens on
stale context every turn. Do this carefully, one file at a time, and ask me
before deleting anything.
1. Verify `recall` is connected. Run /mcp or list_memories. If it's not
connected, stop and tell me how to fix it before continuing.
2. Find all local context files in this repo and my home directory that
might overlap with Recall:
- CLAUDE.md (project root, any subdirectories, and ~/.claude/CLAUDE.md)
- Any gotchas.md, notes.md, decisions.md, architecture.md, lessons.md,
context.md, or similarly named files in the repo
- ~/.claude/projects/<this-project>/memory/ if it exists
List them and the size of each. Ask me to confirm the list before proceeding.
3. For each file, read it and categorize every section or bullet point into
one of three buckets:
a) KEEP IN CLAUDE.md — always-on conventions, build commands, hard rules,
one-paragraph project orientation. Small, stable, applies to every turn.
b) MOVE TO RECALL — gotchas, bug root causes, architectural decisions and
their reasoning, "don't do X because Y" rules, subtle API behavior,
past-tense stories. Situational.
c) DELETE — derivable from the code (file paths, function signatures, tech
stack lists), duplicated elsewhere, or stale.
4. Show me the categorization as a table or list BEFORE making any changes.
Let me correct misclassifications. Do not touch any file until I approve
the plan.
5. Once I approve:
- For each MOVE TO RECALL item, call `store_memory` with a descriptive
kebab-case key, appropriate tags (architecture, gotcha, decision, etc.),
importance between 0.5 and 0.9 based on how load-bearing the info is,
and author set to my handle (ask me what to use).
- After each store_memory, tell me the key you used so I can track it.
- Do NOT batch store_memory calls. One at a time so I can interrupt if
something looks wrong.
6. Rewrite CLAUDE.md with only the KEEP items. Aim for under 1 KB if possible.
Preserve any existing "Memory Usage (recall MCP server)" section at the
bottom.
7. For files being fully deleted (gotchas.md etc.), show me a diff preview
and ask for confirmation before `rm`.
8. Report the before/after CLAUDE.md size, the number of memories stored in
Recall, and any files deleted. Estimate the tokens-per-turn saved.
Important rules:
- Never delete a file you haven't fully migrated first.
- Never store secrets in Recall (API keys, passwords, private keys). Skip
those items and warn me if you see any in the source files.
- If an item could belong in both buckets (conventions with historical
context), prefer CLAUDE.md if it's short and always-on, Recall if the
historical context is the point.
- Skip `~/.claude/projects/<project>/memory/` for now. That's Claude Code's
built-in per-project state and overlaps differently.
This is a destructive operation. Review the agent's categorization table before approving step 5. If you're nervous, start with a single file (e.g., just gotchas.md) and run the prompt repeatedly.
See SETUP_PROMPTS.md for additional prompts covering deploy, agent wiring, and team onboarding.
porter unicode61 tokenizer for BM25 keyword searchkey, with metadata for importance, author, tags@cf/baai/bge-m3K = 60@cf/baai/bge-reranker-base (content truncated to 512 chars — 10-50x token savings)accessed_at / access_count for returned results, debounced to 1 hourstore_memory runs the D1 insert, FTS5 sync, and Vectorize upsert in parallel — independent operations, roughly 2x faster than sequential.
Runs every Sunday at 03:00 UTC by default (0 3 * * SUN). Scans up to 200 memories, finds pairs above similarity_threshold (default 0.82) and entries with zero accesses older than stale_days (default 60). Stores a markdown report as a searchable memory under the key _system.consolidation-report. Never modifies or deletes memories automatically — the report is a recommendation for humans or agents to act on.
Tune the schedule in wrangler.toml.example [triggers] section.
All three backends implement the same RecallAdapter interface (src/adapter.ts), exposing identical MCP tool surfaces. The differences are infrastructure and embedding model:
src/adapters/cloudflare.ts) — wraps D1, Vectorize, Workers AIlocal/src/adapter.ts) — wraps better-sqlite3, sqlite-vec, HuggingFace Transformersdocker/src/adapter.ts) — wraps Postgres/pgvector, HuggingFace Transformers/mcp, HMAC-SHA256 constant-time compare (no timing side channels)clear_memories requires explicit ALLOW_DESTRUCTIVE_TOOLS=true secret. A leaked API key cannot wipe your store in one call.MEMORY_API_KEY is under 32 chars; returns HTTP 503 if missing entirely{ status: 'ok' } only. No version or service name leak.For the full threat model, hardening checklist, and vulnerability disclosure process, see SECURITY.md.
Recall uses one secret — MEMORY_API_KEY — to authenticate MCP clients. The setup script handles it automatically on first deploy. For rotation, multi-environment setups, and local dev, the common commands are:
# Set (prompts for value — does NOT appear in shell history)
npx wrangler secret put MEMORY_API_KEY
# List (shows names only; values are unrecoverable after set)
npx wrangler secret list
# Delete
npx wrangler secret delete MEMORY_API_KEY
# Rotate: generate new key, push to worker, update all clients
NEW_KEY=$(openssl rand -hex 32)
echo "$NEW_KEY" | npx wrangler secret put MEMORY_API_KEY
# (Old key stops working immediately; coordinate with clients.)
Local dev (for wrangler dev) reads secrets from .dev.vars, which is git-ignored by default:
# .dev.vars
MEMORY_API_KEY=local-dev-key-doesnt-need-to-be-secure
Multiple environments (--env staging, --env production) each have separate secret stores. Add [env.staging] blocks to wrangler.toml and use wrangler secret put MEMORY_API_KEY --env staging.
Where secrets live: Deployed secrets are encrypted by Cloudflare, injected as env vars at runtime, never visible in the dashboard, API, or wrangler tail. .dev.vars is plaintext on your disk, never uploaded. Secrets never belong in wrangler.toml, git, or console.log.
If you accidentally commit a secret, rotate it immediately and treat the old value as compromised.
Recall follows semver. Check releases for each version's notes — release notes include a per-version Update section with the exact commands for each backend. Generic flow:
# 1. Pull the latest code
git pull origin main
# 2. Apply any new D1 migrations (idempotent per file, but ALTER TABLE errors on re-run)
# Check migrations/ for anything newer than your last update.
wrangler d1 execute <your-db-name> --remote --file=migrations/NNNN_whatever.sql
# 3. Deploy the worker
wrangler deploy
Migrations ship as numbered SQL files in migrations/. Each file adds a schema change (e.g. 0003_namespace.sql). Run only the migrations newer than your current version, in order.
git pull origin main
cd local && npm install && npm run build
The local backend re-applies setup.sql on every start (all CREATE ... IF NOT EXISTS), so schema changes land automatically on the next process launch. No manual migration needed.
git pull origin main
cd docker && docker compose build && docker compose up -d
Postgres keeps its data in the pgdata volume. New schema objects from setup.sql land automatically via docker-entrypoint-initdb.d on fresh installs; existing installs need to run the ALTER TABLE statement from the matching migrations/NNNN_*.sql file manually against the Postgres container:
docker compose exec postgres psql -U recall -d recall -f /path/to/migrations/NNNN_whatever.sql
(Note: SQLite-syntax migrations may need minor syntax tweaks for Postgres — check the migration's comment header for backend-specific instructions.)
Every release from v2.1 onward includes:
npm install
npm run dev # Local dev with wrangler (remote bindings)
npm run typecheck # TypeScript strict mode
npm run tail # Stream production logs
recall/
├── src/
│ ├── index.ts # Worker fetch + scheduled handler, rate limit, auth
│ ├── mcp.ts # JSON-RPC 2.0 / MCP protocol dispatcher
│ ├── tools.ts # MCP tool implementations + search, lifecycle, and consolidation
│ ├── auth.ts # Constant-time HMAC-SHA256 API key verify
│ └── types.ts # Env bindings + domain + JSON-RPC types
├── schema.sql # D1 table + indexes + FTS5 virtual table
├── wrangler.toml.example
├── setup.sh # One-command Cloudflare deploy
└── examples/ # Sample MCP client configs, agent CLAUDE.md template
combinedScore in src/tools.ts:retrieveMemory@cf/baai/bge-m3 with any Workers AI embedding model, update dimensions in wrangler.toml and recreate the Vectorize indexRATE_LIMIT_PER_MIN constant in src/index.tsTOOL_DEFINITIONS and executeTool dispatch in src/tools.tsTL;DR: $0/month for 95% of users. Recall is designed to fit inside Cloudflare's free tier for personal and small-team use.
Neurons are Cloudflare's AI billing unit. Roughly: one embedding via bge-m3 ≈ 2–6 neurons, one rerank pass ≈ 4 neurons.
These are honest estimates, not marketing math.
Profile 1 — Solo dev, casual use ~20 stores + 50 retrieves/day → ~340 neurons/day → $0/mo ✓
Profile 2 — Active solo dev + Claude Code all day ~50 stores + 300 retrieves/day → ~2,300 neurons/day → $0/mo ✓
Profile 3 — 5-person team sharing one instance ~100 stores + 1,000 retrieves/day → ~7,500 neurons/day → $0/mo ✓ (comfortably within free tier)
Profile 4 — Heavy team or automated agent fleet ~500 stores + 5,000 retrieves/day → ~40,000 neurons/day → ~$3–5/month. You've blown through the daily neurons free tier. Everything else is still free. Workers AI overage is $0.011 per 1,000 neurons, so 30K/day × 30 days ≈ $10 worst case.
Profile 5 — Ludicrous (10K+ retrieves/day)
~$20–50/month. Workers AI becomes the dominant cost. Consider: lowering candidateCount from 20 to 10, caching embeddings client-side for repeat queries, or swapping to @cf/baai/bge-small-en-v1.5 (384D) if you don't need multilingual.
The cost nobody mentions: Cloudflare's free tier is per-account, not per-worker. If you already use D1, Vectorize, or Workers AI for other projects, Recall's usage adds to the same daily counters. Usually not a problem, but worth knowing.
No hosted tier, no subscription. You are the host.
Do I need a domain?
No. Cloudflare gives every worker a free *.workers.dev subdomain. A custom domain is purely cosmetic.
Do I need to pay Cloudflare? No, for typical personal and small-team use. See Costs.
How does this compare to Anthropic's built-in memory? Recall is self-hosted, works with any MCP client (not just Claude.ai), supports teams with a shared instance, and uses a richer retrieval pipeline (hybrid search + cross-encoder reranker). Anthropic's memory is simpler and tied to their platform. Use whichever fits.
Can I use it without Claude? Yes. Any MCP-compatible client works — Cursor, Windsurf, Cline, your own code via the MCP TypeScript/Python SDK.
What happens if Cloudflare goes down? Your memories are unavailable until it comes back up. D1 is replicated within Cloudflare's storage layer, so durability is high, but availability is tied to CF. For true HA you'd need to replicate across providers — Recall doesn't do this out of the box.
Can I export my memories?
Yes. npx wrangler d1 export recall --output=backup.sql. This gives you a SQLite dump you can import elsewhere.
What embedding model is best for non-English?
bge-m3 (the default) is multilingual and works well for most languages. If you only need English, bge-small-en-v1.5 is smaller and cheaper — swap it in src/tools.ts and recreate the Vectorize index with dimension 384.
Why Cloudflare as the default backend?
Cloudflare gives Recall four things that matter: D1 (SQLite with FTS5 built in), Vectorize (managed 1024D index with metadata filters), Workers AI (free-tier bge-m3 + bge-reranker-base embeddings and reranking), and Workers itself (sub-10ms cold start, generous free tier, no container to maintain). Putting all of that on one vendor is what makes it $0/month, one-command install, and zero ops for the 95% use case.
Can I run Recall outside Cloudflare Workers?
Yes, since v2.0.0. Two alternative backends ship in the same repo: a local stdio server (better-sqlite3 + sqlite-vec, fully offline) and a Docker HTTP server (Postgres + pgvector). All three backends implement the same RecallAdapter interface and expose the same MCP tool surface. See Deployment Options for the matrix.
But I'm still nervous about Cloudflare having my memories. Worth saying clearly: on the CF backend, Recall runs on YOUR Cloudflare account, not a shared service. The code is MIT, the worker is deployed under your own CF credentials, the D1 database lives in your account, the API key is yours, and the data never leaves your CF tenant. It's self-hosted in the same sense that running Postgres on AWS RDS is self-hosted — Cloudflare is the substrate, not the vendor you're sharing data with. If that's still not sufficient (auditability, compliance, or you just don't trust CF specifically), use the local stdio or Docker backend — both run without any cloud dependencies.
Is this production-ready?
For personal and small-team use, yes. For mission-critical multi-tenant SaaS, no — each Recall instance is single-tenant by design and has no per-user access control within an instance. See SECURITY.md for the full threat model.
Can two teammates have different personal preferences without conflicting? Yes, with option F in the setup wizard: "team + per-user personal pool". Deploy one shared team instance plus one personal instance per teammate. Each personal instance has its own API key only that teammate has. Claude queries both servers on retrieve and merges the results. Personal preferences override team conventions for that user only. This is the only configuration where cross-teammate privacy is enforced by code, not convention. See the Team usage section above for full details, or just paste the one-line install prompt at the top of this README and pick option F when asked.
How do I delete a single memory?
delete_memory with the key. The full store wipe (clear_memories) is default-disabled to prevent accidental/malicious bulk deletion.
wrangler: command not found
The setup script uses npx wrangler, so you shouldn't need a global install. If you hit this, run npm install first.
Schema apply hangs
D1 --remote applies can take a few seconds. If it hangs >30s, cancel and retry — Cloudflare API occasionally throttles new accounts.
Embedding generation returned no data
Workers AI throws this when the account isn't subscribed to the AI product. Visit dash.cloudflare.com → AI → Workers AI and accept the terms once.
Vectorize dimension mismatch If you change embedding models, you must delete and recreate the Vectorize index with the new dimension count. Existing vectors won't survive.
MCP client says connection failed
Check: (1) the URL ends in /mcp, (2) the Authorization: Bearer header is present, (3) your API key matches what wrangler secret list shows, (4) the worker is deployed (wrangler tail to confirm).
clear_memories returns "disabled"
This is intentional. Set the secret to enable temporarily, then remove it:
echo "true" | npx wrangler secret put ALLOW_DESTRUCTIVE_TOOLS
# ... run clear_memories ...
npx wrangler secret delete ALLOW_DESTRUCTIVE_TOOLS
PRs welcome. Keep scope tight: this is infrastructure, not a framework. Changes should preserve:
File issues for bugs, feature discussions, or architectural questions.
For security issues, see SECURITY.md.
Recall is free and always will be. If it saves you time and you feel like buying me a coffee, you can do that below. Completely optional, zero pressure — I'm not running a business here. The server is yours, the code is MIT, the coffee is strictly a "thanks if you want to" thing.
MIT. See LICENSE.
Recall was extracted from a private memory server built for real production use. The hybrid search + reranker + recency decay pipeline turned out to generalize well, so here it is.
bge-m3 (embeddings) and bge-reranker-base (cross-encoder). These do most of the heavy lifting.Full list in package.json, local/package.json, and docker/package.json.
Self-hosted MCP memory server with hybrid semantic + keyword search on Cloudflare Workers
เครื่องมือ
ยังไม่มีรายการเครื่องมือ เซิร์ฟเวอร์แบบรีโมตจะได้รายการหลังการตรวจสอบสถานะครั้งแรก
FAQ
คัดลอกคอนฟิก stdio สำหรับ Cursor, Claude Desktop, Claude Code หรือ VS Code ได้ในหน้านี้ คอนฟิกนี้ใช้การติดตั้งของผู้เผยแพร่ ไม่ใช่พร็อกซีของ PlugMCP
ระเบียนนี้ไม่ได้ระบุตัวแปรสภาพแวดล้อมที่จำเป็น
Recall ทำงานแบบโลคัลผ่าน stdio
ตรวจสอบล่าสุดเมื่อ 2026-10-28 Self-hosted MCP memory server with hybrid semantic + keyword search on Cloudflare Workers