RAGpipeline, you're one "hallucinated leak" away from a HR nightmare.
I've been deploying Mwe-MCP to see if it can handle the chaos of a multi-user environment. Unlike standard vector DBs, this is an MCP server that uses a "wiki" structure where every single item in a list or paragraph of prose has its own Access Control List (ACL). This means the engine redacts information before it ever reaches the agent. If a junior dev asks the agent about project timelines, they get the data; if they ask about the lead architect's salary, the agent simply doesn't "see" that part of the memory.
How the memory architecture actually works #
The system doesn't just dump text into a database. It uses a specific "REM phase" for data hygiene. During the day, the agent captures fragments of information (often messy or redundant). At night, or during scheduled cycles, a reconciler LLM re-orders these pages and cleans up the prose.
For those looking at a deployment, here is the technical breakdown of the stack:
Binary: Single Rust binary (handles the MCP endpoint and admin dashboard).Protocol: Streamable HTTP with OAuth.Logic: It uses a "navigator" approach. Instead of a simple similarity search, it finds an entry point in the wiki and then follows links to gather full context.
Real-world performance and constraints #
I've noticed a massive difference in "stray memory" recall. Because the data is stored as linked prose rather than isolated chunks, the agent can surface related facts that weren't explicitly queried. For example, if I'm asking for a technical solution for a client, the agent can pull in a "stray" memory about that client's specific legacy infrastructure constraints mentioned three months ago, because those facts are narratively linked in the wiki.
However, there are some hard limits you need to know before trying a deep dive:
Model Requirements: You cannot run the internal routing/reconciliation on tiny local models. I've found that 7B models often route poorly, leading to fragmented wikis. You need a reasonably capable LLM (Claude3.5 or GPT-4o) for the backend processing.OS Support: It's built in Rust, but Windows support is currently "best-effort." It runs flawlessly on Linux/macOS.Deployment: It's an AGPL license, so self-hosting is the way to go.
Implementation Example: Setting up the MCP Server #
If you're trying to integrate this into your AI workflow, you'll need to configure your MCP client to point to the server. Since it runs the dashboard and endpoint on the same port, your config will look something like this:
{
"mcpServers": {
"mwe-memory": {
"command": "mwe-mcp",
"args": ["--port", "8080"],
"env": {
"LLM_API_KEY": "your_key_here",
"MEMORY_DB_PATH": "/data/mwe_memory.db"
}
}
}
}
The biggest win for us has been the "shared yet private" nature of the memory. We have a team wiki that the agent manages, but because of those inline ACLs, the agent behaves like a teammate who knows exactly who is allowed to know what. It's a huge step up from the "all-or-nothing" approach of basic prompt engineering.
Next Scaling MCP Agent Teams: Moving Past the Single-Agent Ceiling →