> your AI forgets everything between sessions.
> gingugu fixes that.█
      


      

        a local MCP server that gives AI coding assistants a real long-term
        brain — persistent, structured, searchable memory that survives across
        sessions, repos, and projects.
      


      

        [ python 3.11+ ]
        [ protocol: MCP ]
        [ storage: SQLite ]
        [ license: MIT ]
        [ 0% cloud · 0 telemetry ]
      

    


    
    

      
$ whoami

      

        

          every session with an AI assistant starts from zero. the decisions you
          made yesterday, the bug you fixed last week, the architecture you
          settled on a month ago — gone.
        

        

          existing memory tools dump observations into a flat pile. no structure,
          no staleness tracking, no relationships, no sense of what's relevant
          right now.
        

        

          gingugu is a structured long-term brain — not a junk
          drawer. one SQLite file on your machine. no cloud, no API keys,
          no telemetry.
        

      

    


    
    

      
$ cat features.txt

      

        
[namespaces] memories auto-scoped to repos/projects, cross-repo pattern sharing

        
[hybrid_search] FTS5 BM25 + local semantic embeddings fused with RRF — fast, local, zero API calls, no PyTorch

        
[trust_map] trust-led scoring, dormancy tracking (never forgets), last-confirmed tracking, spreading activation

        
[relations] link memories: supersedes · related_to · caused_by · contradicts · parent_of · child_of

        
[confidence] verified → inferred → stale → deprecated lifecycle

        
[review_hints] point-in-time memories ("PR open, waiting on…", passed expiry dates) get advisory staleness flags - you reconcile, the server never mutates

        
[consolidate] find near-dupe clusters (read-only scan), then merge, summarize, or dedupe on demand

        
[auto_context] surfaces relevant memories on session start - one call loads many namespaces deduped, optional compact mode

        
[cred_vault] API keys/tokens in the OS keychain — never in plaintext

        
[explorer_ui] interactive knowledge graph + dashboard for your memory data

        
[health] memory stats, dormancy reports, review sweep, namespace overviews

        
[central_brain] optional: gingugu serve runs the same server over HTTP behind a bearer token; gingugu promote harvests local gold up to it with provenance

        
[bootstrap] gingugu init wires a repo for Claude Code in one command - a SessionStart hook auto-injects the memory protocol every session (no rules file to paste), plus a save-discipline stop hook and /sink-the-ship

      

    


    
    

      
$ cat comparison.txt

      

        
> honest take: gingugu doesn't lead the field on every axis. Graphiti has the more sophisticated temporal knowledge graph. mem0 has the broader ecosystem and a managed platform. Letta is a more complete stateful-agent runtime. Zep is built for enterprise scale and governance. (we used to keep a capability matrix here; those products ship fast, and stale claims about someone else's tool help nobody - go evaluate them directly.)

        
> where gingugu wins: one inspectable local memory layer for a developer using several coding agents - no cloud account, no agent framework, no graph DB, no LLM call to store a memory. one SQLite file. MCP-native. typed relations. explicit trust + lifecycle. advisory staleness hints. and when a team wants more: the same server runs as a shared central brain over HTTP (gingugu serve) and harvests each dev's local gold into it (gingugu promote) - no platform migration, same single file.

        
> plus a built-in OS-keychain credential vault - useful alongside memory, but not really a memory feature.

      

    


    
    

      
$ ls tools/ # 16 MCP tools

      

        memory_storememory_recallmemory_contextmemory_update
        memory_relatememory_consolidatememory_forgetmemory_namespaces
        memory_exportmemory_importmemory_statsmemory_search
        credential_storecredential_getcredential_listcredential_delete
      

    


    
    

      
$ gingugu --demo

      
// session start — your agent runs:
memory_context(namespace="my-app", task_hint="fix auth bug")

→ surfaced 4 memories:
  [bug]      JWT refresh loop on expired tokens — FIXED in a81f2c
  [decision] auth lives in middleware/, not per-route guards
  [pattern]  all API errors wrap in ApiError(code, msg)
  [fact]     staging uses cognito pool us-east-1_x7Yq

// your AI now remembers. like it never left.

    


    
    

      
$ ./install.sh

      

        

          pip install gingugu
          
        

        

          or uv tool install gingugu. then, in your repo, run
          gingugu init to wire up Claude Code in one command — a
          SessionStart hook auto-loads the memory protocol every session (no
          rules file to paste). other agents: point your MCP config at it and
          use gingugu init --client windsurf|cursor|cline. full
          setup in the README.
        

      

    


    
    

      
$ cat links.txt

      

        [1] github.com/gingugu/gingugu ........ source
        [2] README#setup ..................... install guide
        [3] modelcontextprotocol.io .......... what's MCP?