de en es ja ko ru zh

Mnemosyne

Name: Mnemosyne
Author: M4F-S

by M4F-S

Overview Schema Related Servers Score Discussions

Python

Local

Mnemosyne 🧠

PyPI version Python 3.9+ MCP License: Apache-2.0

Produktionsreife, lokal-first hierarchische Gedächtnis-Engine für autonome KI-Agenten.

Mnemosyne stattet KI-Agenten (Hermes, OpenClaw, OpenManus, Claude Desktop, Cursor, Windsurf, CrewAI, LangChain) mit permanentem, strukturiertem Langzeitgedächtnis aus. Es verbindet menschenlesbare Obsidian Markdown Vaults mit Hochgeschwindigkeits-PostgreSQL + pgvector (HNSW) oder SQLite ohne Konfiguration und ermöglicht hybride Reciprocal Rank Fusion (RRF)-Suche, Wikilink-Wissensgraphen, Ebbinghaus-Zeitabklingung, agentenübergreifendes Fleet-Sharing und asynchrone Google-Drive-Cloud-Synchronisierung.

📑 Inhaltsverzeichnis

Related MCP server: Synapto

⚡ Vollständige Feature-Matrix

Feature	Beschreibung	Nutzen
🤖 MCP-Nativ (v2024-11-05)	Standardisierter stdio-JSON-RPC-Protokollserver	Nahtlose Integration für Claude, Cursor, Windsurf, Hermes, OpenClaw
🔎 HNSW-Vektorsuche mit hoher Trefferquote	`pgvector`-HNSW-Indizierung mit `vector_cosine_ops` (`m=16, ef_construction=64`)	Sub-Millisekunden-Vektorabruf ohne Clustering-Neutraining
⚖️ Hybrider RRF-Abruf	Reciprocal Rank Fusion aus Dense Embeddings (1.0) + GIN FTS (0.8) + Graph (0.6) + Salience (0.2)	Erfasst exakte technische Schlüsselwörter (CVEs, Code-Tokens) & Fuzzy-Semantik
🏛️ Wing- & Room-Scoping	2-stufige Taxonomie (`wing` = Domäne/Projekt, `room` = Kanal/Thema)	Eliminiert Kontextfenster-Aufblähung & domänenübergreifende Halluzination
🌐 Agentenübergreifendes gemeinsames Gedächtnis	Zentrale `shared_db`, abfragbar über Multi-Agent-Fleets mit Credential-Screening	Kollektive Fleet-Intelligenz ohne Kompromittierung privater Datenbanken
☁️ Asynchrone Google-Drive-Synchronisierung	Lokal-first bidirektionale Synchronisierungs-Engine mit MD5-Diffing und `.conflict.md`-Branch-Auflösung	Sub-Millisekunden-Agent-I/O lokal + automatische Cloud-Backups & Team-Sharing
⏳ Ebbinghaus-Zeitabklingung	Exponentieller Abfall $Salience_t = Salience_0 \times (0.95)^{\Delta t}$ mit 90-Tage-Auto-Archivierung	Entfernt automatisch transientes Rauschen, während aktive Erinnerungen scharf bleiben
📌 Pinned-Memory-Immunität	Permanente Immunität gegen Abklingung durch `pinned=True` oder `#pinned`-Tags	Garantiert, dass grundlegende Anweisungen und Kernregeln nie verblassen
📖 Obsidian Zettelkasten	Schreibt menschenlesbare Markdown-Notizen mit YAML-Frontmatter & `[[Wiki Links]]`	Direkte visuelle Inspektion, Bearbeitung und Graph-Visualisierung in Obsidian
📜 Turn-bewusster Ingestor	1.500-Zeichen-Sliding-Window-Chunking mit 200-Zeichen-Überlappung entlang von Turn-Grenzen	Bewahrt die gesamte Konversationshistorie, ohne Codeblöcke zu brechen
🛡️ Prompt-Injection-Schutz	Neutralisiert Kontroll-Tokens (`<	im_start	>`,` [INST]`) in Prosa; escaped XML-Kontext-Tags	Verhindert Memory-Poisoning und Context-Hijacking-Angriffe
⚡ FastEmbed-ONNX-Unterstützung	Ultra-leichte ONNX-Runtime-Embedding-Engine (~30MB RAM)	90% Speicherreduktion gegenüber schwerem PyTorch `sentence-transformers`
🔄 SQLite-Fallback ohne Konfiguration	Automatischer Fallback auf lokales SQLite, wenn PostgreSQL offline ist	100% Feature-Parität für eigenständige Entwickler-Workstations

🏗️ Systemarchitektur

                                ┌──────────────────────────────────────────────┐
                                │          AI Agents & LLM Frameworks          │
                                │  Hermes • OpenClaw • Claude • Cursor • Manus │
                                └──────────────────────┬───────────────────────┘
                                                       │ JSON-RPC (stdio) / Python SDK
                                                       ▼
┌─────────────────────────────────────────────────────────────────────────────────────────────────────────────┐
│                                           Mnemosyne Core (v3.4.0)                                           │
│                                                                                                             │
│  ┌─────────────────────────┐  ┌─────────────────────────┐  ┌─────────────────────────────────────────────┐  │
│  │ Admission & Security    │  │ Multi-Backend Embedder  │  │ Turn-Aware Session Ingestor                 │  │
│  │ - Secret Regex Guard    │  │ - FastEmbed (ONNX 30MB) │  │ - Turn boundary splitting                   │  │
│  │ - Injection Neutralizer │  │ - Remote Microservice   │  │ - 1500-char linear sliding window           │  │
│  │ - Path Traversal Guard  │  │ - SentenceTransformers  │  │ - Sequential [[Wiki Link]] chaining         │  │
│  └─────────────────────────┘  └─────────────────────────┘  └─────────────────────────────────────────────┘  │
│                                                                                                             │
│  ┌───────────────────────────────────────────────────────────────────────────────────────────────────────┐  │
│  │                                 Hybrid RRF Retrieval & Graph Ranker                                   │  │
│  │            RRF Score = 1.0 * Dense(HNSW) + 0.8 * Keyword(FTS) + 0.6 * Graph + 0.2 * Salience          │  │
│  └───────────────────────────────────────────────────────────────────────────────────────────────────────┘  │
└───────────────────────────────────────┬───────────────────────────────────────┬─────────────────────────────┘
                                        │                                       │
                ┌───────────────────────┴───────────────────────┐               │
                ▼                                               ▼               ▼
 ┌─────────────────────────────┐                 ┌─────────────────────────────────────────────┐
 │    PostgreSQL + pgvector    │                 │       Obsidian Markdown Vault (Local)       │
 │ - HNSW vector_cosine_ops    │                 │ - Human-Readable Markdown + YAML Frontmatter │
 │ - GIN tsvector English FTS  │                 │ - [[Wikilink]] Knowledge Graph Visualizer   │
 │ - Self-Healing DB Pool      │                 │ - Atomic Writes with EXDEV Fallback         │
 │ - Private DB + shared_db    │                 └──────────────────────┬──────────────────────┘
 └─────────────────────────────┘                                        │ Async Background Sync
                                                                        ▼
                                                 ┌─────────────────────────────────────────────┐
                                                 │              Google Drive Cloud             │
                                                 │ - Service Account / OAuth2 Authentication    │
                                                 │ - MD5 Checksum Verification                 │
                                                 │ - Sibling .conflict-TIMESTAMP.md Resolution │
                                                 └─────────────────────────────────────────────┘

🧠 Deep Dive in die Kernfunktionen

1. Hierarchische Wing- & Room-Taxonomie

Gedächtnis-Kreuzkontamination ist ein häufiges Fehlermuster in Multi-Agent-Fleets. Mnemosyne strukturiert das Gedächtnis als 2-stufigen physischen Palast:

wing (Domäne/Projekt): Obergrenze der Domäne (z. B. ecommerce, pentest, devops, shared).
room (Thema/Kanal): Granulare Themenpartition (z. B. database, firewall, stripe_api).

Abfragen können eng auf einen bestimmten Wing oder Room eingegrenzt werden, sodass Marketing-Prompts keine Penetrationstest-Ergebnisse abrufen.

2. Hybride Reciprocal Rank Fusion (RRF)-Suche

Standard-Vektorsuche versagt bei exakten technischen Zeichenketten (z. B. CVE-2024-38077, 0x7fff5fbff8c0), während Stichwortsuche bei semantischen Konzepten versagt. Mnemosyne führt einen Multi-Kandidaten-Abruf durch und führt die Ergebnisse mittels gewichteter RRF zusammen:

$$\text{RRF Score}(d) = \sum_{m \in \text{modes}} w_m \cdot \frac{1}{k + \text{rank}_m(d)} + 0.2 \cdot \text{Salience}(d)$$

Dichte HNSW-Vektorsuche: Gewicht $1.0$ (Kosinus-Distanz über 384-dimensionale Embeddings).
PostgreSQL-Volltextsuche: Gewicht $0.8$ (tsvector gewichtet mit Titel als A und Inhalt als B).
Rekursive Graph-Traversierung: Gewicht $0.6$ (Rekursiver CTE, der 1-Hop- und 2-Hop-[[Wiki Links]] entdeckt).
Memory-Salience-Engine: Gewicht $0.2$ (Wichtigkeits-Score von $0.0$ bis $1.0$).

3. Agentenübergreifende gemeinsame Gedächtnisschicht (`shared_db`)

In autonomen Multi-Agent-Umgebungen halten Agenten isolierte private Datenbanken (toy_db, old_db, candy_db usw.) vor, um Zustandskorruption zu verhindern. Kollektive Intelligenz erfordert jedoch das Teilen globaler Richtlinien und verifizierter Fakten.

Veröffentlichung: Mit memory_publish_shared werden geprüfte Notizen in shared_db veröffentlicht.
Credential-Screening: Inhalte werden mit strengen Regex-Filtern auf Anthropic-Schlüssel (sk-ant-), Google-Gemini-Schlüssel (AIza...), HuggingFace-Tokens (hf_...), OpenAI-Schlüssel (sk-proj-...), AWS-Zugriffsschlüssel (AKIA...), Slack-Tokens (xox-) und private Schlüssel geprüft.
Fail-Soft-Abruf: Wenn ein Agent das Gedächtnis abfragt, fragt memory_recall sowohl den privaten Speicher als auch shared_db ab. Ist die gemeinsame Datenbank vorübergehend nicht erreichbar, degradiert das System elegant, ohne den Agenten zu unterbrechen.

4. Ebbinghaus-Zeitabklingung & Pinned-Immunität

Erinnerungen verlieren mit der Zeit natürlich an Relevanz. Mnemosyne implementiert Herman Ebbinghaus' exponentielle Vergessenskurve:

$$\text{Salience}(t) = \text{Salience}0 \times (0.95)^{\Delta t{\text{days}}}$$

Touch-Feedback: Der Zugriff auf eine Erinnerung aktualisiert last_accessed_at und setzt deren Abklingung zurück.
Nächtliche Auto-Archivierung: Die Konsolidierung überführt automatisch Notizen mit $\text{Salience} < 0.05$ und ohne Zugriff seit $>90\text{ Tagen}$ in status = 'archived'.
Pinned-Immunität: Systemregeln, Kernrichtlinien oder Notizen, die mit pinned=True markiert oder mit #pinned getaggt sind, erhalten permanente Immunität gegen Zeitabklingung ($\text{Salience} = 1.0$).

5. Obsidian Markdown Vault & bidirektionaler Graph

Jede Erinnerung, die ein Agent erstellt, wird gleichzeitig als menschenlesbare .md-Datei in Ihrem Obsidian-Vault geschrieben:

Zettelkasten-Frontmatter: Enthält title, date, tags, type, salience, wing und room.
Wissensgraph: Zielnotizen, die als [[Zielnotiz]] erwähnt werden, werden automatisch in bidirektionale Kanten in PostgreSQL geparst.
Live-Inspektion: Öffnen Sie Obsidian auf Ihrem Desktop oder Mobilgerät und erkunden Sie das kollektive Gedächtnis Ihres Agent-Fleets in Obsidians interaktiver Graph-Ansicht.

6. Turn-bewusster Verbatim-Sitzungs-Ingestor

Konversationstranskripte enthalten oft entscheidende Nuancen, die bei verlustbehafteter Zusammenfassung verloren gehen. memory_ingest_session:

Teilt rohe Transkripte entlang von Turn-Grenzen (User:, Assistant:, ### Turn, **Human**:).
Wendet für Turns über 1.500 Zeichen ein lineares Sliding Window an (1.500 Zeichen mit 200 Zeichen Überlappung).
Verkettet sequenzielle Chunks mit [[Session ... Turn 01 Part 02]]-Wikilinks und bewahrt so Codeblöcke, Ausführungsabläufe und den Konversationsfluss.

7. Asynchrone Google-Drive-Cloud-Synchronisierung

Halten Sie Ihre Agent-Vaults sicher gesichert und über mehrere Maschinen oder Mobilgeräte hinweg synchronisiert:

Lokale Geschwindigkeit: Agent-Tool-Aufrufe werden mit lokaler SSD-Geschwindigkeit (<1ms) ausgeführt, ohne auf die Netzwerklatenz von Google Drive zu warten.
Hintergrund-Daemon / Cron-Synchronisierung: Scannt Vault-Dateien, berechnet MD5-Prüfsummen und synchronisiert Deltas bidirektional mit Google Drive.
Konfliktlösung: Wenn eine Datei gleichzeitig auf Google Drive und im lokalen Agent-Vault geändert wird, speichert Mnemosyne die eingehende Version als NoteName.conflict-YYYYMMDD-HHMMSS.md, um Datenverlust zu verhindern.
Authentifizierung: Unterstützt Google Cloud Service Account JSON (GOOGLE_APPLICATION_CREDENTIALS, GDRIVE_SERVICE_ACCOUNT_JSON) und OAuth2-Benutzertokens (GDRIVE_TOKEN_JSON).

8. Flexible Embedding-Backends (FastEmbed / Microservice / Lokal)

Mnemosyne passt sich jedem Bereitstellungs-Ressourcenbudget an:

FastEmbed ONNX Runtime (Empfohlen für eigenständige Knoten): Verwendet ONNX Runtime C++-Ausführung (~30MB RAM). Kein PyTorch-Overhead.
Zentralisierter Microservice (mnemosyne.embed_service): Hostet sentence-transformers in einem einzigen dedizierten Container, der mehrere Agent-Container über HTTP bedient (MEMORY_EMBED_URL).
Lokale SentenceTransformers: Eigenständige PyTorch-Ausführung (all-MiniLM-L6-v2, 384-dimensional).
Deterministischer Hash-Fallback: Mathematischer Vektor-Hash mit null RAM für extrem ressourcenbeschränkte Umgebungen.

9. Defense-in-Depth-Sicherheit & Injektionsschutz

Pfad-Traversal-Immunität: Doppelt aufgelöste kanonische Pfadprüfungen (is_relative_to) stellen sicher, dass Dateioperationen die Vault-Root nicht verlassen können.
Atomare Sibling-Schreibvorgänge: Dateien werden in temporäre Sibling-Dateien (.note.pid.tmp) geschrieben und atomar umbenannt, mit automatischem Fallback für EXDEV-geräteübergreifende Volume-Mounts.
Neutralisierung von Steuerungstokens: Neutralisiert LLM-Injektionstokens (<|im_start|>, <|system|>, [INST], <<SYS>>) in Prosa, während Codeblöcke unverändert erhalten bleiben.
Strukturierte XML-Kontextumhüllung: Abgerufene Erinnerungen werden in <recalled_memory_context id="..." title="..." source="...">-Tags mit interner Tag-Escaping eingebettet, sodass Host-LLMs abgerufene Erinnerungen niemals mit aktiven Systemanweisungen verwechseln.

🛠️ MCP-Tool-Referenz (8 Tools)

Alle 8 Tools werden Agenten nativ über standardmäßiges MCP JSON-RPC stdio bereitgestellt:

1. `memory_remember`

Speichert eine private Erinnerungsnotiz im Vault mit semantischem Embedding, Tags und hierarchischer Bereichsdefinition.

{
  "title": "PostgreSQL HNSW Tuning",
  "content": "For datasets >10,000 vectors, use HNSW with m=16 and ef_construction=64 for optimal recall.",
  "tags": ["database", "pgvector", "performance"],
  "wing": "engineering",
  "room": "databases",
  "salience": 0.8,
  "pinned": true
}

2. `memory_publish_shared`

Veröffentlicht einen bereinigten, geprüften Befund oder eine Richtlinie im gemeinsamen agentenübergreifenden Flotten-Speicher (shared_db).

{
  "title": "Fleet Security Policy: SSL Verification",
  "content": "All internal agent HTTP requests must enforce SSL certificate validation.",
  "tags": ["security", "policy"],
  "wing": "shared",
  "room": "general"
}

3. `memory_recall`

Durchsucht Erinnerungen in privaten und gemeinsamen Flotten-Datenbanken mithilfe von hybridem RRF, HNSW-Vektoren, Schlüsselwörtern oder Graphen.

{
  "query": "HNSW index configuration parameters",
  "mode": "hybrid",
  "top_k": 5,
  "scope": {
    "wing": "engineering",
    "room": "databases"
  },
  "include_shared": true
}

4. `memory_ingest_session`

Erfasst und chunked ein vollständiges Gesprächstranskript wörtlich entlang der Wendepunkt-Grenzen.

{
  "transcript": "User: How do we configure pgvector?\nAssistant: Use CREATE EXTENSION vector; then create an HNSW index.",
  "wing": "engineering",
  "room": "sessions"
}

5. `memory_timeline`

Untersucht kürzliche Speicheroperationen (remember, recall, remind, consolidate) in chronologischer Reihenfolge.

{
  "limit": 20
}

6. `memory_history`

Zeigt Versionsverlauf und vergangene Bearbeitungsschnappschüsse einer bestimmten Erinnerungsnotiz vor Aktualisierungen an.

{
  "title": "PostgreSQL HNSW Tuning",
  "limit": 5
}

7. `memory_remind_me`

Plant eine zukünftige prospektive Erinnerung oder wiederkehrende Aufgabe.

{
  "title": "Rotate Database Credentials",
  "content": "Verify that all 5 agent connection pools are refreshed with new passwords.",
  "trigger_at": "2026-09-01T00:00:00Z",
  "recurring": "monthly"
}

8. `memory_audit`

Liefert Echtzeit-Metriken zur Speichergesundheit, Store-Backend-Status, Anforderungszahlen und aktive Wings.

{}

🌐 Produktionsarchitektur für Multi-Agenten-Flotten

In Multi-Agenten-Produktionsumgebungen (wie der 5-Agenten-Hermes-Flotte) isoliert Mnemosyne Agent-Datenbanken in einem internen Docker-Netzwerk und bietet gleichzeitig gemeinsame Intelligenz:

                                  ┌─────────────────────────────────────────┐
                                  │      Production VPS (${VPS_HOST})      │
                                  └────────────────────┬────────────────────┘
                                                       │
         ┌───────────────────┬──────────────────┼───────────────────┬──────────────────┐
         ▼                   ▼                  ▼                   ▼                  ▼
┌──────────────────┐┌──────────────────┐┌──────────────────┐┌──────────────────┐┌──────────────────┐
│   hermes-agent   ││ hermes-assistant ││ hermes-marketing ││  hermes-pentest  ││  hermes-trader   │
│      (Toy)       ││      (Old)       ││     (Candy)      ││     (Pencil)     ││      (Coin)      │
│   Database:      ││   Database:      ││   Database:      ││   Database:      ││   Database:      │
│     toy_db       ││     old_db       ││     candy_db     ││     pencil_db    ││     trader_db    │
└────────┬─────────┘└────────┬─────────┘└────────┬─────────┘└────────┬─────────┘└────────┬─────────┘
         │                   │                  │                   │                  │
         └───────────────────┴──────────────────┼───────────────────┴──────────────────┘
                                                │
                                                ▼
                               ┌───────────────────────────────────┐
                               │   PostgreSQL + pgvector (HNSW)    │
                               │   - Private DBs: toy_db, old_db.. │
                               │   - Shared DB:   shared_db        │
                               └───────────────────────────────────┘

🚀 Schnellstart & Installation

1. Installation

# Standard installation
pip install mnemosyne-memory

# With Google Drive Cloud Synchronization support
pip install "mnemosyne-memory[gdrive]"

# With lightweight FastEmbed ONNX support (~30MB RAM)
pip install "mnemosyne-memory[fastembed]"

# Full installation (All extras + Dev dependencies)
pip install "mnemosyne-memory[dev,gdrive,fastembed,embed-service]"

2. Ausführen mit Docker Compose

Starten Sie den PostgreSQL- + pgvector-Container:

docker compose up -d

3. MCP-Server starten

# Standalone with local SQLite (Zero configuration)
python -m mnemosyne server

# With PostgreSQL + pgvector
MEMORY_DB_DSN="postgresql://mnemosyne:***@localhost:5432/my_agent_db" python -m mnemosyne server

🤖 Integrationsrezepte für Agent-Frameworks

1. Claude Desktop (`claude_desktop_config.json`)

{
  "mcpServers": {
    "mnemosyne": {
      "command": "python3",
      "args": ["-m", "mnemosyne", "server"],
      "env": {
        "MEMORY_VAULT_PATH": "/Users/username/Documents/Obsidian/AgentVault",
        "MEMORY_DEFAULT_WING": "claude"
      }
    }
  }
}

2. Cursor IDE (`.cursor/mcp.json`)

{
  "mcpServers": {
    "mnemosyne": {
      "command": "python3",
      "args": ["-m", "mnemosyne", "server"],
      "env": {
        "MEMORY_VAULT_PATH": "./.vault",
        "MEMORY_DEFAULT_WING": "codebase"
      }
    }
  }
}

3. Hermes-Agent (`~/.hermes/config.yaml`)

mcp_servers:
  obsidian_memory:
    command: python3
    args: ["-m", "mnemosyne", "server"]
    env:
      MEMORY_DB_DSN: "postgresql://mnemosyne:***@${DB_HOST}:5432/toy_db"
      MEMORY_SHARED_DSN: "postgresql://mnemosyne:***@${DB_HOST}:5432/shared_db"
      MEMORY_VAULT_PATH: "/opt/data/vault"

4. OpenClaw (`openclaw-config.yaml`)

plugins:
  mcp_servers:
    mnemosyne:
      command: "python3"
      args: ["-m", "mnemosyne", "server"]
      env:
        MEMORY_VAULT_PATH: "~/.openclaw/vault"
        MEMORY_DEFAULT_WING: "openclaw"

5. Python-SDK & autonome Agent-Skripte

from mnemosyne import UnifiedMemorySystem

mem = UnifiedMemorySystem(
    vault_path="~/.agent/vault",
    dsn="postgresql://mnemosyne:***@localhost:5432/agent_db",
    shared_dsn="postgresql://mnemosyne:***@localhost:5432/shared_db"
)

# Remember fact
mem.remember(
    title="Kubernetes Cluster Policy",
    content="Deployments in staging must specify resource memory limits.",
    wing="infrastructure",
    room="k8s",
    tags=["kubernetes", "policy"],
    pinned=True
)

# Hybrid recall
results = mem.recall(
    query="staging memory limits",
    mode="hybrid",
    scope={"wing": "infrastructure"}
)

for r in results:
    print(r["title"], "->", r["formatted_context"])

💻 Vollständige CLI-Befehlsreferenz

Mnemosyne enthält eine voll ausgestattete Verwaltungs-CLI:

# 1. Store a memory note
python -m mnemosyne remember "API Architecture" "Uses Bearer JWT auth." --tags security auth --wing backend --room api --salience 0.8 --pinned

# 2. Publish shared fleet memory
python -m mnemosyne publish-shared "Global Production Policy" "Always check SSL certs." --wing devops

# 3. Search memories
python -m mnemosyne recall "JWT authentication" --mode hybrid --top-k 5 --wing backend

# 4. View activity timeline
python -m mnemosyne timeline --limit 20

# 5. Trigger Ebbinghaus decay & link reconciliation
python -m mnemosyne consolidate --decay-rate 0.95 --archive-threshold 0.05

# 6. Check system statistics & health
python -m mnemosyne stats

# 7. Synchronize with Google Drive (One-off pass)
python -m mnemosyne sync-gdrive --folder "My-Agent-Vault" --credentials service-account.json

# 8. Run Google Drive Sync as a background daemon
python -m mnemosyne sync-gdrive --daemon --interval 60

# 9. Run standalone Centralized Embedding Microservice
python -m mnemosyne embed-service --host 0.0.0.0 --port 8000 --model all-MiniLM-L6-v2

⚙️ Referenz der Umgebungsvariablen

Variable	Standard	Beschreibung
`MEMORY_VAULT_PATH`	`~/.mnemosyne/vault`	Dateisystempfad zum lokalen Obsidian-Markdown-Vault-Verzeichnis
`MEMORY_DB_DSN`	(keine)	PostgreSQL-DSN (z. B. `postgresql://user:pass@host:5432/db`). Wenn nicht gesetzt, wird SQLite verwendet
`MEMORY_SHARED_DSN`	(keine)	PostgreSQL-DSN für die optionale agentenübergreifende gemeinsame Flotten-Datenbank
`MEMORY_AGENT_NAME`	`local-agent`	Kennung für den Ursprungsagenten in Multi-Agenten-Flottenbereitstellungen
`MEMORY_EMBED_URL`	(keine)	URL des entfernten zentralisierten Embedding-Microservice (z. B. `http://localhost:8000`)
`MEMORY_REQUIRE_POSTGRES`	`false`	Setzen Sie `true`, um einen Fehler auszulösen, anstatt auf SQLite zurückzufallen, wenn PostgreSQL fehlschlägt
`GOOGLE_APPLICATION_CREDENTIALS`	(keine)	Dateipfad zur Google Cloud Service Account JSON für die Google-Drive-Synchronisierung
`GDRIVE_SERVICE_ACCOUNT_JSON`	(keine)	Stringifizierter JSON-Inhalt der Google Cloud Service Account-Anmeldedaten
`GDRIVE_TOKEN_JSON`	(keine)	Stringifizierter JSON-Inhalt des autorisierten Google-OAuth2-Benutzertokens
`TOKENIZERS_PARALLELISM`	`false`	Deaktiviert HuggingFace-Tokenizer-Forks, um die Integrität des stdio-JSON-RPC-Streams zu bewahren
`HF_HUB_DISABLE_PROGRESS_BARS`	`1`	Deaktiviert Fortschrittsbalken in stdio, um MCP-Streams makellos zu halten
`HF_HUB_OFFLINE`	`0`	Setzen Sie `1`, um SentenceTransformers zu 100 % offline mit lokalem Cache auszuführen
`TRANSFORMERS_OFFLINE`	`0`	Setzen Sie `1`, um zu verhindern, dass transformers externe HuggingFace-Netzwerkanfragen stellt

🧪 Tests & Benchmarks

Mnemosyne pflegt eine umfassende Testsuite (Unit-Tests, Sicherheits-Injektionstests, SQLite-Tests und Live-PostgreSQL-pgvector-Integrationstests):

# Run all unit tests
pytest tests/ -v -m "not integration"

# Run full test suite including live PostgreSQL + pgvector tests
MEMORY_DB_DSN="postgresql://mnemosyne:***@localhost:5432/test_db" pytest tests/ -v

📄 Lizenz

Apache-2.0-Lizenz. Entwickelt für das offene Ökosystem autonomer Agenten. Siehe LICENSE für vollständige Details.

Install Server

RayrunBuild, deploy, and operate MCP servers without becoming an infrastructure team.ray.runAd

license - permissive license

quality

maintenance

How are these scores calculated?

Maintenance

–Maintainers

–Response time

1wRelease cycle

2Releases (12mo)

Commit activity

Resources

GitHub Repository

Need Help?

Related Servers

Unclaimed servers have limited discoverability.

Looking for Admin?

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

Tools

View all tools

Related MCP Servers

aimemory
Knowledge & Memory RAG Systems
George3307
A
license
Not graded
quality
D
maintenance
Gives AI agents persistent memory with semantic search, automatic extraction, and memory decay, accessible via MCP protocol.
Updated 6 months ago (2026-02-20 22:53 UTC)
12
MIT
Synapto
Knowledge & Memory Search
ramonlimaramos
A
license
Not graded
quality
A
maintenance
Provides persistent, searchable memory for MCP-compatible agents, enabling recall by meaning, automatic decay, trust scoring, and cross-agent handoffs.
Updated 4 days ago (2026-08-27 15:11 UTC)
5
MIT
mcp-memory
Knowledge & Memory RAG Systems
oneKn8
A
license
A
quality
D
maintenance
Provides persistent memory with semantic search for MCP-based AI agents, enabling them to store and recall information across sessions using vector embeddings.
Updated 5 months ago (2026-03-23 14:16 UTC)
4
1
MIT
madb-mcp-server
Knowledge & Memory Autonomous Agents
spshkar84
F
license
Not graded
quality
B
maintenance
Provides persistent, causal memory for AI agents with semantic recall, causal tracking, and importance-based forgetting through MCP tools.
Updated 2 months ago (2026-07-07 04:22 UTC)

View all related MCP servers

Related MCP Connectors

XMemo
Shared, governed long-term memory for AI agents across tools and sessions via MCP and REST.
mcp
Your memory, everywhere AI goes. Build knowledge once, access it via MCP anywhere.
OpenAkashic
Shared long-term memory vault for AI agents with 20 MCP tools.

View all MCP Connectors

Latest Blog Posts

Who's Calling? MCP Hosts Are an Identity Blind Spot (And the Spec Knows It)
By Om-Shree-0709 on July 25, 2026.
mcp
Agent Identity
OAuth 2.1
Your AI Chatbot Just Exposed Your CEO's Salary to an Intern
By Om-Shree-0709 on July 2, 2026.
Agent Identity
MCP Security
OAuth Delegation
Why MCP Servers Need Execution Sandboxing (And Why Your Current Stack Isn't Enough)
By Om-Shree-0709 on June 30, 2026.
Agentic Ai
Prompt Injection
WebAssembly

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/M4F-S/gomaa'

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