> 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

        
[confidence] verified → inferred → stale → deprecated lifecycle

        
[consolidate] merge duplicates, summarize clusters, dedupe on demand

        
[auto_context] surfaces relevant memories on session start — zero manual effort

        
[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, namespace overviews

      

    


    
    

      
$ cat comparison.txt

      

        

          

            
              

                
                [ gingugu ]
                OpenMemory MCP
                Mem0 OSS
                Mem0 Platform
                Graphiti (OSS)
                Zep Cloud
                Letta
              

            
            
              

                local-first by default
                ✅
                ✅
                ⚙️ configurable
                ❌ hosted
                ✅ self-hosted
                ❌ hosted
                ⚙️ local mode
              

              

                MCP-native cross-tool memory
                ✅
                ✅
                ❌ SDK only
                ⚙️ hosted MCP
                ✅ MCP server
                ❌ API only
                ❌ Letta agents only
              

              

                no mandatory hosted service
                ✅
                ✅
                ✅
                ❌
                ✅
                ❌
                ⚙️ in local mode
              

              

                no LLM call to store a memory
                ✅
                ⚙️ engine dependent
                ❌ extracts via LLM
                ❌ extracts via LLM
                ❌ extraction-time
                ❌ extraction-time
                ⚙️ agent-managed
              

              

                single-file storage
                ✅ SQLite
                ❌
                ❌
                ❌ hosted
                ❌ graph DB
                ❌ hosted
                ❌
              

              

                local visual memory inspection
                ✅ graph explorer
                ✅ dashboard
                ⚙️ cloud dashboard
                ❌ cloud only
                ❌ framework-level
                ❌ cloud tooling
                ✅ ADE
              

              

                lexical + semantic retrieval
                ✅ hybrid ranking
                ⚙️ engine dependent
                ✅
                ✅
                ✅ + graph
                ✅ + graph
                ⚙️ partial
              

              

                explicit confidence + lifecycle
                ✅ 4-state
                ⚙️ partial
                ⚙️ partial
                ⚙️ partial
                ❌ uses temporal facts
                ❌ uses governance tooling
                ❌ uses agent state
              

              

                typed memory relations
                ✅ supersedes / contradicts / …
                ⚙️ partial
                ⚙️ via entity graph
                ⚙️ via entity graph
                ✅ graph-native
                ✅ graph-native
                ❌
              

              

                auto entity / relation extraction
                ❌ intentional
                ⚙️ engine dependent
                ✅
                ✅
                ✅
                ✅
                ❌
              

              

                operational footprint
                very small
                medium
                medium-large
                hosted
                large
                hosted
                large
              

            
          

        

        
> these products aren't all the same shape. mem0 ships an OSS framework and a managed platform. Zep is the managed product; Graphiti is its OSS temporal-graph sibling. Letta is a full stateful-agent runtime rather than a memory layer. split out, not bucketed.

        
> 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.

        
> 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. OpenMemory MCP is the only product squarely in this lane; we differentiate via confidence states, lifecycle, typed relations, last-confirmed tracking, supersession, contradiction, structured namespaces, and a local graph explorer.

        
> plus a built-in OS-keychain credential vault — useful alongside memory, but not really a memory feature, so it sits beside the matrix rather than inside it.

      

    


    
    

      
$ 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 point your MCP config at it
          and paste the memory protocol into your agent's rules file — 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?