接入你的智能体
从发布者处安装。不是 PlugMCP 端点。
远程 URL 还是本机命令？ 两种安装方式的区别
来自发布者
Recall is a memory for agents. The memory that avoids hallucinations, proposes facts and does not do guesswork. The recall functionality builds the current belief of the system based on how a user corrects their facts, backtracks or changes their understandings. Recall replaces the old fact and informs the agent what it replaced. It keeps the old value in a history for auditing and replaying.
Memory and state for AI agents: every correction kept with history, and agents that resume from their own records. Runs on your database.
The demo is a real run with one user over nine months. User chaned three homes, three employers, and three work emails. The demo queries six questions about her with current understanding. It is using Opus 5.5 to extract facts, answer, and judge for all three systems. The answers are at Recall 18/18, mem0 18/18, Zep 12/18. Tokens to save one message: Recall 3.0k, mem0 12.7k, Zep 14.7k.
pip install polign-recall # Python client, the recall binary, and the database it runs
brew install polign/tap/recall # the same for Homebrew
recall mcp -write # MCP over stdio: remember(text), recall(question), forget(text)
Without a named database, recall keeps memory in a
local database in ~/.local/share/recall, started on first use and shared by
every agent on the machine. The Quickstart runs without a model
or an API key. see Backends to keep the memory in the currently integrated locations.
Today that local database is polign_db, so recall needs the polign-server
binary next to it. pip and Homebrew install both. go get and
go install github.com/Polign/recall/cmd/recall give you the library and the
binary but not the database: name one with -backend and -url, or install
polign_db (pip install polign-db or brew install polign/tap/polign). In
0.23.0 a recall mcp with nothing configured and no polign-server exits
before the MCP handshake; the next release serves the tools and reports the
missing database on the first memory call instead. A local database that needs
no second binary is being built.
Every change is kept. Three commands read that record:
$ recall history "which editor do I use"
user preferred editor
believed now: user preferred editor: zed
2026-09-01 10:00 stated, user_stated
+ user preferred editor: vim
2026-09-20 10:00 replaced, user_stated
- user preferred editor: vim
+ user preferred editor: emacs
2026-10-05 10:00 replaced, user_stated
- user preferred editor: emacs
+ user preferred editor: zed
$ recall ask -as-of 2026-09-25 "which editor do I use"
Believed as of 2026-09-25 00:00:
user preferred editor: emacs (since 2026-09-20)
replaced: vim (since 2026-09-01)
$ recall diff -from 2026-09-15 -to 2026-10-31
Changed between 2026-09-15 00:00 and 2026-10-31 00:00:
- user home city: Lisbon
+ user home city: Porto
- user preferred editor: vim
+ user preferred editor: zed
as_of, history, and diff answer what the
agent believed then, and when that changed.recall explain shows the message a fact came
from, the rule that decided it, and its history.LongMemEval user-facts subset (267 questions about a user's own facts, preferences, updates, and dates), Recall 0.19.0, Sonnet 5.5 as reader and judge, upstream prompts:
With its built-in word search, Recall is about even with BM25 overall and behind it on preference questions (70.0 against 83.3). A model embedder puts it ahead. Since 0.20.0 one follows the extraction model: OpenAI's text-embedding-3-small with an OpenAI extractor, Ollama's nomic-embed-text with an Ollama one, and the all-MiniLM model built into the binary with an Anthropic one. With word search, Recall handed the reader about 28k tokens per question, against about 44k for BM25 and 168k for the full history.
The Claude Code plugin
is a ready-made MCP integration for memory across coding sessions, and the
OpenClaw plugin
(@polign/openclaw-recall on npm) gives OpenClaw agents the same memory.
You'll need Python 3.10+. Install the client:
pip install polign-recall
pip also brings the polign_db package, which holds the polign and
polign-server binaries, so there is nothing else to download or start. This
example needs no model or embedding API key.
One process saves an editor preference and then changes it:
python - <<'PY'
from polign_recall import Client
with Client(local_dir="./recall-data") as memory:
memory.remember("user", "prefers_editor", "vim")
memory.remember("user", "prefers_editor", "neovim")
PY
Run a second process in the same terminal. It reads the current preference, the full history, and what was believed before the correction:
python - <<'PY'
from polign_recall import Client
with Client(local_dir="./recall-data") as memory:
print(memory.recall("user", "prefers_editor")[0].value) # neovim
events = memory.history("user", "prefers_editor")
print([event.value for event in events]) # ['vim', 'neovim'] in a fresh directory
# Ask what was believed at the moment of the first statement.
before = memory.recall("user", "prefers_editor", as_of=events[0].observed_at)
print(before[0].value) # vim
PY
The correction did not erase vim. It is still there to read, which is how you
answer "what did the agent believe yesterday, and when did that change?"
The first client to open ./recall-data starts a local polign-server for it
in the background, and later clients share it. The memories stay in that
directory after your program exits. A bare Client() does the same in
~/.local/share/recall, the memory every agent on the machine shares, the
Claude plugin included. Managed local databases work on Linux and macOS.
To share memory between machines, run polign-server yourself (requires
Polign v0.8.0 or later) or any
other backend, leave local_dir out, and name the database with
Client(backend=, backend_url=, backend_key=) or with RECALL_BACKEND,
RECALL_BACKEND_URL and RECALL_BACKEND_KEY in the environment.
RECALL_COLLECTION names the collection. Client.database says which
database the binary resolved.
For examples covering forgetting as well, see the Python session example or Go session example.
A memory has a subject, a predicate, and a typed value:
Predicates live in a registry that declares each one's value type, whether it
holds one value or several, and which predicates it contradicts (dislikes
excludes likes, gave_away excludes owns). Recall includes
starter registries for coding, personal
assistant, support, sales, and voice agents. Add your own predicates
(the registry), and the extractor files
statements under them; you can
change the registry later without
changing what the agent remembered before. A value can be text, a number, a boolean, an enum,
a date, or a reference to another subject.
For a single-valued predicate such as prefers_editor, a new assertion replaces
the current value. A multi-valued predicate such as uses_technology can hold
both Python and Go. Corrections preserve earlier statements, so you can read
current values, inspect their history, or query what was known at an earlier time.
Forgetting records a withdrawal and removes the affected fact from current answers. It does not permanently delete the record.
An agent can also propose facts from text.
Recall validates those proposals against the registry before writing them. A
statement that fits no predicate is kept as a note
instead of being dropped. Once you add a predicate for that kind of fact,
Promote files each note under it and keeps the note in history.
You don't have to define predicates at all. With an
open vocabulary, a write may name any
predicate and its first use defines it, starting from the coding and personal
starters. recall explain "<question>" shows, for each answer, the text it
came from, the predicate it was filed under, the rules that decide it, and its
history.
With a model configured, the MCP server goes one step further and takes plain text, with no predicates in any tool or answer:
recall setup -extract-model anthropic:claude-haiku-4-5-20251001
remember("I switched from helix to zed last week")
recall("which editor do I use?") -> "user prefers editor: zed" (before: helix)
forget("my editor")
The model decides how each statement is filed: which predicate, and whether a
new value replaces the old one or adds to it. Once filed, replacement follows
the predicate's rule as before, every filing is recorded, and a wrong one is
corrected with one event (Redefine, Merge, Split) that every answer
follows. The model is called on every remember and forget, and the text is
sent to its provider. See text-only tools.
The benchmark above uses these text tools with an open vocabulary seeded from the personal starter.
recall mcp -write -typed serves tools over a fixed vocabulary instead, such
as remember(subject, predicate, value). A session with the personal starter
registry:
remember(user, likes, mangoes)
remember(user, dislikes, mangoes)
-> superseded: [likes: mangoes] # the registry says dislikes excludes likes
recall(user, dislikes)
-> mangoes replaced: [likes: mangoes] # the correction arrives with the answer
remember(user, goal, "run a marathon")
remember(user, did, "run a marathon")
recall(user, goal)
-> run a marathon elsewhere: [did: run a marathon] # no rule joins goal and did,
# so the read shows both
remember(user, did, "run a marathon",
replaces=[goal: "run a marathon", goal: "learn piano"])
-> replaced: [goal: run a marathon]
-> unreplaced: [goal: learn piano] # never believed, so reported, not dropped
No model reconciles memory on its own. Recall applies the rules the registry declares, shows the candidates that may conflict, and lets your agent confirm the rest, so every correction can be read back to the rule or the statement that made it.
Each step of a history is the log folded just before and just after that
statement, so it agrees with a read at that instant. Agents get the same
record through the history and diff MCP tools (timeline and diff with
-typed), recall serve answers them over HTTP at /v1/history,
/v1/timeline and /v1/diff, and the Python client has history_text,
timeline and diff.
Resume gives an agent back the context it should start from, built from what
it wrote down while it worked. The new process resumes from records, not from a
process or container snapshot:
The next process gets those records, plus memories that match its focus, sized to a token budget and rendered as one briefing for the model. A lease keeps one process per agent, so a second copy cannot write over the first. Leases need Polign v0.8.0 or later.
agent, err := client.Resume(ctx, recall.ResumeRequest{AgentID: "coder-1", TokenBudget: 8000})
if err != nil {
return err
}
defer agent.Release(context.Background())
briefing := agent.Resumed().Briefing // hand this to the model
Resume and actions are a beta surface: the calls around the records may still change in a minor release, with the change and what to do about it in the changelog. The records themselves are stable. See STABILITY.md.
The resume example crashes an agent partway through a task
and continues it in a new process. See Resuming an agent
for the full API, and the Python client guide for resume
in Python.
recall mcp is one agent, one process, one store. recall serve is the same
memory for many agents at once, over HTTP, each inside the namespace its key
names. The server holds the store's credentials; agents hold Recall keys.
recall serve -backend polign -url http://polign:23000 -bootstrap-key-file admin.key # admin.key holds one rcl_... line
recall key create -backend polign -url http://polign:23000 -namespace acme:agent-7 -expires 168h
With no database named, recall serve runs on the local database like every
other command, and recall key create -namespace team:agent-1 against the
same default mints a key for it: a shared memory server for several agents on
one machine, with nothing configured. Its first log line says where memory
is, so a container that meant to name a database and did not is told at once.
Each namespace gets its own collection, so nothing a caller sends can reach
another namespace's records. Keys are stored hashed, expire if asked, renew at
POST /v1/keys/renew, and are revoked by a tombstone that nothing can
overwrite. POST /mcp is MCP over streamable HTTP; POST /v1/<tool>
(remember, recall, forget, history, explain, diff, timeline,
predicates) takes that tool's arguments as the body. Any MCP client that
speaks stdio reaches the server through
recall connect, with RECALL_URL and RECALL_API_KEY set.
On Kubernetes a pod needs no key at all. With recall serve -kubernetes, it
posts its projected service account token (audience recall) and gets a
short-lived key for <tenant>:<pod name>, fixed to that agent, which recall connect and the Python client obtain and renew by themselves from
RECALL_TOKEN_FILE. The Helm chart is charts/recall in
Polign/polign; the
agent-sandbox demo runs it on kind. The contract every
client is written against is docs/memory-api-v1.md.
Three things say where memory lives, the same three for every backend and every command:
Each resolves in the same order: the flag, the variable, the setup recall setup saved, the default. The flags go before the command or after it. A
backend's other options are query keys on the URL, listed in the table below;
anything else in the query goes to the driver as it is
(postgres://host/db?schema=memory&sslmode=require).
Nothing else about the database has a variable. The names each backend had
before 0.23.0 (POLIGN_URL, POLIGN_API_KEY, DATABASE_URL, PGPASSWORD,
MONGODB_URI, MONGODB_PASSWORD, QDRANT_URL, QDRANT_API_KEY) keep
working as aliases, with one line on stderr naming the new one, and so does a
polign_db already answering at http://localhost:23000 when nothing names a
backend, which is where 0.22 looked. See STABILITY.md for
when they go away.
Recall provides memory rules, validation, and history; the backend provides persistence and access to the data. Agents share memory by using the same backend, collection, and namespace, with compatible Recall versions and memory definitions. Search also requires compatible embedding methods.
Concurrent reads and writes follow the backend's consistency guarantees. Recall does not add transaction isolation or replication.
To run Recall on a PostgreSQL database:
export RECALL_BACKEND=pgvector RECALL_BACKEND_URL=postgres://user:password@localhost:5432/mydb
recall mcp -write
The first write creates a recall schema with one table per collection and
two bookkeeping tables. The role needs CREATE on the database, and the
vector extension must be installed or creatable by that role.
Pitfalls on PostgreSQL:
english text search configuration unless
?text_search= on the URL (Go: Config.TextSearchConfig) says otherwise.
It is fixed when a collection is created.ef_search
candidates before the filter applies.To run Recall on MongoDB:
export RECALL_BACKEND=mongodb RECALL_BACKEND_URL=mongodb://user:password@localhost:27017/recall
recall mcp -write
The database is the connection string's path, recall when it has none. The
first write to a collection creates a MongoDB collection named rc_ and the
collection's name, and two bookkeeping collections, recall_collections and
recall_leases. The user needs readWrite on the database.
Pitfalls on MongoDB:
english text index, fixed when a collection
is created.Pitfalls on Qdrant:
_recall_id
payload field makes reads fail.Unleased: true is safe only when something else keeps one process per
agent. Without a lease, a crashed process that comes back can overwrite its
replacement.-embed-model) helps paraphrases, not keywords.To add a backend, implement Put, List and Search
(contract), register it with
recall.RegisterBackend in init, pass backendtest, and import
it in cmd/recall/backends.go.
The core package, github.com/Polign/recall, imports nothing outside the
standard library. The pgvector backend uses pgx,
the MongoDB backend the
official MongoDB driver, and the
model package the Anthropic SDK and hugot
for the embedding model that runs inside the binary. A program pulls each in
only by importing that package.
Two embedders ship with Recall: lexical word search, which needs nothing, and
local:all-minilm-l6-v2, a model that runs in the binary with no key and no
service. -embed-model names an OpenAI, Ollama or Voyage model instead. See
the embedding guide.
See the development guide for the implementation map and test commands.
What is stable and what is beta · Developer reference · Resuming an agent · Connecting through MCP · Caching memory reads · Exporting and replaying history
If Recall kept your agent from acting on a stale fact, a star on this repository helps other people find it. Bugs, questions, and ideas go in issues.
Memory and state for AI agents: every correction kept with history, and agents that resume from their own records. Runs on your database.
工具
暂无工具列表。远程服务器在首次健康检查后会获得工具列表。
常见问题
在本页复制适用于 Cursor、Claude Desktop、Claude Code 或 VS Code 的 stdio 配置。它使用发布者的安装方式，而不是 PlugMCP 代理。
此记录未列出必需的环境变量。
Recall 通过 stdio 在本地运行。
上次检查时间：2026-11-10。 Memory and state for AI agents: every correction kept with history, and agents that resume from their own records. Runs on your database.