Yunaki Memory MCP
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@Yunaki Memory MCP remember that we use Prettier for formatting"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
Yunaki Memory MCP
Git-backed, per-repo memory for coding agents, exposed as an MCP server.
Each git repo the server is used in gets its own memory store. The store is a separate git repository under ~/.yunaki/memory/<repo-id>/. Every memory_write is a commit, and each memory_ingest run is one commit. What an agent records about a repo becomes plain-text history you can read, diff and revert. Memories are never written into your project's files. The one thing the server writes inside your repo is an id in .git/config, and only for a repo that has no commits yet.
How it works
Stable repo identity. A repo is keyed by its root-commit SHA (
git rev-list --max-parents=0 HEAD, first 12 chars). On your machine, its memory stays with it after a re-clone, a rename or a remote change. A shallow clone (git clone --depth ...) reports a different root commit, so it gets a separate store. A repo with no commits gets a UUID cached in its.git/config(yunaki.memoryId). After its first commit, the repo is keyed by its root commit, and the UUID store is not carried over.Created on first use. Every tool call resolves the repo first. If the path is not inside a git repository, the call returns an error. On first touch the server
git inits the store, seedsrepo.jsonandMEMORY.md, and commits.One file per memory. Each memory is a Markdown file with YAML frontmatter at
<type>/<slug>.md, so every change is a small, separate diff.MEMORY.mdis rebuilt as an index on every write.Seed from the repo.
memory_ingestwritesreferencememories built from the repo's file list, itspackage.jsonand its docs. A new store then starts with an overview of the repo rather than empty.
~/.yunaki/memory/<repo-id>/ # its own git repo (root overridable with YUNAKI_MEMORY_ROOT)
├── repo.json # root commit, remote, last seen path, createdAt
├── MEMORY.md # index, sorted by confidence
├── heuristic/use-pnpm-in-this-repo-not-npm-lockfile-is-pnpm-lock-yaml.md
└── reference/
├── repo-overview.md
├── repo-structure.md
└── doc-readme-md.mdA memory file:
---
id: use-pnpm-in-this-repo-not-npm-lockfile-is-pnpm-lock-yaml
type: heuristic
tags:
- tooling
- package-manager
confidence: 0.5
usage_count: 0
last_used: '2026-06-28'
status: active
source: ''
created: '2026-06-28'
updated: '2026-06-28'
---
Use pnpm in this repo, not npm — lockfile is pnpm-lock.yaml.Related MCP server: memory-mcp
Tools
Tool | What it does |
| Saves a memory of type |
| Scores each memory by how many query terms appear in its id, tags and body, adds its confidence, and returns the top |
| Lists tracked files plus untracked files that are not gitignored, then writes three kinds of |
| Shows the resolved repo id, remote, root, memory directory and entry count. |
Every tool takes an optional repoPath, which can be any path inside the target repo. Without it, the server uses YUNAKI_REPO if that is set, and otherwise its own working directory (Claude Code starts it inside your project).
Install
Requires Node 18+ and git on your PATH. The server speaks MCP over stdio, so each person runs a local copy against their own repos.
From GitHub with npx (the prepare script compiles the TypeScript on install):
claude mcp add yunaki-memory -- npx -y github:Nanda-Kiran/yunaki-memory-mcpOr clone and build:
git clone https://github.com/Nanda-Kiran/yunaki-memory-mcp.git
cd yunaki-memory-mcp && npm install && npm run build
claude mcp add yunaki-memory -- node "$(pwd)/dist/index.js"Or commit a .mcp.json to share the config with collaborators:
{
"mcpServers": {
"yunaki-memory": {
"command": "npx",
"args": ["-y", "github:Nanda-Kiran/yunaki-memory-mcp"]
}
}
}Memory is stored per user. Installing the server does not share memories between people.
When you adopt a repo, run memory_ingest once to seed it.
Develop
npm install
npm run build
npm run smoke # temp repo: two writes, a search, the store's git log, a re-open
node test/ingest-smoke.mjs # run from the repo root: ingests it twice, prints the entry count before and afterBoth scripts point YUNAKI_MEMORY_ROOT at a temp directory, so they leave ~/.yunaki alone. They print their results without asserting on them, so they fail only if a call throws.
File | Role |
| MCP server and tool schemas (zod) |
| Repo identity and lazy store creation |
| Memory files, index, search |
| Repo scan, stack detection, file tree, doc capture |
| git calls via |
| Store root, default repo, memory types |
Stack: TypeScript, Node.js, @modelcontextprotocol/sdk, zod, gray-matter, git.
Status
v0.1.0, early. The per-repo store and the four tools are implemented and exercised by the two smoke scripts above. There are no assertion-based tests and no CI yet. The package is not published to npm. confidence and usage_count are stored, but nothing updates them yet. Every new memory is written at 0.5, so search ranking currently comes down to keyword hits.
Known gaps:
Ingest matches doc names by prefix anywhere in the tree, so a file such as
scripts/install.shis captured as a doc.Ingest does not remove entries for docs that were deleted or renamed.
No tool sets
status: deprecatedyet. Search honors it only if you edit a memory file by hand.A shallow clone gets its own store (see How it works).
Roadmap (not built yet)
memory_reinforce(id, outcome): raise or decayconfidenceandusage_countinstead of writing duplicates.Dedup before write: match near-duplicates by slug or meaning so reinforcement replaces them.
memory_consolidate(): merge duplicates, prune stale entries, and promote high-confidence memories into a Claude skill'sSKILL.md, so the skill's improvements show up as a git diff.Embedding rerank, cached in an
.index/directory kept out of each store's git history.memory_sync(): push and pull each store to a remote for shared team memory.
License
MIT
Available Tools
4 toolsmemory_ingestIngest repo contentA
Scan the current git repo (tracked + non-ignored files) and write reference memories: a repo overview (stack, npm scripts, file types), the file-structure tree, and the contents of docs (README, CONTRIBUTING, docs/*). Idempotent — re-running updates the same entries in a single commit. Run this once when adopting a repo to seed memory.
Inputs: maxDocs, maxDepth, repoPath, maxDocBytes.
memory_repo_infoRepo memory infoC
Show the resolved identity and memory location for the current git repo.
Inputs: repoPath.
memory_searchSearch memoryA
Retrieve relevant memories for the current git repo, ranked by keyword match blended with confidence. Empty query returns the highest-confidence memories.
Inputs: query (required), tags, type, limit, +1 more.
memory_writeWrite memoryA
Persist a memory for the current git repo. Auto-creates the repo's git-backed memory store on first use and commits the write.
Inputs: content (required), tags, type, title, +2 more.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
TDQS
Scored across 4 tools
Each tool has a clearly distinct purpose: ingest scans and writes repo memories, repo_info shows identity, search retrieves memories, and write persists new ones. No overlap or ambiguity.
All tools start with 'memory_' prefix, but three use verbs (ingest, search, write) while one uses a noun phrase (repo_info). This slight inconsistency is minor but noticeable.
4 tools is appropriate for a focused memory MCP server. It covers the essential operations without being too few or too many.
Covers core operations (ingest, write, search, info) but lacks explicit update or delete functionality. The ingest tool is idempotent and can overwrite, but direct memory removal is missing.
Maintenance
Related MCP Connectors
Shared work memory for Claude Code, Codex, Cursor and chat, scoped to each repository.
Persistent memory for Claude Code and Cursor. Stop re-explaining your project every session.
Persistent, governed institutional memory for Claude Code — specs, decisions, learnings.
Persistent cross-session memory shared by Codex, Claude Code, ChatGPT, and other AI agents.
Related MCP Servers
- AlicenseBqualityDmaintenanceA persistent memory layer for Claude Code that maintains project information, technology stack, tasks, decisions, and session history between coding sessions, eliminating the need to re-explain project context.9MIT
- AlicenseAqualityDmaintenancePersistent memory and automatic git snapshots for Claude Code, capturing decisions, patterns, and architecture across sessions.10121 npm100MIT
- FlicenseNot gradedqualityDmaintenanceA persistent personal memory system for Claude that accumulates and organizes knowledge over time using plain Markdown in a local git repo, providing tools for reading, searching, and capturing short-term memories.1-
- AlicenseNot gradedqualityDmaintenancePersistent memory for Claude Code — a self-evolving knowledge layer that survives across sessions, grows from every conversation, and surfaces relevant context automatically.14MIT