PathruleAsked for,
or already there.
An MCP memory server lets an agent store and read back knowledge that outlives the session. The protocol settles how the agent talks to it. It does not settle when the knowledge arrives, and for a coding agent that decides whether it is ever used.
Recall on request
Done. The discount is applied to the order total.
Nothing suggested asking, so nothing was recalled.1 silent miss
Delivery at hook time
hook, before the first tool call
- Coupons attach to the line item, never to the order total.
Done. The discount is applied to each line item.
In context whether or not the agent would have asked.0 misses
Pathrule exposes MCP tools; it is not a memory MCP server. MCP is one of the ways knowledge reaches an agent, and Pathrule MCP is the page for Pathrule's own MCP surfaces. What sits behind it is an intelligence layer: project, personal and team knowledge kept as typed memories, rules and skills, scoped to paths, and delivered as the part a specific task needs, with strict rules checked at the hook on clients that have one rather than returned as text. Describing Pathrule as a memory MCP names the socket, not the system.
What a memory server is asked to do.
- Persist past the conversationThe minimum. Something written in one session is readable in the next, without the client holding it.
- Come back typedA memory, a rule and a procedure are different things. A server that returns one undifferentiated blob of text hands the agent the job of telling them apart.
- Be reachable from any clientThe reason to use the protocol at all. One store, many agents, no per-agent copy of the same knowledge.
- Say what a request is scoped toFor a coding agent the scope that matters is the path being worked in. Without it every read returns the whole store and the client pays for the difference.
Recall on request. Delivery before it starts.
- The agent calls a tool when it decides it needs something.
- Nothing arrives for a constraint the agent never suspected.
- Scope is whatever the agent passes in the arguments.
- Works from a cloud-only client with nothing installed.
- Context only. There is no pre-write event to hook.
- The matching slice arrives before the first tool call, at the hook points the client exposes.
- The constraint is in context whether or not the agent would have asked.
- Scope is the working directory the hook can actually see.
- Needs Pathrule on the machine: the CLI or the VS Code extension.
- A strict rule can block a violating change before it lands, where the Pathrule hook runs (Claude Code and Codex).
Side by side with the protocol's own reference implementation: Pathrule vs the MCP memory server. Sources: Model Context Protocol: reference memory server, Model Context Protocol: specification.
Same protocol, different job.
A reference memory server is a place an agent can put things. A context layer decides which knowledge belongs to which part of the tree and gets it in front of the agent before it starts. If one person wants durable scratch memory on one machine, the reference server is the smaller and better answer. Pathrule is what the second person or the second agent makes necessary.
Local server or hosted endpoint.
$ pathrule setup
- Resolves your working directory
- Sits beside the hooks setup installs
- Local mode with no account
- Every supported client can use it
$ claude mcp add --transport http pathrule https://cloud.pathrule.io/mcp
- Nothing to install
- Signs in with a Pathrule account
- No hooks, no local files
- Answers on request, never before
Both use MCP and the same workspace knowledge types. Local stdio and Remote MCP have different tool catalogs and argument schemas; inspect tools/list on the server you connect.
Connecting a client
Claude Code
Codex
Cursor
GitHub Copilot
WindsurfQuestions.
What is an MCP memory server?
A Model Context Protocol server whose tools let an agent store knowledge and read it back in a later session. Because it speaks MCP, any MCP client can connect without a bespoke integration, which is what makes the memory portable across agents.
Does MCP define how memory should work?
No. MCP settles the transport and the tool contract, not the memory model. Two MCP memory servers can agree on every message and still disagree about what a memory is, how it is scoped and whether the agent has to ask for it.
Why is MCP memory not enough on its own for a coding agent?
Because an MCP tool is pull: the agent calls it when it decides it needs something. A constraint the agent does not know exists never gets asked about, so nothing arrives, and the failure is silent. Delivery before the first tool call is what covers that case, and it needs a hook on the machine rather than a protocol feature.
How is Pathrule different from the MCP reference memory server?
The reference server is a knowledge graph of entities, relations and observations persisted to a JSONL file on one machine: a good place for an agent to put things. Pathrule adds path scope, team membership, typed rules with enforcement, and delivery before the first tool call in Claude Code and Codex, where it installs its hook. Full side by side: Pathrule vs the MCP memory server.
Do I need to install anything to use Pathrule over MCP?
Not for a client that supports Remote MCP. The hosted endpoint at https://cloud.pathrule.io/mcp connects with OAuth and a Pathrule account, with nothing installed: Claude Code, Codex and Claude.ai are documented, and any client that supports Streamable HTTP with OAuth can use the same URL. To get hook-time delivery, or to run with no account in local mode, install Pathrule CLI (npm i -g @pathrule/cli, then pathrule setup) or the VS Code extension.
Can the hosted endpoint enforce a strict rule?
No. It has no pre-write event to hook, so it delivers rules as context and cannot block a change. Pathrule CLI and the VS Code extension register the Pathrule hook for Claude Code, and for Codex when the repository has Codex files, where a strict rule with an approved block pattern can stop a matching edit. Cursor, GitHub Copilot, Windsurf and Remote MCP receive rules as context only.
Which MCP clients can connect to Pathrule?
Any client that speaks the protocol. pathrule setup connects Claude Code, Codex, Cursor, GitHub Copilot and Windsurf to the local server, with hooks and instruction files for Claude Code and Codex, and clients that support Streamable HTTP with OAuth can use the hosted endpoint. The MCP overview covers the roles, and Integrations shows how each agent is connected.
Is my source code sent to the MCP server?
Not automatically. Pathrule does not scan or upload your source code on its own. The server carries the memories, rules and skills your team writes. In cloud mode the start of each prompt is sent to rank what applies. Full breakdown on the Security page.