I’ve been experimenting a lot with local AI coding workflows, and I kept running into the same problem:

Even with large context models, repositories are still far bigger than the context window.

After a few prompts the model forgets:

• architecture decisions
• relationships between modules
• previous exploration of the codebase
• design notes or reasoning

So you end up re-explaining the same things over and over.

I built Memento to try to solve that.

What it is

Memento is a local-first MCP server that gives AI agents durable memory about a repository.

Instead of repeatedly injecting large context into prompts, the model can query the repository memory layer through MCP.

For those not familiar with it, MCP (Model Context Protocol) is an open standard for connecting AI applications to external tools and data sources.

https://modelcontextprotocol.io

This lets agents retrieve context only when they need it, instead of bloating prompts.

What Memento stores

The server builds and maintains high-signal structured knowledge about the repo, such as:

• indexed repository structure
• semantic relationships between modules
• searchable contextual notes
• architecture summaries
• persistent design decisions

The goal is to give the model fast access to relevant context without burning the context window.

Design philosophy

A few things I tried to optimize for:

Local-first

Everything stays on your machine.

Hybrid deterministic + LLM workflows

Where possible things stay predictable and reversible.

High-signal memory

Focus on information that actually helps the model reason about the project.

Durable across sessions

Agents don’t start from zero every time.

Why this helps

In practice this improves things like:

• navigating large repos
• multi-file reasoning
• architecture understanding
• incremental refactors
• avoiding repeated explanations

It makes AI assistants feel less stateless and more like they actually remember the project.

Experimental at this point, but in my N = 1 experiment has been working pretty consistently mostly coded Go though. please let me know if you try it.

Curious how others are solving this

I’m interested in hearing how people here are dealing with:

• repository memory for agents
• context window limitations
• MCP tooling
• repo indexing approaches

If people are interested I can also share more about:

• architecture
• indexing strategy
• memory model
• MCP integration <-this is a pain.in.the.Mass

Would love feedback from anyone experimenting with local AI dev tooling.

(ISSUES AND PRs ARE VERY WELCOME, TRULY FOSS, MIT LICENSE)