RemembrallMCP — Rust-based persistent vector memory for AI agents using Postgres, pgvector and MCP

TL;DR in plain English

RemembrallMCP is a small Rust service that gives AI agents persistent memory. It stores embedding vectors and metadata in Postgres with the pgvector extension. It speaks the MCP (Message Connector Protocol). Source: https://github.com/cdnsteve/remembrallmcp

Quick path to a working demo:

• Start a local Postgres with pgvector. See the repo for details: https://github.com/cdnsteve/remembrallmcp
• Run the RemembrallMCP binary or container from the repo.
• Index a small set of documents and run a validation loop.

Why try this first? A local stack is cheap to run and fast to iterate on. It helps you test retrieval quality and latency before any cloud rollout. Basic targets to aim for (examples in the checklist and assumptions): index-level tests with a small corpus and a short canary.

---

What you will build and why it helps

You will build a local RemembrallMCP test instance based on the project at https://github.com/cdnsteve/remembrallmcp. The core components are:

• A Rust process that implements MCP for clients.
• A Postgres database with pgvector to store vectors and metadata.
• A small index and a test loop that measures retrieval quality.

Why this helps:

• Persistent vectors avoid re-embedding the same content every session.
• Metadata stored with vectors lets retrieval return snippets, tags, timestamps, or authorship fields alongside similarity scores.
• A reproducible local stack makes it easy to validate recall and latency before you scale.

Concrete goals you will check during tests include relevance and latency (see assumptions in the final section). For source and project code, see https://github.com/cdnsteve/remembrallmcp.

Before you start (time, cost, prerequisites)

Read the repository summary first: https://github.com/cdnsteve/remembrallmcp.

Prerequisites (high level):

• A host with git available.
• Either Docker or a Rust toolchain to run the service.
• Access to a Postgres instance where you can enable extensions (pgvector).
• An embedding provider or model to produce vectors for index and query.

Minimal checklist to prepare:

• [ ] Clone the repo: https://github.com/cdnsteve/remembrallmcp
• [ ] Ensure Postgres is reachable and you can enable extensions
• [ ] Decide whether to run via Docker or cargo/build
• [ ] Gather a small validation corpus (example sizes listed in assumptions)

Notes: The repo is the authoritative starting point for code and design. See https://github.com/cdnsteve/remembrallmcp for the project description.

Step-by-step setup and implementation

1. Clone the repository

git clone https://github.com/cdnsteve/remembrallmcp
cd remembrallmcp
ls -la

This fetches the project source and any local README or build instructions. See the repo: https://github.com/cdnsteve/remembrallmcp

2. Start Postgres (example template)

Below is a generic Docker example. Replace placeholders with values you choose.

# Example: replace PASSWORD and DBNAME before running
docker run --name rem_pg -e POSTGRES_PASSWORD=PASSWORD -d postgres
# Wait until Postgres is ready, then connect to create extensions and schema

3. Enable pgvector and prepare schema

You will need to enable pgvector in the database that will hold vectors. Use psql or your DB client to run the appropriate CREATE EXTENSION statement. See the repo for schema hints: https://github.com/cdnsteve/remembrallmcp

4. Build and run the Rust service (template)

# If you have Rust installed
cargo build --release
./target/release/remembrallmcp --help

# Or build a container image (example) and run it
# docker build -t remembrallmcp .
# docker run --rm -e DATABASE_URL="postgres://..." remembrallmcp

5. Minimal config template

postgres:
  url: "postgres://USER:PASS@HOST/DBNAME"  # replace with your values
mcp:
  listen: "0.0.0.0:PORT"                  # choose an unused port
timeouts:
  connect_ms: 5000
  query_ms: 10000

This YAML is a template. Adjust credentials, host, and timeouts to your environment. See the project: https://github.com/cdnsteve/remembrallmcp

6. Index a small corpus and test retrieval

• Create a table with a text column, metadata (JSON), and a vector column.
• Insert a small number of documents and associated vectors from your embedding provider.
• Issue MCP requests from a test client and measure retrieval quality.

If retrieval quality is low, check embedding model parity and corpus cleanliness. See the repo for protocol and code: https://github.com/cdnsteve/remembrallmcp

Common problems and quick fixes

Service fails to bind to MCP port

• Verify no other process uses the chosen port. Check firewall rules.

pgvector not available

• Connect with psql and run CREATE EXTENSION IF NOT EXISTS pgvector; in the target DB.

Embedding/model mismatch

• Ensure you use the same embedding model/config for indexing and queries. If you change the model, re-embed and reindex your validation set.

High latency

• Confirm a vector index exists for the vector column. Monitor median and p95 latency to find patterns.

Quick diagnostics (examples):

# Check tables in the DB (replace URL)
psql "postgres://USER:PASS@HOST/DBNAME" -c "\dt"

# Tail a local service log file
tail -n 200 ./logs/service.log || journalctl -u remembrallmcp -n 200

Thresholds to watch (examples; see assumptions): median and p95 latency, recall@10, and corpus size growth. Reference: https://github.com/cdnsteve/remembrallmcp

First use case for a small team

Use case: a team of 1–3 people wants an agent to remember recent PR comments, design notes, and short snippets. Source: https://github.com/cdnsteve/remembrallmcp

Simple actionable plan:

1. Export and curate a small set of items for the index (see assumptions for recommended sizes).
2. Index those items with the same embedding model you will use for queries.
3. Run a set of validation queries and measure recall and latency.
4. Start with reads-only canary traffic before enabling writes.

Operational tips for a small team:

• Automate daily snapshots and keep a short retention window for ephemeral notes.
• Monitor recall and p95 latency for regressions.
• Keep a short rollback window for rapid recovery.

See the project for implementation details: https://github.com/cdnsteve/remembrallmcp

Technical notes (optional)

High-level architecture (from the repo): Rust service <-> Postgres + pgvector; the service speaks MCP to clients. Source: https://github.com/cdnsteve/remembrallmcp

Data model (conceptual): text, compact metadata (JSON), vector column. Use a vector index to avoid full-table scans and reduce query latency for modest corpus sizes. Monitor corpus count and index size as the dataset grows.

Scaling note: a single-node Postgres with pgvector is suitable for early tests. For larger corpora, evaluate partitioning, sharding, or a dedicated vector store and measure p95 latency as you grow.

What to do next (production checklist)

| Item | Target / Threshold | Action | |---|---:|---| | Canary traffic | 10% | Run a 24-hour canary before full rollout | | Staging corpus | 500 docs | Validate retrieval on a staging set | | Recall target | recall@10 >= 0.6 | Test with 20–100 queries daily | | Median latency (test) | < 200 ms | Alert if p95 > 500 ms | | Backup retention | 30 days | Daily automated snapshots | | Rollback window | 1 hour | Automated switch-off or restore snapshot |

Operational checklist:

• [ ] Daily DB snapshot with 30-day retention (example)
• [ ] Monitoring for median latency, p95, and recall@10
• [ ] Rate limiting and access control on MCP endpoint
• [ ] Documented rollback playbook with a 1-hour recovery SLA

See the repo for code and further context: https://github.com/cdnsteve/remembrallmcp

Assumptions / Hypotheses

• The repository is a Rust-based persistent memory layer that uses Postgres + pgvector and implements the MCP protocol. Source: https://github.com/cdnsteve/remembrallmcp
• Numeric targets in this document are conservative recommendations for initial validation and testing. Example values used as guidance: 30–120 minutes to stand up a demo, 4–8 hours to index and validate 100–500 documents, $0 local cost, 10% canary, 24-hour canary duration, recall@10 >= 0.6 (60%), median latency < 200 ms, p95 < 500 ms, staging corpus ~500 docs, retention windows (30 days, 365 days), and a 1-hour rollback window.
• Configuration snippets and port/timeouts shown above are templates. Specific ports, timeouts, and commands must be chosen for your environment and validated against the repository code and your security policies.

Risks / Mitigations

• Risk: Sensitive data stored inadvertently. Mitigation: enforce retention and access controls; keep writes disabled during initial canary.
• Risk: Embedding/model mismatch causes poor recall. Mitigation: use the same embedding model and provider for indexing and queries; reindex a validation set when models change.
• Risk: Latency spikes at scale. Mitigation: monitor p95 and median latency, run a canary, and roll back if latency exceeds thresholds for prolonged periods.

Next steps

1. Clone and inspect the project: git clone https://github.com/cdnsteve/remembrallmcp
2. Run a local end-to-end test with a small corpus and your chosen embedding model.
3. Validate recall on a curated set of 20–100 queries and measure median and p95 latency.
4. Run a 24-hour 10% read-only canary before enabling writes for full traffic.

One-line methodology note: the repository summary is the grounding reference (https://github.com/cdnsteve/remembrallmcp); numeric thresholds are conservative starting points to guide testing and rollout.

RemembrallMCP — Rust-based persistent vector memory for AI agents using Postgres, pgvector and MCP

Hands-on guide to run RemembrallMCP: a Rust service that stores embeddings and metadata in Postgres with pgvector, speaks the MCP protocol, and enables agent r…

https://aisignals.dev/posts/2026-04-10-remembrallmcp-rust-based-persistent-vector-memory-for-ai-agents-using-postgres-pgvector-and-mcp

(Weekly: AI news, agent patterns, tutorials)