MCP Memory Server: 3 Token Costs Nobody Quotes You Upfront

An MCP memory server adds memory to your AI client, and a token bill with it. See the 3 hidden costs, the math, and how lazy loading cuts them.

Connect enough tools to Claude Desktop or Cursor and something strange happens before you have done any work at all: your context is already crowded. Every connected server announces its capabilities to the client, every announcement costs tokens, and those tokens ride along on every single request you make afterwards. A memory server is the popular answer to agent forgetfulness, and it is also a perfect case study in how the Model Context Protocol bills you for convenience.

This article is the protocol-level view of the problem, written for people choosing an MCP memory server rather than building one from scratch. It explains what an MCP server actually announces, why the announcements cost more than people expect, where a memory server specifically adds weight, and how lazy schema injection changes the math. When you finish reading, you should be able to estimate what your current setup costs per request before you have written a line of code, which is a useful superpower in a year when everyone is connecting everything to everything.

Diagram of an MCP memory server connected to AI clients with tool announcements consuming context tokens
The hidden layer: every connected server speaks first, and every word of it lands on your bill.

What an MCP memory server actually is

Direct answer: an MCP memory server is a program that implements the Model Context Protocol, the open standard by which AI clients talk to external tools, and exposes memory operations, such as storing and retrieving project facts, as tools the client can call. It usually runs locally over stdio, the simple stream-based channel between a client and a child process, and it keeps its data wherever it is configured to keep it, from a JSON file to a database.

The protocol part matters because it is the contract that sets the costs. When your client starts a session with a server, the server sends back a list of the tools it offers, and each tool comes with a name, a description and a schema, which is the structured definition of what arguments the tool accepts. The client folds all of that into the context it sends to the model. This is not a bug or a trick; it is how the model is supposed to learn what it can do. The cost is simply the flip side of the design, and it explains why an MCP memory server that looks free in a README is rarely free in an invoice.

A memory server tends to be chattier than most, and this is worth knowing before you pick one, because schema weight varies more between implementations than any other property. Memory tools need expressive arguments, what to store, how to tag it, how to scope it to a project, so their schemas run longer than a simple calculator tool’s. The result is that the most useful server in your stack is often one of the most expensive ones to keep connected.

Anatomy of an MCP tool announcement showing name, description and argument schema that consume context tokens
What an announcement is made of: name, description, schema. Every field rides on every request.

Cost 1: the announcement tax on every request

The first cost is the one nobody quotes about running an MCP memory server: tool announcements are re-sent with every request. When you type a message, the client ships the whole conversation, plus every connected server’s tool list, to the model. You pay for the announcements again. And again. On every step of every task, whether or not the task ever touches those tools.

Run the arithmetic on a realistic stack with one MCP memory server and four other tools connected. Say five connected servers announce a combined 6,000 tokens of tool definitions, which is not unusual once descriptions and schemas are counted honestly. A working session that runs 200 model requests re-sends those 6,000 tokens 200 times: 1.2 million tokens spent describing tools, most of which were never called. At typical API pricing, that is a meaningful slice of the month’s bill spent on introductions.

StackAnnounced tokensRequests per dayAnnouncement tokens per month
2 servers, lean tools2,000100~400,000
5 servers, mixed6,000200~2,400,000
8 servers, chatty schemas12,000300~7,200,000

The table is deliberately conservative on descriptions, because vendors keep making them longer, not shorter. Whatever your exact numbers, the shape is the same: announcement cost scales with servers times requests, and neither factor is going down on its own.

Comparison of dense 200-token memory summaries against verbose 2000-token retrievals competing for context attention
Two retrieval styles, one budget: dense state versus loose association.

Cost 2: memory content competing for attention

The second cost is subtler than billing. A memory server does more than announce its tools; when it serves memories, those memories enter the context too, and context is a budget. A server that retrieves generously, the top twenty facts loosely related to your question, spends the budget on material the model must read, weigh and ignore. Retrieval that is too tight has the opposite failure: the fact that mattered was not fetched, and the agent confidently proceeds without it.

This is the quality problem that separates one MCP memory server from another. The good ones are dense by design: a compact summary of project state, scoped to the current project, injected once at turn start. The expensive ones are verbose by default: every retrieval drags in paragraphs of related-but-not-relevant history. When you evaluate any MCP memory server, ask what it injects per turn and read a sample. The difference between 200 tokens of distilled state and 2,000 tokens of loose association is both a quality difference and a 10x cost difference on the same line item.

Cost 3: the duplicated-layer trap

The third cost of an MCP memory server shows up when teams stack memory solutions. A memory MCP server on top of the client, plus a notes file in the repo, plus a hosted memory API someone tried last quarter, plus the client’s own session history: four layers storing overlapping facts, each with its own staleness. The agent reads contradictory versions of the same truth and resolves the conflict arbitrarily, which is a polite way of saying randomly.

Duplication also multiplies the announcement tax, because each layer is typically its own server with its own tool list. The fix is architectural discipline rather than more software: one memory layer, one write path, one summary injected per turn. Your MCP memory server should be the only memory layer you run. Everything else should be deleted, not tolerated.

Diagram of duplicated memory layers in an AI client stack causing contradictory context and extra token costs
Four layers, four truths: duplication costs tokens and buys contradiction.

How lazy schema injection changes the math

The engineering answer to the announcement tax is to stop paying it for tools you are not using, and it is the single most valuable feature to look for in an MCP memory server in 2026. Lazy schema injection means the server holds its tool definitions back until a tool is actually needed, then supplies the schema for that tool at the moment of use. The client’s context stays lean on ordinary requests, and the model still gets full instructions when it reaches for the tool.

Done across a whole stack, the savings are large. SOVEL Net-Routed Agentic OS implements this as a design target of cutting prompt context bloat by 65 to 80 percent, and the mechanism is exactly the one described here: fewer tokens of standing announcements, more tokens of actual work. The protocol allows this; most servers simply have not optimized for it, because the bill lands on the user’s API account rather than on the server’s own costs. That misalignment is worth noticing: the party choosing your schema weight is rarely the party paying for it.

For an MCP memory server specifically, lazy injection has a second benefit. Memory tools are called rarely, a few writes per turn at most and reads on demand, so they are the ideal candidates for deferred schemas. The memory layer stays connected and useful while its standing cost approaches zero, which is the shape you want: maximum capability, minimum footprint.

Flow diagram comparing eager tool schema announcements on every request with lazy schema injection loaded only at the moment of use
Eager versus lazy: one pays the announcement tax on every request, the other pays at the moment of use.
Checklist graphic of five evaluation criteria for choosing an MCP memory server
Five questions before you connect: announcements, injections, storage, scoping, write path.

Choosing and configuring an MCP memory server

If you are evaluating one, the checklist is short and mostly about costs:

  • What does it announce? Count the tokens of its tool definitions. Ask the vendor if the number is not published; a server that cannot answer has not looked.
  • What does it inject per turn? Read a real sample of what enters your context. Density beats volume, and 200 tokens of state beats 2,000 of association.
  • Where does the data live? Local file or database keeps project context on your disk; a hosted store means your facts ride on someone else’s infrastructure and retention policy.
  • Does it scope per project? Memory that leaks between projects is worse than no memory, because the agent gets confidently wrong.
  • Is there one write path? If it cannot be your only memory layer, it will become one of several, and duplication brings back cost 3.

For the exact JSON configuration blocks for Claude Desktop, Cursor and Cline, the next article in this series is the practical one: Claude Desktop MCP setup, step by step with the errors each client throws when a server is misconfigured. And for the marketing-side view of MCP servers as products, our MCP server marketing workflow piece covers the go-to-market angle.

Frequently asked questions

What is an MCP memory server?

It is a program that implements the Model Context Protocol and exposes memory operations, storing and retrieving project facts, as tools your AI client can call. Most run locally over stdio and keep data in a local file or database. It gives agents continuity between sessions, which is the capability clients lack by default.

Why does an MCP memory server cost tokens before I use it?

Because of the announcement tax: the protocol requires servers to declare their tools, with names, descriptions and argument schemas, and the client includes those declarations in the context of every request. You pay for the descriptions on every step whether or not the tools are called.

How many tokens do MCP tool announcements use?

It depends on the server, but a realistic stack of five servers announces around 6,000 tokens combined, and chatty schemas push that higher. Multiplied by the number of requests in a session, announcements can reach millions of tokens per month, which is real money spent on introductions.

What is lazy schema injection?

It is the technique of holding tool schemas back until a tool is actually needed, then supplying the schema at the moment of use. This keeps ordinary requests lean while preserving full capability. SOVEL Net-Routed Agentic OS uses it as the basis of its measured design target of cutting context bloat by 65 to 80 percent.

Should memory live in an MCP server or in the client?

In a server you control, ideally local. Clients are rebuilt and replaced; memory should outlive them. A local MCP memory server keeps the store on your disk, survives client switches, and avoids sending project context to a hosted third party.

Can I run more than one memory server at once?

You can, and you mostly should not. Multiple memory layers store overlapping facts with independent staleness, and the agent receives contradictory versions of the same truth. One layer, one write path, one summary per turn is the architecture that survives contact with real projects.

Pay for capability, not for introductions

The Model Context Protocol is a good protocol carrying an unfortunate default: everything announces itself, always, and you foot the bill. A memory server is worth having precisely because memory is the capability agents lack most, and it is worth auditing precisely because its announcements are among the heaviest. Count what your stack announces, prefer lazy injection where it exists, keep one MCP memory server with one write path, and spend the savings on work instead of introductions. The full engine that implements this, memory plus loop protection plus guarded execution in one local install, is documented on the SOVEL Net-Routed Agentic OS product page.

Connected Systems & Architecture

This publication connects directly to the formal SOVEL software registry, production engines, and architectural documentation: