convez.ai
MCP ServerProdutividadeIntermediário
karimassalihi-bot

Git Memory Vault

karimassalihi-bot/git-memory-vault

Memória semântica nativa para projetos Git integrada ao Claude Code

Ver no GitHub
InicialPluginScore · de 0 a 100

MCP 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-vault

1 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

Estrelas
0
Forks
0
Acompanhando
0
Saúde
28%
Último commit
há 6 meses
Versão
—
Issues abertas
0
Contribuidores
1

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

Download

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 SystemNative SupportVerified VersionNotes
Linux (Ubuntu 22.04+)Full2.34+Native performance, full feature set
macOS (Monterey+)Full2.37+Homebrew-compatible installation
Windows 10/11Full (WSL2)2.41+Native Windows support via Git for Windows
Windows 10/11Native2.41+Limited hook support without WSL
FreeBSDFull2.38+Tested on 13.x
Alpine LinuxFull2.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

Download

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.


Download

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

Ver o original no GitHub

Bom para

Relacionados