RE-call MCP Memory Server

Why RE-call

Nearest-match retrieval cannot tell the difference between what is true and what merely reads like it. When a corpus keeps its history, and real agent memory does, the retracted claim and its correction are both retrievable, and the retracted one is often the nearer match. That is not a tuning problem. A ranker with no notion of validity has no way to prefer the correction.

RE-call came out of a production, long-running trading-research agent: months of operation, 792 typed memos, 6,469 chunks, re-indexed daily by a session-end hook. Every guard in this repository exists because that agent failed a specific way without it. See docs/CASE_STUDY.md.

It is for teams putting agent memory behind real applications, where a stale or unsupported memory is worse than no memory: keep the memory layer local by default, attach policy to every hit, calibrate the refusal threshold on your corpus, and let the application decide what to do with a result that is not trustworthy enough to answer from.

Measured strengths:

The README is the product overview. For evidence behind these claims, start with docs/EVIDENCE.md, then use results/FINDINGS.md for the full interpretation and limits.

Related MCP server: Obsidian MCP (pgvector + Ollama, self-hosted)

Quickstart

RE-call keeps memory in your own PostgreSQL with pgvector, so a database comes first.

Already running PostgreSQL with pgvector? Skip ahead and point the DSN at it.

Want a throwaway one? Save this as docker-compose.yml, then start it:

services:
  db:
    image: pgvector/pgvector:pg18
    environment:
      POSTGRES_USER: recall
      POSTGRES_PASSWORD: recall
      POSTGRES_DB: recall
    volumes:
      - recall_pgdata:/var/lib/postgresql
    ports:
      - "5432:5432"
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U recall"]
      interval: 2s
      timeout: 3s
      retries: 30

volumes:
  recall_pgdata:

docker compose up -d --wait

Then install, create the schema, and run the guided setup wizard. The wizard records the selected embedder, retrieval options, and an optional calibration that is fitted to your labeled queries and your corpus.

pip install "recall-rag[fastembed]"
python -m recall.cli --migration-dsn postgresql://recall:recall@localhost:5432/recall schema --dim 384 apply
python -m recall.cli setup

Those three run unchanged in PowerShell.

The schema command targets the default chunks table deliberately. Global migrations have to be applied there before any other table, so starting with --table something_else on a fresh database stops with SchemaTooOld. To add a separate index later, apply the default target first, then pass --table.

When the wizard asks whether to calibrate, it wants a labeled query file and the corpus those queries refer to. You do not have to build either to try it: both ship inside the installed package, next to each other.

python -c "import recall.eval, pathlib; print(pathlib.Path(recall.eval.__file__).parent)"

That prints a directory holding queries.json, a labeled set covering both answerable and unanswerable questions, and corpus/, the documents those questions are labeled against. Give the wizard those two paths and calibration runs end to end. Sources: recall/eval/queries.json and recall/eval/corpus/.

A calibration fitted that way belongs to that sample, not to your data. It shows the mechanism working and gives you a labeled file to copy the shape of. Calibration is per embedder and per corpus, so a new model or a substantially changed corpus needs calibrating again, and a threshold fitted on the sample should not be used to judge your own memory.

A labeled file needs at least one answerable and one unanswerable query, and every entry needs a query and an answerable key. Calibration refuses the file rather than fitting a threshold to one-sided evidence.

The distribution is recall-rag; the import is recall. The name recall on PyPI belongs to an unrelated package, so do not install both into the same environment.

Working from a clone:

pip install -e ".[fastembed]"

How it works

flowchart TB
    M["Memo: markdown plus frontmatter"] --> CH["Chunk"]
    CH --> EW["Embed locally"]
    EW -. "optional" .-> SP["SPLADE encode"]
    EW --> DB
    SP -. "optional" .-> DB

    Q["Query"] --> EQ["Query encoder"]
    EQ --> DB[("PostgreSQL plus pgvector")]

    DB --> DN["Dense vector search"]
    DB --> SL["Postgres full-text search"]
    DB -. "optional" .-> LS["Learned sparse search"]

    DN --> F["Reciprocal Rank Fusion"]
    SL --> F
    LS -. "optional" .-> F

    F -. "optional" .-> RR["Cross-encoder rerank"]
    RR --> GP
    F --> GP{"Gap check: calibrated threshold"}
    GP --> TR{"Trust layer: supersession, validity, confidence"}
    CAL["Calibration: fitted per embedder and corpus"] --> TR
    TR -. "optional" .-> EJ{"Entailment judge"}
    EJ --> OUT
    TR --> OUT["Verdict, confidence, provenance, or ABSTAIN"]

    TR -. "explicit opt-in" .-> RG["Reasoning graph projection"]
    DB -. "generation-bound" .-> RG
    RG --> IP["Inference proposals: review candidates"]
    TR --> RP["Reasoning policy plus budget"]
    IP --> RP
    RP --> RV{"Citation and trust validation"}
    RV --> ROUT["Cited answer, needs review, clarification, or ABSTAIN"]

Product surface

Deliberately out of scope: an end-user dashboard, entity synthesis, high availability orchestration, automatic truth extraction from prose, and corpus rewrites from inference proposals. Reasoning is opt in, citation constrained, and review aware.

The ordered SQL migration path is versioned now, pre-tenancy tables are migrated in place, and runtime CREATE TABLE IF NOT EXISTS remains bootstrap only.

When not to use RE-call

Use something else if you need managed hosting, per-chunk ACLs, automatic truth extraction from prose, or a memory system that rewrites facts for you. RE-call is a retrieval library over your PostgreSQL database, not a hosted memory platform.

What this does not do

RE-call is a retrieval library with an opt-in reasoning layer, not a general reasoning system. It does not infer every missing supersession edge, prove that an on-topic memory answers a near-miss question, promote proposals into corpus truth, or replace database operations with a managed service. It returns the trust signals the caller needs, and it refuses to pretend that a nearest match is always usable evidence.

Use it

For an ad hoc local markdown folder, create a table for that index, index the corpus, and search it. If you did not calibrate during setup, use development mode only for local evaluation. Replace ./notes with your memo folder.

python -m recall.cli --table recall_notes \
  --migration-dsn postgresql://recall:recall@localhost:5432/recall \
  schema --dim 384 apply
RECALL_TRUST_MODE=development python -m recall.cli --table recall_notes index ./notes
RECALL_TRUST_MODE=development python -m recall.cli --table recall_notes search "what did we decide about caching?"
python -m recall.cli lint ./notes
python -m recall.cli check ./notes/new-memo.md --strict

PowerShell uses the same commands, but set development mode first when you are running an uncalibrated local evaluation:

$env:RECALL_TRUST_MODE = "development"

For production generation mode, build, validate, calibrate, and promote an immutable generation. Then query the tenant's active generation:

from recall.embeddings import FastEmbedEmbedder
from recall.generation_store import GenerationStore
from recall.trust import trusted_search

emb = FastEmbedEmbedder()
with GenerationStore(DSN, dim=emb.dim, tenant="acme", pool_size=8) as store:
    store.check_schema()
    result = trusted_search(store, emb, "what is the rate limit?")
    if result.abstained:
        ...  # say you do not know
    for hit in result.hits:
        hit.verdict
        hit.confidence
        hit.validity.superseded_by

Set RECALL_SERVING_DSN for application traffic and RECALL_MIGRATION_DSN only in the migration job. RECALL_DSN remains a deprecated development fallback for the serving DSN. See docs/MIGRATIONS.md. Configuration modes are summarized in docs/OPERATING_MODES.md.

Operational safety notes:

MCP

The MCP server uses the default chunks table. Apply that schema for the embedder the server will run, then point the client at recall_mcp.server.

python -m recall.cli --migration-dsn postgresql://recall:recall@localhost:5432/recall \
  schema --dim 384 apply

If an existing chunks table was created with another vector dimension, use a fresh database or an embedder with the matching dimension. The MCP stdio server does not take a --table flag.

{
  "mcpServers": {
    "recall": {
      "command": "python",
      "args": ["-m", "recall_mcp.server"],
      "env": {
        "RECALL_SERVING_DSN": "postgresql://...",
        "RECALL_TENANT": "acme",
        "RECALL_TRUST_MODE": "development"
      }
    }
  }
}

Omit RECALL_TRUST_MODE in production after you have built, calibrated, and promoted a generation. Local uncalibrated MCP work needs the explicit development setting because it has not gone through production calibration.

Tools: recall_search, recall_evidence, recall_index, recall_forget, and recall_stats.

Full guide: docs/USING_WITH_CLAUDE.md. Authentication and tenancy: docs/AUTH.md.

LangChain and LlamaIndex

pip install "recall-rag[langchain]"
pip install "recall-rag[llamaindex]"

from recall.integrations.langchain import RecallRetriever

retriever = RecallRetriever.from_store(store, emb, k=5)
docs = retriever.invoke("what is the rate limit?")

When the trust layer abstains, the adapters return no document by default. Returned documents carry trust metadata, including verdict, confidence, cosine, and supersession details.

Documentation

Start with docs/README.md.

Core documents:

Release notes and upgrade warnings live in CHANGELOG.md.

Evidence

Start with benchmarks/README.md. The results directory has its own map at results/README.md.

The short version:

Important benchmark documents:

When not to use RE-call

Use something else if you need managed hosting, per-chunk ACLs, automatic truth extraction from prose, or a memory system that rewrites facts for you. RE-call is a retrieval library over your PostgreSQL database, not a hosted memory platform.

What this does not do

RE-call is a retrieval library with an opt-in reasoning layer, not a general reasoning system. It does not infer every missing supersession edge, prove that an on-topic memory answers a near-miss question, promote proposals into corpus truth, or replace database operations with a managed service. It returns the trust signals the caller needs, and it refuses to pretend that a nearest match is always usable evidence.

Reproduce

make eval
python -m recall.eval.scale --embedder hashing --filler 50000

Cloud rows require the relevant API keys. Local rows run key-free.

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

Apache 2.0 license. See LICENSE, and keep NOTICE with redistributed derivative works.