RE Call Memory

MCP文档知识

提供方 未标注

文档知识 未标注 未标注 社区 / 第三方 Claude DesktopClaudeCursorVS Code

Postgres 加 pgvector 为 AI 智能体提供记忆,具备来源追踪、信任判定,并在记忆无法支撑答案时明确弃权。

一句话选型结论

按资料字段整理

RE Call Memory 属于文档知识类 MCP 服务器,传输方式未标注,鉴权方式未标注,可直接接入 Claude Desktop、Claude、Cursor 等,没有现成安装命令,需按官方文档接入。接入前先确认权限范围;涉及写入、删除或付款的操作,建议先在测试环境验证。

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

工具与能力

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

能力标签

支持客户端

适用场景

记忆

安装与配置

未标注 未标注
上游未给出传输方式
  1. 1
    准备运行环境

    按官方文档确认运行环境(常见为 Node.js 或 Python),装好后再执行安装命令。

  2. 2
    安装服务

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

  3. 3
    写入客户端配置

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

  4. 4
    验证是否可用

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

典型使用场景

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

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

知识库读写

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

内容整理

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

选择建议

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

值得选的地方

  • 已适配 Claude Desktop、Claude、Cursor,换客户端不用重新研究配置。

先想清楚的地方

  • 没有现成安装命令,需要按官方文档自己填启动命令和参数。
  • 资料没标注工具数量,实际能力要装好后确认。
  • 版本更新与行为细节以官方仓库为准。

更适合

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

不太适合

  • 需要厂商级 SLA 和技术支持的生产环境。

同类对比

6 个同类
同分类里挑最接近的几条,字段以各自详情页为准
MCP 服务器工具数传输方式部署方式安装命令最后核验
RE Call Memory当前 未标注 未标注 未标注 无 未标注
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

服务器档案

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

详细介绍

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

Memory that abstains instead of guessing.

RE-call is agent memory in a local SQLite file or your own PostgreSQL with pgvector. Each result carries a verdict,
confidence, and provenance, while unsupported questions are refused instead of answered by the
nearest match.

What it is
For agents
How it works
Start with Lite
Install and integrate

What is RE-call

RE-call is agent memory in a local SQLite file or your own PostgreSQL database. It indexes source
documents and keeps validity, lineage, confidence, and provenance attached to every result.

Vector search returns nearby text. RE-call also checks whether that text is current, supported, and
trustworthy enough for the query. A superseded claim is marked superseded; a result that does not
clear the calibrated trust gate becomes ABSTAIN with a reason. Declared supersession makes the current memory win
over stale but similar memory.

The default path uses local embeddings plus hybrid dense and keyword retrieval. PostgreSQL uses
its full text search; Lite uses SQLite FTS5. It needs no memory-layer LLM call. Additional retrieval,
reasoning, and structured-fact modules are optional.

For the agent reading this, RE-call for agents explains the experience loop
and how to use persistent memory as a trustworthy past rather than an unverified scratchpad.

How it works

On PostgreSQL, RE-call builds an immutable, calibrated generation and serves queries against that
pinned generation. Lite binds calibration to its single-file corpus. Every search, including the
reasoning and fact paths, goes through trusted search and the trust gate.

The diagram is interactive on the project site:
click any box to see the source lines it describes. A
step by step view of one recall_search call
follows a single search through its refusal, abstention and answer paths. Both are generated from
the sources in docs/diagrams.

Text version of the diagram, with each box linked to its file

Solid arrows are the default path. Dashed arrows are opt in or reasoning only: the reranker, graph
expansion, and the answer provider. Each box links to the file that implements it.```mermaid
flowchart LR

subgraph group_entry["Entry points"]
node_cli["recall CLI<br/>commands"]
node_mcp["MCP server<br/>tool handlers"]
node_sdk["Agent SDK<br/>in process"]
end

subgraph group_build["Generation build"]
node_manifest["Source manifest<br/>immutable input"]
node_generations["Generation manager<br/>build, validate, promote"]
node_parser["Parse and chunk<br/>documents to chunks"]
node_embedder["Embedder<br/>local or hosted API"]
node_graph_build["Semantic graph<br/>entities, relations"]
node_calibration["Calibration<br/>certified threshold"]
end

subgraph group_serve["Trusted retrieval"]
node_trusted_search["Trusted search<br/>query orchestrator"]
node_gen_store["Generation store<br/>pinned generation"]
node_retriever["Hybrid retriever<br/>dense, full text, RRF"]
node_reranker["Reranker<br/>opt in"]
node_trust_gate{{"Trust gate<br/>verdict or ABSTAIN"}}
end

subgraph group_reason["Reasoning"]
node_reasoner["Reasoning query<br/>evidence bundle, plan"]
node_graph_expansion["Graph expansion<br/>one hop, before trust"]
node_answer["Answer provider<br/>opt in LLM"]
end

subgraph group_facts["Provenance and facts"]
node_provenance["Provenance controller<br/>fact review"]
node_ledger["Fact ledger<br/>append only"]
end

node_caller(("Agent or user<br/>caller"))
node_postgres[("PostgreSQL + pgvector<br/>generations, chunks, graph")]

node_caller -->|"runs"| node_cli
node_caller -->|"tool calls"| node_mcp
node_caller -->|"imports"| node_sdk
node_sdk -->|"reuses handlers"| node_mcp
node_cli -->|"generation build"| node_generations
node_mcp -->|"ingest uploads"| node_generations
node_generations -->|"reads sources"| node_manifest
node_generations -->|"parses, chunks"| node_parser
node_generations -->|"embeds chunks"| node_embedder
node_generations -->|"builds graph"| node_graph_build
node_generations -->|"requires certified"| node_calibration
node_generations -->|"writes generation"| node_postgres
node_graph_build -->|"writes graph"| node_postgres
node_cli -->|"calibrate, publish"| node_calibration
node_calibration -->|"stores threshold"| node_postgres
node_cli -->|"search"| node_trusted_search
node_mcp -->|"search, evidence"| node_trusted_search
node_trusted_search -->|"pins generation"| node_gen_store
node_gen_store -->|"reads active"| node_postgres
node_trusted_search -->|"retrieves"| node_retriever
node_retriever -->|"embeds query"| node_embedder
node_retriever -->|"dense, full text"| node_gen_store
node_retriever -.->|"reorders"| node_reranker
node_trusted_search -->|"evaluates"| node_trust_gate
node_mcp -->|"reasoning query"| node_reasoner
node_reasoner -->|"retrieves"| node_trusted_search
node_trusted_search -.->|"expands pre trust"| node_graph_expansion
node_graph_expansion -.->|"same generation graph"| node_postgres
node_reasoner -.->|"cited answer"| node_answer
node_mcp -->|"apply fact"| node_provenance
node_provenance -->|"fresh search"| node_trusted_search
node_provenance -->|"appends"| node_ledger
node_ledger -->|"stores"| node_postgres

click node_cli "https://github.com/GiulioDER/RE-call/blob/master/recall/cli.py"
click node_mcp "https://github.com/GiulioDER/RE-call/tree/master/recall_mcp"
click node_sdk "https://github.com/GiulioDER/RE-call/blob/master/recall_agent/memory.py"
click node_manifest "https://github.com/GiulioDER/RE-call/blob/master/recall/manifest.py"
click node_generations "https://github.com/GiulioDER/RE-call/blob/master/recall/generations.py"
click node_parser "https://github.com/GiulioDER/RE-call/blob/master/recall/document.py"
click node_embedder "https://github.com/GiulioDER/RE-call/blob/master/recall/embeddings.py"
click node_graph_build "https://github.com/GiulioDER/RE-call/blob/master/recall/semantic_graph/_build.py"
click node_calibration "https://github.com/GiulioDER/RE-call/blob/master/recall/calibration_v2.py"
click node_trusted_search "https://github.com/GiulioDER/RE-call/blob/master/recall/trust.py"
click node_gen_store "https://github.com/GiulioDER/RE-call/blob/master/recall/generation_store.py"
click node_retriever "https://github.com/GiulioDER/RE-call/blob/master/recall/retriever.py"
click node_reranker "https://github.com/GiulioDER/RE-call/blob/master/recall/rerank.py"
click node_trust_gate "https://github.com/GiulioDER/RE-call/blob/master/recall/trust.py"
click node_reasoner "https://github.com/GiulioDER/RE-call/blob/master/recall/reasoning.py"
click node_graph_expansion "https://github.com/GiulioDER/RE-call/blob/master/recall_mcp/graph_expansion.py"
click node_answer "https://github.com/GiulioDER/RE-call/blob/master/recall/answer_provider.py"
click node_provenance "https://github.com/GiulioDER/RE-call/blob/master/recall/provenance_controller.py"
click node_ledger "https://github.com/GiulioDER/RE-call/blob/master/recall/fact_ledger.py"
click node_postgres "https://github.com/GiulioDER/RE-call/tree/master/recall/migrations"

classDef toneNeutral fill:#f8fafc,stroke:#334155,stroke-width:1.5px,color:#0f172a
classDef toneBlue fill:#dbeafe,stroke:#2563eb,stroke-width:1.5px,color:#172554
classDef toneAmber fill:#fef3c7,stroke:#d97706,stroke-width:1.5px,color:#78350f
classDef toneMint fill:#dcfce7,stroke:#16a34a,stroke-width:1.5px,color:#14532d
classDef toneRose fill:#ffe4e6,stroke:#e11d48,stroke-width:1.5px,color:#881337
classDef toneIndigo fill:#e0e7ff,stroke:#4f46e5,stroke-width:1.5px,color:#312e81
classDef toneTeal fill:#ccfbf1,stroke:#0f766e,stroke-width:1.5px,color:#134e4a
class node_cli,node_mcp,node_sdk,node_caller toneBlue
class node_manifest,node_generations,node_parser,node_embedder,node_graph_build,node_calibration,node_postgres toneAmber
class node_trusted_search,node_gen_store,node_retriever,node_reranker,node_trust_gate toneMint
class node_reasoner,node_graph_expansion,node_answer toneRose
class node_provenance,node_ledger toneIndigo


Ordinary `recall search` follows the direct path. Explicit reasoning accepts `graph_expansion`:
`auto` is the default and resolves to bounded one hop expansion for every nonempty query; `off`
keeps direct retrieval only; `one-hop` forces the graph path. The CLI uses
`--graph-expansion auto · off · one-hop`; the MCP tool uses `graph_expansion=&quot;auto&quot; · &quot;off&quot; · &quot;one_hop&quot;`.
Graph neighbors are generation bound, direct candidates remain first, and expanded candidates must
clear the same trust boundary before they can support a cited answer.

The opt in choices attach to different points in the system:

| Optional capability | Where it fits | What it adds |
|---|---|---|
| Hosted embedder | Build and query | Remote model calls for embeddings. Query and corpus text may leave the environment. |
| Learned sparse retrieval, SPLADE | Hybrid retrieval | A learned term weighted retrieval leg in addition to dense vectors and Postgres full text. |
| Reranker | After candidate fusion | Reorders the fused candidates with a cross encoder. |
| Evidence Graph version one | Explicit reasoning retrieval | Adds bounded, generation-bound structural neighbors to reasoning retrieval. See `graph_expansion` above for controls; graph candidates pass through trust before a cited answer can use them. |
| Structured fact application | Evidence cards | Lets a reviewed fact pass through the provenance controller into the append only ledger. |

For details, see the architecture writeup, provenance controller, and API reference.

## Quickstart

For one project&#x27;s memory on your machine, start with **RE-call Lite**. It stores memory in
`.recall/memory.db`, refreshes changed memos automatically, and needs no Docker or database server.

**Install the source build first:** Lite is in the repository; the published `0.14.0` PyPI wheel
predates it. Follow the Lite installation guide
to create an environment and install the source, then run this from your own project with an
existing folder of notes:```bash
recall setup --lite --memory ./notes

Setup indexes the notes, attempts automatic calibration, and registers Claude Code for this project.
Inspect the calibration and registration results, use the printed doctor command, and restart the
client. Strict trust stays enabled; a corpus that cannot certify will refuse trusted answers.
For other MCP clients, use manual Lite wiring.

Choose Best fit Maintenance
Lite One project on one machine, using a local SQLite file Automatic memo refresh and calibration; back up notes and the store.
PostgreSQL Shared serving, immutable generations, multiple tenants, or authentication Manage the database, schema migrations, generations, calibration, and backups.

Try the PostgreSQL demo

Prerequisites: Python 3.11 or newer, Docker, and a Docker installation able to run PostgreSQL with
pgvector.```bash
pip install "recall-rag[fastembed]"
recall quickstart


The demo starts a throwaway database, indexes a small corpus included in the package, and runs
three searches. It includes a normal answer, a stale claim that is returned as superseded, and a
question that is refused. The demo uses development trust and changes no personal files.

Remove the demo database when finished:```bash
recall quickstart --remove

Already have PostgreSQL with pgvector? Use recall quickstart --existing-dsn instead. The
demo is intentionally separate from a real install and is not calibrated for your data.

Install and integrate

Local, with no database server and no Docker

Use the Lite source installation, then run
from the project whose notes you want to index:```bash
recall setup --lite --memory ./notes


Setup creates `.recall/memory.db`, attempts automatic calibration, and registers Claude Code for
this project. Use the printed doctor and read-only dashboard commands, and add `.recall/` to
`.gitignore`. For CLI or manual client wiring, add `--no-register`.

The MCP server refreshes changed memos automatically. To check or refresh explicitly:```bash
recall lite refresh --store .recall/memory.db --memory ./notes --check
recall lite refresh --store .recall/memory.db --memory ./notes

Use the same memo root and embedder as setup. The CLI does not read the MCP client's environment;
apply setup's printed settings before CLI searches or doctor. Strict trust remains enabled, and
successful indexing alone does not guarantee certification.

The Lite guide covers other clients, source updates, backup and restore, refresh
budgets, and queued writes. Keep the file on a local disk. Lite uses exact cosine search and
SQLite keyword retrieval; results can differ from PostgreSQL. Generations, multi-tenant serving,
and authentication require PostgreSQL. See the API for trust and retrieval limits.

With PostgreSQL

For your own corpus, provide PostgreSQL with pgvector and run the guided setup wizard after
installing recall-rag[fastembed]:```bash
recall setup


It applies the schema, asks for the embedder and retrieval options, indexes the corpus, offers
calibration, and registers the selected agent integration. When the wizard asks whether to calibrate,
use a labeled query file that refers to the corpus you are installing. Calibration fitted
to the bundled demo is only an example, not a certification for your data. The schema uses an
ordered SQL migration path and pre-tenancy tables are migrated in place.

For Docker, an existing database, headless provisioning, manual calibration, and troubleshooting,
see docs/INSTALLATION.md and docs/WIZARD.md.

### Choose an integration

| Use case | Install | Next step |
|---|---|---|
| Lite CLI or MCP | Install from source | Run `recall setup --lite --memory ./notes`; use `--no-register` for CLI or manual client wiring. |
| PostgreSQL CLI and Python | `pip install &quot;recall-rag[fastembed]&quot;` | Run `recall setup`, then use `recall search` or the Python API. |
| PostgreSQL MCP clients | `pip install &quot;recall-rag[fastembed,mcp]&quot;` | Run setup and follow the MCP guide. Host specific steps are below. |
| Claude Agent SDK | `pip install &quot;recall-rag[agent,fastembed]&quot;` | Use the in process integration in USING_WITH_AGENT_SDK.md. |
| LangChain or LlamaIndex | Install the matching extra | Use the adapters described in API.md. |
| Windows desktop UI | `pip install &quot;recall-rag[desktop]&quot;` | Run `recall-install`; the current release does not ship a standalone Windows binary. See the wizard guide. |

#### Claude Code

Inside Claude Code, install the plugin after installing the Python package:```text
/plugin marketplace add GiulioDER/RE-call
/plugin install recall@re-call

The plugin supplies the MCP server, memory search skill, and lifecycle hooks. Lite setup already
registers a project server; the plugin is optional. If you add it, configure its Database DSN with
the SQLite DSN printed by setup and avoid enabling duplicate servers for the same memory. The
plugin's server does not refresh memos by itself; run recall lite refresh yourself or keep the
server setup registers.
For PostgreSQL, run recall setup against the project and database Claude should use.
Details are in plugin/README.md.

Codex

For Lite, use manual MCP wiring: recall setup --lite only
registers Claude Code. For PostgreSQL, run recall setup from the project. When Codex is detected,
setup installs the Codex MCP server,
plugin bundle, memory and session skills, and hooks into the user configuration. Restart Codex afterward. The
Codex and Claude Code integrations share the same memo format and trust layer. See
docs/CODEX_RECALL_INTEGRATION.md.

Claude Agent SDK

The SDK integration runs the same tools in process and does not start an MCP server:```python
from recall_agent import RecallAgentMemory

with RecallAgentMemory.from_env() as memory:
options = memory.options()


See docs/USING_WITH_AGENT_SDK.md for the complete example and
write-tool boundaries.

#### LangChain and LlamaIndex

Both adapters use the same trusted retrieval path. If trust abstains, they return no document by
default, and returned documents retain verdict, confidence, cosine, and supersession metadata.
See docs/API.md for the supported classes and methods.

### If an install is not working```bash
recall doctor

For Lite, first apply the environment printed by setup so doctor inspects the SQLite store.
For PostgreSQL, the doctor checks the interpreter, console scripts, embedder, Docker, database,
pgvector, schema,
configured table and tenant, calibration, and agent registration. It changes nothing and prints the
repair command for each problem.

Product surface

Area What ships
Retrieval and memory Dense vectors plus Postgres full text with hybrid RRF, validity, calibrated confidence, provenance, trust verdicts, immutable generations, incremental indexing, pruning, and source erasure.
Structured facts Citable evidence cards, provenance controller, append only fact ledger, current fact projection, and optional materialization outbox.
Quality Real pgvector integration tests, type checking, linting, dependency audit, and a claim gate that checks published evidence in CI.

RE-call is not a hosted memory service, dashboard, or automatic truth extractor. It does not rewrite
corpus metadata from an agent's inference. Reasoning is opt in, citation constrained, and review
aware. See docs/PRODUCTION.md for deployment boundaries.

Read next

Need Document
Why an agent needs persistent, trusted memory docs/FOR_AGENTS.md
Full documentation map docs/README.md
Install and maintain Lite docs/LITE.md
Install and provision PostgreSQL docs/INSTALLATION.md, docs/WIZARD.md
Python, CLI, and MCP reference docs/API.md
Trust, architecture, and provenance docs/WRITEUP.md, docs/PROVENANCE_CONTROLLER.md
Security and operations docs/AUTH.md, docs/PRODUCTION.md, docs/OPERATING_MODES.md
Measurements and limits docs/EVIDENCE.md, results/FINDINGS.md

Published numbers are tied to committed artifacts, and the claim gate checks them in CI. Benchmark
interpretation and limits belong in docs/EVIDENCE.md, not in this overview.

Citation

If you describe RE-call in a paper, post, talk, or README of your own, cite the project and credit
Giulio D'Erme. Use CITATION.cff as the canonical citation source.

License

RE-call is open source under the GNU Affero General Public License v3.0 (AGPL-3.0).
You may use, study, modify, and share it, commercially as well, on the AGPL's conditions: if you
distribute RE-call or a work based on it, or let users interact with a modified version over a
network, you must make the corresponding source available under the same license. When those
conditions do not fit, for example a closed source product or a proprietary hosted service, a
commercial license is available from the copyright holder. See
COMMERCIAL_LICENSE.md for the boundary between the two and for the terms
of earlier releases, and preserve NOTICE when redistributing the software.
Contributions are accepted under the Contributor License Agreement.

常见问题

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

资料没有给出安装命令,请到官方仓库或文档按说明接入;这类条目多数是生态应用,或尚未发布可安装包。

RE Call Memory 怎么在 Claude Desktop、Claude、Cursor 里配置?

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

RE Call Memory 收费吗?

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

RE Call Memory 需要 API Key 吗?

资料没有标注鉴权方式,是否需要密钥取决于服务本身,接入前按官方文档确认。

RE Call Memory 支持哪些客户端?

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

RE Call Memory 能提供哪些能力?

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

热门专题

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

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