Recall

MCP文档知识

提供方 未标注

文档知识 HTTP · 远程 API Key 社区 / 第三方 Claude DesktopClaudeCursorVS Code
查看接入方式

为AI代理提供长期记忆:学习关于每个人的带日期的事实,更新变化的事实,并附上来源进行回答。

一句话选型结论

按资料字段整理

Recall 属于文档知识类 MCP 服务器,HTTP · 远程,API Key,可直接接入 Claude Desktop、Claude、Cursor 等,有可直接复制的远程端点配置。接入前先确认权限范围;涉及写入、删除或付款的操作,建议先在测试环境验证。

分类文档知识 传输方式HTTP · 远程 鉴权API Key 部署方式支持远程部署
GitHub 星标 未标注 仓库热度,无公开仓库时显示未标注
工具数 未标注 暴露给模型的工具数量
资源 / 提示词 0 / 0 资源与提示词模板数量
维护方 社区 / 第三方 核验等级 仅资料核对

工具与能力

文档知识
数量来自来源目录的标注,具体工具清单以官方文档为准
工具数量未标注暴露给模型可调用的工具个数
资源数量0可读取的资源条目
提示词数量0内置提示词模板数量

能力标签

支持客户端

适用场景

记忆

安装与配置

HTTP · 远程 API Key
连远程 HTTPS 端点,通常为 Streamable HTTP
npx add-mcp 'https://api.recallmem.dev/mcp'

这条命令只是入口,具体启动参数请按官方文档补齐,不要直接照搬到别的服务器。

  1. 1
    准备运行环境

    确认你的客户端支持远程端点,并拿到服务地址。

  2. 2
    安装服务

    复制上面的安装命令执行;命令里带占位符的位置,换成自己的密钥或路径。

  3. 3
    写入客户端配置

    在客户端的 MCP 配置里填好启动命令和参数,保存后完全退出客户端再打开,让新配置生效。

  4. 4
    验证是否可用

    连接成功后随便调一个只读工具,确认能返回结果,再接入正式流程。

典型使用场景

3 类
按分类与标签整理的常见用法,具体以官方文档为准
文档检索问答

在你的文档库里按问题找答案。

知识库读写

把新资料写进知识库,随用随取。

内容整理

把零散资料归纳成结构化笔记。

选择建议

选之前先看这几条
按条目字段给出的判断,不替你决定用不用

值得选的地方

  • 有现成的安装命令,不用自己找入口,照着跑就能起服务。
  • 已适配 Claude Desktop、Claude、Cursor,换客户端不用重新研究配置。

先想清楚的地方

  • 远程端点依赖网络与服务方可用性,注意密钥与调用额度。
  • 使用前要准备好API Key对应的凭据,并按最小权限配置。
  • 资料没标注工具数量,实际能力要装好后确认。
  • 版本更新与行为细节以官方仓库为准。

更适合

  • 需要在文档知识场景里让模型直接调用外部能力的人。
  • 已经在用 Claude Desktop、Claude 的用户,接入路径最短。
  • 想先快速试一下、能接受在本地或自有环境跑服务的人。

不太适合

  • 不方便管理密钥或第三方授权的人。
  • 需要厂商级 SLA 和技术支持的生产环境。

同类对比

6 个同类
同分类里挑最接近的几条,字段以各自详情页为准
MCP 服务器工具数传输方式部署方式安装命令最后核验
Recall当前 未标注 HTTP · 远程 支持远程部署 有 2026-11-20
dify 未标注 stdio · 本地进程 本地部署 有 2026-04-11
open-webui 未标注 stdio · 本地进程 本地部署 有 2026-04-11
JeecgBoot 未标注 stdio · 本地进程 本地部署 有 2026-04-11
Cherry Studio 未标注 未标注 未标注 无 2026-05-17
mempalace 未标注 stdio · 本地进程 本地部署 有 2026-04-11

服务器档案

文档知识
字段来自项目仓库与公开索引,中文说明由本站标注
提供方未标注上游标注的维护方 未标注
分类文档知识本站按上游分类展示
连接方式HTTP · 远程连远程 HTTPS 端点,通常为 Streamable HTTP
鉴权方式API Key远程服务建议用最小权限凭据
维护方社区 / 第三方核验等级 仅资料核对
包名 / 运行时未标注 · 未标注本地安装时用到的包标识与运行时
部署类型支持远程部署上游给出的部署形态
最近核验2026-11-20上游最后核验时间

详细介绍

14.2 KB
来自项目仓库与上游目录的原文,未做删改

Website ·
Docs ·
Evals ·
Guides ·
Get an API key

Your agents forget. Recall keeps receipts. Recall is long-term memory for AI agents that talk to the
same people again. Send it the conversation; in the background it works out what is true about
each person, keeps a dated, cited record of it, and retires facts that stop being true (when
Alice moves from London to New York, the old address is closed, not contradicted). Ask it a
question and it answers from that record in a single model call, with its sources, or hands you the
context to put in your own prompt. Use the hosted API at recallmem.dev
(hosted in Frankfurt), or run the server in this repository yourself.

Benchmarks

Full runs, every question of each benchmark, on the hosted service at the default reasoning level,
graded the way each benchmark grades itself. The method, the per-ability scores, what failed and
how other systems compare are on recallmem.dev/evals. The
harness that produced them is in evals/, so you can run it against your own deployment.

Show as a table

Benchmark Result 95% interval Questions Graded by
LongMemEval-S 91.0% accuracy 88.2-93.2% all 500 questions official judge
BEAM 100K 0.683 score, 0 to 1 0.653-0.713 all 400 questions BEAM's own scoring
BEAM 500K 0.670 score, 0 to 1 0.643-0.695 all 700 questions BEAM's own scoring

How it works

  1. Send the conversation. One call per turn from the SDK, or a plugin does it for you.
    Workspaces, peers (anyone who speaks) and sessions are created on first use.
  2. Recall learns in the background. It extracts facts about each person with when they became
    true and the messages they came from, closes facts that changed, and keeps a short peer card
    and running session summaries. After a conversation goes quiet, a night shift merges
    duplicates and draws new conclusions.
  3. Ask, or inject context. peer.chat("...") answers with citations, a confidence and an
    explicit "I don't know" when memory has no answer. session.context() returns recent messages,
    the summary and what is known about the person, trimmed to your token budget and ready for
    OpenAI or Anthropic message formats.

Search, MCP tools, webhooks, scopes (groups of sessions), per-peer deletion and data export are
in the docs.

Quickstart (hosted API)

Sign in at app.recallmem.dev with your email, create an API key
under API keys, and export it. New accounts start with free credit.```bash
export RECALL_API_KEY=pk_live_...


**TypeScript** (`npm install @recall-memory/sdk`, Node 20+, no dependencies)```ts
import { Recall } from "@recall-memory/sdk";

const recall = new Recall({ apiKey: process.env.RECALL_API_KEY });
const alice = recall.peer("alice"); // lazy: no request is made
const bot = recall.peer("bot");
const session = recall.session("chat-1");

// One round trip per agent turn: store the message, get the next prompt's context back.
const { context } = await session.turn([alice.message("I moved to New York last month.")], {
  peerTarget: alice,
  tokens: 4000,
});
const messages = context.toOpenAI(bot); // or context.toAnthropicParams(bot)

await recall.waitForIdle(); // background reasoning has caught up
console.log(await alice.chat("Where do I live?")); // "New York"

Python (pip install recall-mem, imported as recall_memory, Python 3.10+)```python
from recall_memory import Recall

recall = Recall(workspace_id="my-app") # reads RECALL_API_KEY; no network call yet

alice = recall.peer("alice") # handles are lazy: no network call
bot = recall.peer("bot")
session = recall.session("chat-1")

session.add_peers([alice, bot])
session.add_messages(
[
alice.message("I moved to New York last month and I love cycling."),
bot.message("New York has great bike lanes!"),
]
)

recall.wait_for_idle() # block until reasoning has finished

print(alice.chat("Where does Alice live?")) # -> "Alice lives in New York."

Build the next prompt: recent messages + what is known about Alice, in OpenAI or Anthropic shape.

ctx = session.context(peer_target=alice, tokens=4000)
messages = ctx.to_openai(assistant=bot) # or ctx.to_anthropic(assistant=bot)


**curl**```bash
export RECALL_URL=https://api.recallmem.dev

curl $RECALL_URL/v3/workspaces/my-app/sessions/chat-1/messages \
  -H "Authorization: Bearer $RECALL_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"messages":[
        {"peer_id":"alice","content":"I moved to New York last month and I am vegetarian now."},
        {"peer_id":"assistant","content":"Noted! New York has great veggie food."}
      ]}'

# Learning runs in the background and usually takes about 20 seconds: new messages are read in
# batches. GET /v3/workspaces/my-app/queue/status?wait_ms=30000 waits until it is done. Then:
curl $RECALL_URL/v3/workspaces/my-app/peers/alice/chat \
  -H "Authorization: Bearer $RECALL_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"query":"What should I cook for Alice?","reasoning_level":"low"}'

The answer carries content, citations, a confidence and abstained. The SDK READMEs
(TypeScript, Python) and the
docs cover streaming, structured answers, search, scopes and
webhooks.

Integrations

Give an agent you already use a memory, without writing code. Each integration's README has the
install steps, its settings and a way to check that it works.

Agent How Where
Claude Code Plugin: recalls what it knows about you when a session starts, records each turn, adds the MCP tools. /plugin marketplace add recallmem/recall-plugin, then /plugin install recall-memory@recall integrations/claude-code
Codex Plugin or installer with the same hooks and tools. codex plugin marketplace add recallmem/recall-plugin, then codex plugin add recall-memory@recall integrations/codex
Claude.ai (web, desktop, mobile) Custom connector: Settings, Connectors, Add custom connector, URL https://api.recallmem.dev/mcp, then sign in docs
ChatGPT Connector in developer mode with the same URL and OAuth sign-in docs
Any MCP client (Cursor, VS Code, ...) Remote MCP server at https://api.recallmem.dev/mcp: OAuth sign-in, or an API key in a header. Eight memory tools by default, all 40 with ?profile=full docs
OpenClaw Native plugin: memory added to each turn, conversations recorded, recall_* tools integrations/openclaw
Hermes Agent Memory provider (memory.provider: recall) with prefetch, turn sync and tools integrations/hermes
Any agent with Agent Skills A SKILL.md that teaches when and how to recall and record, with a helper script integrations/agent-skill

Building on an agent framework? These packages add Recall in a few lines:

Framework Package What you get
Vercel AI SDK @recall-memory/ai-sdk Middleware that adds memory to each request and stores every turn, and memory tools (guide)
LangChain.js @recall-memory/langchain A chat message history in Recall sessions, a retriever and memory tools (guide)
Mastra @recall-memory/mastra A processor that adds memory to each run and stores every turn, and memory tools (guide)

There is also a command-line client, recall (recall init, recall peer chat "Where do I live?",
recall doctor). It comes with the server rather than from npm: it is on the PATH in the Docker image
and at packages/server/dist/cli.js in a build of this repository; see the docs.

Self-hosting

Yes, you can run Recall yourself. The server in packages/server is
source-available (see Licence) and is the one the hosted service runs: REST API,
background worker and MCP endpoint in one Node process (plus the recall CLI), with Postgres and
pgvector as its only dependency. Run it for your own products and company with your own model
provider keys, which you pay the providers for directly; the server meters every call so you can
see what each workspace costs. The hosted API at recallmem.dev is the
easiest path if you would rather operate nothing.

With Docker Compose (Postgres 17 with pgvector, and Recall on port 8000):```bash
git clone https://github.com/recallmem/recall && cd recall
cp .env.example .env # add at least one model provider key; every setting is documented there
docker compose up --build
curl localhost:8000/health


**One container**, with an embedded Postgres (PGlite) kept in the `/data` volume: good for a laptop,
a demo or a small agent.```bash
docker build -t recall-server .
docker run -p 8000:8000 -v recall-data:/data -e OPENAI_API_KEY=... recall-server

From source (Node 22, pnpm 10): pnpm install, then pnpm dev (the server with reload on
port 8000), or pnpm --filter @recall-memory/server build and node packages/server/dist/main.js.
With no database URL it uses the embedded Postgres in ./.recall; any Postgres 16+ with pgvector
works through RECALL_DATABASE_URL.

Point the SDKs at your server with RECALL_URL=http://localhost:8000 (or baseURL / base_url).
Before anyone else can reach it, turn authentication on: RECALL_AUTH_ENABLED=true and a long
random RECALL_AUTH_SECRET, then mint a scoped token with the CLI:
docker compose exec recall recall token --workspace my-app, or from a build,
node packages/server/dist/cli.js token --workspace my-app. A self-hosted server has no sign-in,
dashboard or billing (those are the hosted service's multi-tenant mode); the
docs list the other differences.

Models. With no provider key at all, Recall runs on a deterministic offline mock: the pipeline,
storage, retrieval and metering are real, the answers are canned. That is for trying the API and
for tests. For real answers set one or more provider keys:

Provider Key Model reference
OpenAI OPENAI_API_KEY openai/
Anthropic ANTHROPIC_API_KEY anthropic/
Gemini GEMINI_API_KEY gemini/
OpenRouter OPENROUTER_API_KEY openrouter//
Groq GROQ_API_KEY groq/
xAI XAI_API_KEY xai/
DeepSeek DEEPSEEK_API_KEY deepseek/
Together TOGETHER_API_KEY together/
Fireworks FIREWORKS_API_KEY fireworks/accounts//models/
Any OpenAI-compatible server (Ollama, vLLM, LM Studio, llama.cpp) RECALL_COMPAT_BASE_URL, RECALL_COMPAT_API_KEY compat/

Every task can use a different model, from any provider:

Variable Task
RECALL_MODEL_REASONER Learning: extracting facts from new messages (most of the background cost)
RECALL_MODEL_SUMMARY, RECALL_MODEL_CARD, RECALL_MODEL_DREAM Session summaries, peer cards, the night shift
RECALL_MODEL_CHAT_MINIMAL ... RECALL_MODEL_CHAT_MAX The answering model for each reasoning level
RECALL_EMBEDDING_MODEL, RECALL_EMBEDDING_DIMENSIONS Embeddings (keep them fixed for the life of a database)
RECALL_DEFAULT_PROVIDER The provider for every task you have not set

A task you leave unset gets the cheapest suitable model among the providers that have a key;
recall doctor prints the model each task will use. For example, a small model for the background
work and a local model for quick answers:bash GEMINI_API_KEY=... RECALL_MODEL_REASONER=gemini/gemini-2.5-flash-lite \ RECALL_COMPAT_BASE_URL=http://localhost:11434/v1 RECALL_MODEL_CHAT_LOW=compat/qwen3:8b \ node packages/server/dist/main.js

Answers and memory quality depend on the models you choose: the benchmark figures above were
measured on the hosted service with its own model configuration, and evals/ lets you measure
yours. Costs are recorded per workspace, task and model at GET /v3/workspaces/{id}/usage.

The server is licensed under the Functional Source License: you can
self-host it for any purpose, including in production and inside commercial products, except
offering it to others as a competing memory service. See Licence.

Repository layout

Path What Licence
packages/server The server: REST API, background worker (reasoning, summaries, the night shift), hybrid search and answers, MCP, CLI, dashboard FSL-1.1-ALv2
packages/sdk TypeScript SDK, @recall-memory/sdk MIT
sdks/python Python SDK, recall-mem (import recall_memory) MIT
packages/ai-sdk, packages/langchain, packages/mastra Framework integrations: @recall-memory/ai-sdk, @recall-memory/langchain, @recall-memory/mastra MIT
integrations Claude Code and Codex plugins, OpenClaw, Hermes, Agent Skill, MCP registry and connector manifests MIT
examples The code of every guide, in TypeScript and Python (TypeScript only for the TypeScript frameworks), run against a real server in CI MIT
evals The benchmark harness: LongMemEval-S, BEAM and LoCoMo against any compatible URL, with metered cost and latency MIT
docs Architecture and releasing the SDKs MIT

Develop with pnpm install, pnpm dev (server with reload on port 8000) and
pnpm lint && pnpm typecheck && pnpm test; tests run offline against an in-memory Postgres and
the mock model. CONTRIBUTING.md has the details.

Licence

  • The server (packages/server/) is under the Functional Source License 1.1, Apache 2.0
    future licence. Use, copy, modify and self-host it for anything
    except a Competing Use: making it available to others as a commercial product or service that
    substitutes for Recall or offers substantially the same functionality. Each version becomes
    Apache 2.0 two years after it is released.
  • Everything you build on (the SDKs, integrations, examples and the eval harness) is
    MIT. That includes the Python SDK: version 0.1.1 on PyPI still lists
    Apache-2.0 in its metadata, and the releases after it list MIT.

LICENSE.md explains the split in full. Copyright (c) 2026 Smidt Beheer.

Contributing, security and support

  • Contributing: issues and pull requests are welcome; read CONTRIBUTING.md
    first (commits are signed off under the DCO). Everyone
    taking part follows the Code of Conduct.
  • Security: please do not open an issue. Email security@recallmem.dev; see
    SECURITY.md and recallmem.dev/security.
  • Help with your account or billing: support@recallmem.dev or
    recallmem.dev/support.

Website ·
Docs ·
Evals ·
Security ·
Privacy ·
Terms

Recall is made by Smidt Beheer in the Netherlands.

常见问题

8 问
答案由本站依据条目字段整理,不引用上游原文
Recall 怎么安装?

在客户端按下面的安装命令接入:npx add-mcp 'https://api.recallmem.dev/mcp'。装完在客户端配置里引用同一个包或端点。

Recall 怎么在 Claude Desktop、Claude、Cursor 里配置?

它的传输方式是HTTP · 远程,在客户端的 MCP 配置里填好启动命令和参数,保存后完全退出客户端再打开,配置才会生效。

Recall 收费吗?

本站不代收费用,也没有标注具体价格。是否收费取决于服务本身和背后的接口额度,正式使用前按官方说明确认。

Recall 需要 API Key 吗?

资料标注需要API Key认证,使用前准备好对应凭据,并按最小权限配置。

Recall 支持哪些客户端?

资料标注支持 Claude Desktop、Claude、Cursor、VS Code、Gemini CLI、Codex;其他客户端只要能配置 MCP Server,也能用同样的命令或地址接入。

Recall 能提供哪些能力?

资料显示能力标签包括 记忆。具体工具清单以官方文档为准。

Recall 需要什么运行环境?

属于远程端点,不需要在本地装运行时。

Recall 是本地还是远程?

它是远程端点,连服务地址即可。传输方式为HTTP · 远程。

热门专题

按标签挑服务器
全部专题 →

服务器信息以作者仓库与官方文档为准;分类、传输方式与鉴权方式的中文说明为中文整理,最近核验 2026-11-20。