Git Memory Vault
karimassalihi-bot/git-memory-vault
Memória semântica nativa para projetos Git integrada ao Claude Code
Ver no GitHubMCP server que transforma notas Git em um grafo semântico de memória associativa. Integra-se com Claude Code para injetar contexto relevante automaticamente nas sessões de trabalho, permitindo busca semântica de notas vinculadas ao histórico de commits e relacionamentos entre conceitos do projeto.
Instalação
npx convez-ai karimassalihi-bot/git-memory-vault1 comando no terminal: detecta o formato do repositório (marketplace ou plugin avulso) e instala via Claude Code. Requer Node 18+ e o Claude Code instalado.
Métricas
Casos de uso
- Recuperar contexto de decisões arquiteturais durante refatorações
- Rastrear insights de debugging vinculados a commits específicos
- Pesquisar relacionamentos conceituais entre partes não-óbvias do codebase
Veredito

Ferramenta sólida para developers que usam Claude Code e buscam contextualização inteligente. O conceito de embarcação semântica em Git Notes é genuinamente útil, mas a adoção depende de disciplina na escrita de notas e disponibilidade de APIs de embedding.
README
A tradução para o português deste README ainda está na fila.
Git Notes Graph: Semantic Memory Engine for Claude Code Workflows
Transform your Git repository into an associative memory palace — where every commit note becomes a node in a living knowledge graph that Claude Code can traverse, query, and learn from.
Why Git Notes Graph Exists
Traditional note-taking tools are filing cabinets. You open a drawer, you look at a single sheet. Git Notes Graph is different: it treats your codebase and your notes as an interconnected neural landscape. Every concept, every insight, every debugging revelation becomes a neuron with dendrites reaching into your actual source code history.
For Claude Code users, this means your AI assistant isn't just reading files — it's understanding the context, the why behind each decision, and the relationships between seemingly unrelated parts of your project.
The Architecture of Thought
Git Notes Graph builds on Git's native notes system, extending it with semantic embedding, relationship mapping, and recursive querying capabilities that transform how Claude Code interacts with your project memory.
flowchart TB
USER[Developer] -->|writes notes| CLI[Git Notes CLI]
CLI -->|stores in| GIT[Git Notes Ref]
GIT -->|feeds into| EMB[Semantic Embedder]
EMB -->|creates vectors| VEC[(Vector Store)]
CLAUDE[Claude Code Session] -->|asks question| QPROC[Query Processor]
QPROC -->|embeds query| VEC
VEC -->|returns relevant notes| MERGE[Merge Engine]
MERGE -->|builds context| CONTEXT[Enriched Context Window]
CONTEXT -->|delivers to| CLAUDE
GIT -->|commit links| HOOKS[Git Hooks]
HOOKS -->|auto-annotate| COMMITS[Commit History]
subgraph SEMANTIC_LAYER[Semantic Layer]
EMB
VEC
end
subgraph MEMORY_LAYER[Memory Layer]
GIT
HOOKS
COMMITS
end
The diagram above reveals the elegance of the system: notes stored in Git's native format are transformed into vector embeddings, enabling Claude Code to perform semantic search across your entire project memory — not just string matching, but conceptual retrieval.
Example Profile Configuration
Every developer's memory system should reflect how they think. Here's a profile configuration that turns Git Notes Graph into a personalized cognitive scaffold:
# ~/.config/git-notes-graph/profile.yaml
profile:
name: "contextual-engineering"
embedder:
provider: openai
model: text-embedding-3-small
dimension: 1536
storage:
backend: git-notes
branch-ref: refs/notes/commits
indexing:
auto-index-on-commit: true
chunk-size: 512
overlap: 64
claude:
context-injection: semantic-top-k
max-notes-per-query: 10
relevance-threshold: 0.75
os:
integration: cross-platform
cache-directory: ~/.cache/git-notes-graph
This configuration tells the system to embed notes using OpenAI's text-embedding-3-small model, store them in Git's notes system, and inject the top 10 most semantically relevant notes into every Claude Code context window. The 0.75 threshold ensures only highly relevant memories surface — think of it as your cognitive noise filter.
Example Console Invocation
Once configured, using Git Notes Graph feels like having a second brain that speaks Git and Claude Code fluently:
# Store a new note linked to the current commit
$ git graph note "The pagination refactor in commit a3f2b1 reduced API latency by 40%. Key insight: cursor-based pagination outperformed offset-based because of database index utilization."
# Automatically, this note is embedded and stored in the vector index
# Later, in a Claude Code session:
$ claude graph query "Why did we change the pagination approach?"
# Claude Code receives not just the pagination note, but all semantically related notes about performance, database indexing, and the API architecture
# Search your entire project memory
$ git graph search "performance optimization patterns"
# Returns ranked notes from across all commits, ordered by semantic relevance
The console commands mirror Git's familiar interface while extending it into a semantic dimension. git graph note becomes your memory's hippocampus — encoding experiences into retrievable patterns. git graph search becomes your prefrontal cortex — retrieving relevant memories based on conceptual similarity rather than exact matches.
Operating System Compatibility
Git Notes Graph runs where Git runs. Our commitment to cross-platform compatibility means your memory system travels with you.
| Operating System | Native Support | Verified Version | Notes |
|---|---|---|---|
| Linux (Ubuntu 22.04+) | Full | 2.34+ | Native performance, full feature set |
| macOS (Monterey+) | Full | 2.37+ | Homebrew-compatible installation |
| Windows 10/11 | Full (WSL2) | 2.41+ | Native Windows support via Git for Windows |
| Windows 10/11 | Native | 2.41+ | Limited hook support without WSL |
| FreeBSD | Full | 2.38+ | Tested on 13.x |
| Alpine Linux | Full | 2.40+ | Docker-optimized deployment |
The system's architecture ensures that whether you're developing on a Linux server, a macOS workstation, or a Windows laptop, your semantic memory layer remains consistent and accessible.
Feature Landscape
Git Notes Graph is not a simple note-taking tool. It's a cognitive augmentation system designed for the modern AI-assisted development workflow.
Semantic Context Injection for Claude Code
The flagship feature: Claude Code doesn't just see your prompt. It sees your entire project memory, filtered through semantic relevance. When you ask about a bug, Claude Code receives notes about similar bugs, related architectural decisions, and historical context — all without you typing a single additional word.
Embedding Provider Flexibility
Choose your semantic backbone:
- OpenAI API: text-embedding-3-small, text-embedding-3-large, text-embedding-ada-002
- Claude API: claude-3-haiku embedding endpoint (coming 2026 Q2)
- Local Models: Support for sentence-transformers and Ollama embeddings for air-gapped environments
Multilingual Memory Support
Your codebase might have comments in English, documentation in Japanese, and commit messages in Spanish. Git Notes Graph's embedder handles all major languages with SOTA accuracy. The vector space is language-agnostic — a Chinese comment about "database optimization" surfaces alongside an English note about "index tuning."
Responsive CLI Interface
The command-line interface adapts to your terminal width, supports dark and light themes, and provides real-time feedback during embedding operations. When you run git graph index --all, the progress bar isn't just aesthetic — it shows estimated time remaining based on your actual embedding throughput.
24/7 Automated Indexing
Git hooks automatically index new notes when you commit, stash, or rebase. Your memory layer is always up to date, requiring zero manual intervention. The background indexer respects your CPU limits and pauses during high-load operations.
SEO Keywords and Discoverability
Git Notes Graph occupies a unique intersection of developer tools, AI augmentation, and knowledge management. Here's what the project is optimized for:
- semantic memory engine for claude code
- git notes knowledge graph
- ai-assisted developer memory system
- vector search for git repositories
- context enrichment for large language models
- developer productivity augmentation tool
- semantic git notes manager
- claude code context injection
- cross-platform developer memory system
- project memory with openai embeddings
API Integration: OpenAI and Claude
Git Notes Graph integrates with both major AI providers, giving you flexibility in how your memory layer operates.
OpenAI Integration
The OpenAI embedder uses text-embedding-3-small by default, providing 1536-dimensional vectors that capture subtle semantic relationships between your notes. Configuration is straightforward:
git graph config embedder.provider openai
git graph config embedder.api-key $OPENAI_API_KEY
git graph config embedder.model text-embedding-3-small
The system batches embeddings for efficiency — 20 notes per batch, with automatic rate limiting to avoid 429 errors.
Claude API Integration
Claude's embedding endpoint (available in 2026) provides native integration with Anthropic's models. The claude-3-haiku embedding is optimized for 1024-dimensional vectors with higher throughput than text-embedding-3-small.
git graph config embedder.provider claude
git graph config embedder.api-key $CLAUDE_API_KEY
git graph config embedder.model claude-3-haiku-embedding
When using Claude's embedder, query results are weighted by both semantic relevance and temporal recency — recent notes about similar topics rank higher than old ones, simulating how human memory naturally biases toward recent experiences.
Getting Started
Installation is a single command for most systems:
# macOS with Homebrew
brew install git-notes-graph
# Linux with apt
sudo apt install git-notes-graph
# Windows with chocolatey
choco install git-notes-graph
# Or build from source
git clone https://github.com/git-notes-graph/git-notes-graph.git
cd git-notes-graph
make install
After installation, initialize your repository:
cd your-project
git graph init
git graph config embedder.api-key your-api-key-here
The Metaphor: Your Codebase as a Brain
Think of Git Notes Graph as the hippocampus of your development workflow. The hippocampus in biological brains encodes experiences into long-term memory, then retrieves them based on contextual cues. Your commits are experiences. Your notes are encoded memories. Claude Code is the consciousness that queries this memory.
Without Git Notes Graph, each Claude Code session is like meeting a brilliant colleague with anterograde amnesia — exceptional reasoning ability, but no memory of past conversations. With Git Notes Graph, Claude Code develops a persistent memory that grows richer with every commit you annotate.
License
This project is licensed under the MIT License - see the LICENSE file for details.
Disclaimer
Git Notes Graph is an augmentation tool, not a replacement for sound engineering judgment. The semantic memory layer may surface notes that are contextually irrelevant if the embedding model misinterprets your query. Always verify Claude Code's recommendations against your project's actual requirements.
The system stores embeddings locally in your Git repository. No note content or embedding vectors are transmitted to external services unless you configure an API-based embedder. When using OpenAI or Claude APIs, note text is transmitted to those services for embedding computation. Review their privacy policies for data handling practices.
Performance depends on your repository size, note volume, and embedder latency. Large repositories with over 100,000 notes may experience indexing delays on initial setup. The incremental indexer maintains responsiveness after the initial pass.
Git Notes Graph: Because your project's memory should be as interconnected as your code.
Version 2.4.0 | Released 2026 | Semantic Memory for Generative Development