Veracium

Provenance-aware memory for AI agents — durable, per-user memory that resists the injection and confabulation failures of naive memory.

Veracium gives your AI agent a long-term memory of each user it serves. Out of the box, an agent forgets everything between sessions; with Veracium it remembers what it learns — who the user is, what they prefer, where they work, what changed — and carries that into every future conversation. A small Python library, plus an MCP server so Claude Desktop, Claude Code, or any MCP client can use it without writing code.

remember — store what happened: chat turns, emails, documents, tool output.
recall — get the relevant memory back as context for any prompt.
answer — ask questions and get answers grounded in what's actually known.

Why this memory layer and not a vector store or your framework's built-in memory:

Structural quarantine — what an email or document claims is stored as a claim, never as a fact about you. That rule is built into the data model itself — there's no filter for a convincing scam to talk its way past.
Grounded or silent — an abstention gate that says “I don’t know” instead of guessing.
Supersession, never erasure — current facts with history retained.
Embedded & private — one SQLite file, bring your own model, nothing phones home.

$ pip install veracium

Example code ↓ GitHub Docs PyPI

v0.2 — MIT-licensed, on PyPI. Every guarantee above ships with a self-check you can run: veracium selfcheck.

Wire it up

The whole integration is one object and three calls — no services to run, no schema to design. Bring any model (AnthropicComplete is a convenience; any callable works, including local models via the OpenAI-compatible example provider).

from veracium import Memory, EvidenceAuthor
from veracium.llm.anthropic import AnthropicComplete

mem = Memory(llm=AnthropicComplete())   # or pass your own Complete callable

# Remember interactions. `author` is the trust-critical input.
mem.remember("alice", "USER: I'm vegetarian and have a dog named Ollie.")
mem.remember("alice", "From billing@scam: you owe $900.",
             author=EvidenceAuthor.THIRD_PARTY, event_type="email")

# Recall grounded, provenance-flagged context for any prompt...
ctx = mem.recall("alice", "suggest a lunch spot")
print(ctx.context)   # the vegetarian constraint as fact; the $900 "claim"
                     # rendered under a never-assert flag — not as truth

# ...or ask directly through the abstention gate:
mem.answer("alice", "Do I owe anyone money?")
# → reports the $900 only as an unverified third-party claim; asserts nothing

Using Claude Desktop or Claude Code instead? No code at all — the bundled MCP server exposes the same memory as tools (remember / recall / answer / maintain) with one config block:

{
  "mcpServers": {
    "veracium": {
      "command": "veracium-mcp",
      "env": {
        "ANTHROPIC_API_KEY": "sk-...",
        "VERACIUM_DB_PATH": "/home/you/.veracium.db"
      }
    }
  }
}

Full quickstart in the docs, or run the end-to-end scam-email demo notebook in Colab. Integrating with LangChain? There's a worked example too.