Skip to main content
Glama
Sign In
deenesjakoruzh
Logos-Flux

Mnemo

by Logos-Flux
OverviewSchemaSourceRelated ServersDiscussionsAdmin
TypeScript
Hybrid
██╗      ██████╗  ██████╗  ██████╗ ███████╗
██║     ██╔═══██╗██╔════╝ ██╔═══██╗██╔════╝
██║     ██║   ██║██║  ███╗██║   ██║███████╗
██║     ██║   ██║██║   ██║██║   ██║╚════██║
███████╗╚██████╔╝╚██████╔╝╚██████╔╝███████║
╚══════╝ ╚═════╝  ╚═════╝  ╚═════╝ ╚══════╝

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

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

This server cannot be deployed

Shareable, User-Owned Context BackendPeople, applications, and agents read, write, and coordinate together in one context lake. Reach it over MCP, a CLI, a Python SDK, or REST.fulcradynamics.comAd

Maintenance

ActivityInactive
ResponsivenessNo issues

Resources

Related MCP Connectors

Related MCP Servers