Skip to main content
Glama
██╗      ██████╗  ██████╗  ██████╗ ███████╗
██║     ██╔═══██╗██╔════╝ ██╔═══██╗██╔════╝
██║     ██║   ██║██║  ███╗██║   ██║███████╗
██║     ██║   ██║██║   ██║██║   ██║╚════██║
███████╗╚██████╔╝╚██████╔╝╚██████╔╝███████║
╚══════╝ ╚═════╝  ╚═════╝  ╚═════╝ ╚══════╝

        ███████╗██╗     ██╗   ██╗██╗  ██╗
        ██╔════╝██║     ██║   ██║╚██╗██╔╝
        █████╗  ██║     ██║   ██║ ╚███╔╝ 
        ██╔══╝  ██║     ██║   ██║ ██╔██╗ 
        ██║     ███████╗╚██████╔╝██╔╝ ██╗
        ╚═╝     ╚══════╝ ╚═════╝ ╚═╝  ╚═╝

Mnemo

Erweitertes Gedächtnis für KI-Assistenten via Gemini Context Caching.

Mnemo (griechisch: Gedächtnis) ermöglicht KI-Assistenten wie Claude den Zugriff auf große Codebasen, Dokumentationsseiten, PDFs und mehr, indem es das 1M-Token-Kontextfenster und die Context-Caching-Funktionen von Gemini nutzt.

Warum Mnemo?

Anstelle komplexer RAG-Pipelines mit Embeddings und Retrieval verfolgt Mnemo einen einfacheren Ansatz:

  • Laden Sie Ihre gesamte Codebasis in den Kontext-Cache von Gemini

  • Fragen Sie diese in natürlicher Sprache ab

  • Lassen Sie Claude die Orchestrierung übernehmen, während Gemini den Kontext hält

Das bietet Ihnen:

  • Perfekte Wiedergabe – kein Chunking oder Retrieval bedeutet keinen verlorenen Kontext

  • Geringere Latenz – zwischengespeicherter Kontext wird schnell bereitgestellt

  • Kosteneinsparungen – zwischengespeicherte Token kosten 75-90 % weniger als reguläre Eingabe-Token

  • Einfachheit – keine Vektordatenbanken, Embeddings oder komplexe Retrieval-Logik

Related MCP server: Heimdall MCP Server

Was kann Mnemo laden?

Quelle

Lokaler Server

Worker

GitHub-Repos (öffentlich)

GitHub-Repos (privat)

Beliebige URL (Doku, Artikel)

PDF-Dokumente

JSON-APIs

Lokale Dateien/Verzeichnisse

Mehrseitige Crawls

✅ unbegrenzt

✅ max. 40 Seiten

Bereitstellungsoptionen

Mnemo kann je nach Bedarf auf drei Arten bereitgestellt werden.

Option 1: Lokaler Server (Entwicklung & volle Funktionen)

Am besten für die Entwicklung geeignet und wenn Sie lokale Dateien laden müssen.

# Clone and install
git clone https://github.com/logos-flux/mnemo
cd mnemo
bun install

# Set your Gemini API key
export GEMINI_API_KEY=your_key_here

# Start the server
bun run dev

Claude Code MCP-Konfiguration:

{
  "mcpServers": {
    "mnemo": {
      "type": "http",
      "url": "http://localhost:8080/mcp"
    }
  }
}

Option 2: Selbst gehosteter Cloudflare Worker (Empfohlen für Claude.ai)

Bereitstellung in Ihrem eigenen Cloudflare-Konto. Sie behalten die Kontrolle über Ihre Daten und Kosten.

Voraussetzungen:

# Clone and install
git clone https://github.com/logos-flux/mnemo
cd mnemo/packages/cf-worker

# Configure secrets
bunx wrangler secret put GEMINI_API_KEY
bunx wrangler secret put MNEMO_AUTH_TOKEN  # Optional but recommended

# Create D1 database
bunx wrangler d1 create mnemo-cache

# Deploy
bunx wrangler deploy

Claude.ai MCP-Konfiguration:

{
  "mcpServers": {
    "mnemo": {
      "type": "http",
      "url": "https://mnemo.<your-subdomain>.workers.dev/mcp",
      "headers": {
        "Authorization": "Bearer YOUR_AUTH_TOKEN"
      }
    }
  }
}

Warum diese Option? Claude.ai kann keine Verbindung zu localhost herstellen. Der Worker bietet Ihnen einen externen Endpunkt, den Claude.ai erreichen kann.


Option 3: Managed Hosting (VIP)

Sie möchten keine Infrastruktur verwalten? Wir bieten für ausgewählte Kunden ein vollständig verwaltetes Mnemo-Hosting an.

Beinhaltet:

  • Dedizierte Worker-Bereitstellung

  • Priorisierter Support

  • Eigene Domain

  • Nutzungsüberwachung

Kontakt: lf@logosflux.io für Preise und Verfügbarkeit.


Anwendungsbeispiele

# Load a GitHub repo
curl -X POST http://localhost:8080/tools/context_load \
  -H "Content-Type: application/json" \
  -d '{"source": "https://github.com/honojs/hono", "alias": "hono"}'

# Load a documentation site (crawls up to token target)
curl -X POST http://localhost:8080/tools/context_load \
  -H "Content-Type: application/json" \
  -d '{"source": "https://hono.dev/docs", "alias": "hono-docs"}'

# Load a PDF
curl -X POST http://localhost:8080/tools/context_load \
  -H "Content-Type: application/json" \
  -d '{"source": "https://arxiv.org/pdf/2303.08774.pdf", "alias": "gpt4-paper"}'

# Load a private repo (with GitHub token)
curl -X POST http://localhost:8080/tools/context_load \
  -H "Content-Type: application/json" \
  -d '{"source": "https://github.com/owner/private-repo", "alias": "private", "githubToken": "ghp_xxx"}'

# Load multiple sources into one cache
curl -X POST http://localhost:8080/tools/context_load \
  -H "Content-Type: application/json" \
  -d '{"sources": ["https://github.com/owner/repo", "https://docs.example.com"], "alias": "combined"}'

# Query the cache
curl -X POST http://localhost:8080/tools/context_query \
  -H "Content-Type: application/json" \
  -d '{"alias": "hono", "query": "How do I add middleware?"}'

# List active caches
curl -X POST http://localhost:8080/tools/context_list \
  -H "Content-Type: application/json" -d '{}'

# Get usage stats with cost tracking
curl -X POST http://localhost:8080/tools/context_stats \
  -H "Content-Type: application/json" -d '{}'

# Evict when done
curl -X POST http://localhost:8080/tools/context_evict \
  -H "Content-Type: application/json" \
  -d '{"alias": "hono"}'

CLI

# Start server
mnemo serve

# Start MCP stdio transport (for Claude Desktop)
mnemo stdio

# Load a project
mnemo load ./my-project my-proj

# Query
mnemo query my-proj "What's the main entry point?"

# List caches
mnemo list

# Remove cache
mnemo evict my-proj

MCP-Tools

Tool

Beschreibung

context_load

Lädt GitHub-Repos, URLs, PDFs oder lokale Verzeichnisse in den Gemini-Cache

context_query

Fragt einen zwischengespeicherten Kontext in natürlicher Sprache ab

context_list

Listet alle aktiven Caches mit Token-Anzahl und Ablaufdatum auf

context_evict

Entfernt einen Cache

context_stats

Ruft Nutzungsstatistiken mit Kostenverfolgung ab

context_refresh

Lädt einen Cache mit frischem Inhalt neu

context_load Parameter

Parameter

Beschreibung

source

Einzelne Quelle: GitHub-URL, beliebige URL oder lokaler Pfad

sources

Mehrere Quellen, die zu einem Cache kombiniert werden

alias

Anzeigename für diesen Cache (1-64 Zeichen)

ttl

Lebensdauer in Sekunden (60-86400, Standard 3600)

githubToken

GitHub-Token für private Repos

systemInstruction

Benutzerdefinierte System-Anweisung für Abfragen

Konfiguration

Variable

Beschreibung

Standard

GEMINI_API_KEY

Ihr Gemini API-Schlüssel

Erforderlich

MNEMO_PORT

Server-Port (nur lokal)

8080

MNEMO_DIR

Datenverzeichnis (nur lokal)

~/.mnemo

MNEMO_AUTH_TOKEN

Auth-Token für geschützte Endpunkte

Keine

Authentifizierung

Wenn MNEMO_AUTH_TOKEN konfiguriert ist, erfordern die Endpunkte /mcp und /tools/* eine Authentifizierung:

# Set auth token (Workers)
bunx wrangler secret put MNEMO_AUTH_TOKEN

# Requests must include header:
Authorization: Bearer your-token-here

Öffentliche Endpunkte (keine Authentifizierung erforderlich):

  • GET /health - Gesundheitsprüfung

  • GET / - Service-Informationen

  • GET /tools - Liste der verfügbaren Tools

Kosten

Sie zahlen immer für die Gemini API-Nutzung, unabhängig von der Bereitstellungsoption. Mnemo nutzt das Context Caching von Gemini, das deutlich günstiger ist als die Standard-Eingabe:

Ressource

Kosten

Cache-Speicher

~4,50 $ pro 1 Mio. Token pro Stunde

Zwischengespeicherte Eingabe

75-90 % Rabatt gegenüber regulärer Eingabe

Reguläre Eingabe

~0,075 $ pro 1 Mio. Token (Flash)

Beispiel: 100.000 Token Codebasis für 1 Stunde zwischengespeichert mit 10 Abfragen ≈ 0,47 $

Cloudflare-Kosten (selbst gehostet):

  • Worker: Kostenloser Tarif beinhaltet 100.000 Anfragen/Tag

  • D1: Kostenloser Tarif beinhaltet 5 Mio. Lesezugriffe/Tag

  • Wahrscheinlich 0 $ bei moderater Nutzung

Architektur

┌─────────────────────────────────────────────────────────────┐
│                         Mnemo                                │
├─────────────────────────────────────────────────────────────┤
│  MCP Tools                                                   │
│  • context_load    - Load into Gemini cache                 │
│  • context_query   - Query cached context                   │
│  • context_list    - Show active caches                     │
│  • context_evict   - Remove cache                           │
│  • context_stats   - Token usage, costs                     │
│  • context_refresh - Reload cache                           │
├─────────────────────────────────────────────────────────────┤
│  Adapters (v0.2)                                             │
│  • GitHub repos (via API)                                   │
│  • URL loading (HTML, PDF, JSON, text)                      │
│  • Token-targeted crawling                                  │
│  • robots.txt compliance                                    │
├─────────────────────────────────────────────────────────────┤
│  Packages                                                    │
│  • @mnemo/core      - Gemini client, loaders, adapters      │
│  • @mnemo/mcp-server - MCP protocol handling                │
│  • @mnemo/cf-worker - Cloudflare Workers deployment         │
│  • @mnemo/local     - Bun-based local server                │
└─────────────────────────────────────────────────────────────┘

Lizenz

MIT

Credits

Entwickelt von Logos Flux | Voltage Labs

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections. Dates show when Glama detected each change.

No tool schema history has been recorded yet.

Maintenance

ActivityInactive
ResponsivenessNo issues

Resources

Unclaimed servers have limited discoverability.

Looking for Admin?

If you are the server author, to access and configure the admin panel.

Related MCP Connectors

Related MCP Servers

  • A
    license
    B
    quality
    C
    maintenance
    Provides AI assistants with persistent memory of your project architecture, development history, and technical decisions, allowing them to give context-aware coding help without needing repeated explanations.
    16
    61
    2
    MIT
  • A
    license
    Not graded
    quality
    D
    maintenance
    Provides AI coding assistants with persistent, context-rich memory of a codebase, including documentation and git history, enabling recall across sessions.
    104
    Apache 2.0
  • A
    license
    A
    quality
    B
    maintenance
    Provides persistent memory and a codebase knowledge graph for AI coding assistants, enabling shared context across multiple tools like Claude, Cursor, and ChatGPT, with significant token reduction.
    5
    25
    MIT

Latest Blog Posts

MCP directory API

We provide all the information about MCP servers via our MCP API.

curl -X GET 'https://glama.ai/api/mcp/v1/servers/Logos-Flux/mnemo'

If you have feedback or need assistance with the MCP directory API, please join our Discord server