Your memory, one URL away.
MemRails speaks MCP. Point any compatible client at one server URL and your memory shows up as tools your agent can call — query the stack, write a refactor, inspect a packet — with no glue code to write or integration to maintain. The same packet contract you already build against, exposed the way the rest of your stack expects it.
One endpoint, and memory becomes a tool.
Add the MemRails server to your client config and the retrieval stack registers itself as callable tools. No SDK to install in your agent, no adapter to keep in sync with the contract — the client discovers what's available and your model uses it.
{ "mcpServers": { "memrails": { "url": "https://mcp.memrails.dev", "transport": "http", "scope": "read" } } }
# client handshakes, lists capabilities → initialize ← tools: 3 resources: 1 memory.query # read memory.write # write memory.inspect # read memory://files # resource # ready — no code shipped
Three tools, the whole contract.
The server exposes the protocol as a small, legible tool surface. Each maps directly to the packet contract you already know — query returns a compressed packet, write proposes a refactor into the market, inspect opens provenance. Nothing new to learn.
Run a query through L1–L5 and return a compressed packet with confidence, token count, and provenance. The same synthesis the library and harness produce.
Propose a refactor — a new claim, a confidence change, a contradiction — into the refactor market. Staked, reviewed by validators, never silently applied.
Open a packet's lineage: the evidence bundle, the provenance weights, the input and output hashes. The Console inspector, available to your agent at call time.
If it speaks MCP, it speaks to your memory.
The server is a standard MCP implementation, so it works with any compliant client out of the box. No per-client adapters, no bespoke plugins — the same URL drops into all of them.
One server speaks to every client. Nothing per-integration.
One JSON block in the client's config. That's the whole install.
Tools are discovered live, so they can't fall out of sync.
Exposed on purpose, scoped by default.
Memory files surface as MCP resources, so a client can read the corpus directly when it needs to. Access is read-only until you grant write, and every scope maps to the same audit trail you see in Console.
Files, not a black box.
Markdown memory is published as memory:// resources. A client can list and read them directly — the source of truth, not a derived index.
Read-only until you say so.
A server starts read. Granting write opens memory.write into the refactor market — an explicit choice, never a default.
Every call, on the ledger.
Tool calls through MCP log exactly like every other packet — hashed in, hashed out, reconcilable. The transport changes; the audit trail doesn't.
Add it once, use it everywhere.
Drop the server into your client config and your agent has memory as a tool in five lines. Read-only by default, exportable always, audited the same as everything else.