MemoGraph 🧠

MemoGraph verwandelt einen Ordner mit Markdown-Notizen in einen abfragbaren, KI-bereiten Wissensgraphen. Es löst das Speicherproblem von LLMs — Ihre KI-Assistenten vergessen die Entscheidung von letztem Dienstag, finden eine verwandte Notiz über zwei Projekte hinweg nicht und leiten dieselbe Erkenntnis immer wieder neu her — indem es ihnen eine persistente, navigierbare, attributionsfreundliche Speicherschicht gibt, die in einfachen Markdown-Dateien lebt, die Sie kontrollieren.

Sie schreiben Notizen so, wie Sie es bereits tun. MemoGraph indexiert sie, baut aus [[wikilinks]] einen Graphen, ordnet sie nach Salienz und liefert sie auf Abruf an Ihr LLM (oder Ihr Team) zurück.

⚡ In 60 Sekunden ausprobieren

pip install memograph
memograph quickstart

Das war’s schon. Der quickstart-Befehl legt ein kleines, miteinander vernetztes Beispiel-Vault auf Ihrer Festplatte ab (15 Notizen über Python-Entwicklung, mit echten Wikilinks zwischen ihnen), übernimmt es in den Index und führt drei Live-Demo-Abfragen aus, damit Sie den Graphen und das Hybrid-Retrieval in Aktion sehen, bevor Sie sich festlegen. Probieren Sie insbesondere diese Abfrage:

memograph --vault ~/memograph-quickstart search "FastAPI dependency injection"

Das Vault enthält eine Notiz mit dem Titel FastAPI dependencies (über Depends(...)) — die Wörter „dependency“ und „injection“ kommen in keinem Titel einer Notiz vor. MemoGraph findet sie trotzdem, weil das Hybrid-Retrieval „dependency injection“ semantisch versteht und der Wikilink-Graph verwandte Notizen miteinander verknüpft. Das ist das Produkt — demonstriert in einer einzigen Abfrage.

Führen Sie memograph quickstart --force jederzeit erneut aus, um die Demo auf einen frischen Stand zurückzusetzen. Wenn Sie bereit sind, richten Sie MemoGraph auf Ihre echten Notizen aus: memograph --vault ~/your-notes ingest.

Related MCP server: exocortex

Was Sie bekommen

Als Einzelnutzer / Wissensarbeiter

• Ein Vault aus menschenlesbaren Markdown-Dateien — nichts Proprietäres, keine Herstellerbindung. Ihre Notizen überleben jedes Werkzeug.

• Hybrid-Retrieval, das Stichwortsuche, semantische Ähnlichkeit und Graphtraversierung kombiniert, sodass Sie die richtige Notiz finden, selbst wenn Sie sich nicht mit den genauen Worten erinnern.

• KI-gestütztes Tagging, Link-Vorschläge und Lücken-Erkennung, die Ihre Wissensbasis wachsen lassen, statt sie veralten zu lassen.

• Ein CLI und eine Weboberfläche zum Durchsuchen, Bearbeiten und Visualisieren des Graphen.

Als KI-Agent / IDE-Nutzer

• Ein erstklassiger Model Context Protocol (MCP)-Server mit über 30 Tools, der von Haus aus mit Claude Desktop, Claude Code, Cursor, Cline, Windsurf, Continue, Zed, VS Code, Goose, Gemini CLI, OpenAI Codex CLI und anderen funktioniert.

• Autonome „Auto-Save“-Hooks, die Entscheidungen und Kontext aus Ihren KI-Konversationen automatisch im Vault erfassen.

• Speicherabruf pro Konversation — Ihr Assistent kann „Was haben wir letzte Woche über X entschieden?“ abrufen, ohne dass Sie jedes Mal Kontext kopieren und einfügen müssen.

Als Enterprise-/SaaS-Betreiber

• Multi-Tenant-Bereitstellung mit Isolation auf Dateisystemebene pro Mandant, End-to-End-Isolationstests und einem Warm-LRU-Kernel-Cache.

• OIDC- und API-Key-Authentifizierung mit JWKS-Unterstützung (Auth0, Clerk, WorkOS, Keycloak, Azure AD, Okta), restriktiven CORS, Begrenzungen der Anforderungsgröße und Rate-Limiting.

• DSGVO-konforme geplante Löschung: Tombstone-Flow mit Gnadenfrist, automatische Abschluss-Backups, täglicher Reaper und ein Audit-Log für jede Löschung.

• Observability eingebaut: OpenTelemetry-Traces und Prometheus /metrics, strukturiertes JSON-Logging mit Request-IDs und separaten /healthz- und /readyz-Endpunkten für die Orchestrierung.

• Operations-Runbooks im Lieferumfang: Installation, SSO-Einrichtung, RBAC, Backup-Wiederherstellung und DSGVO-Verfahren.

So profitieren Anwender

✨ Fähigkeiten auf einen Blick

Kern-Speicher-Engine

• Graphbasierte Speicherung — bidirektionale [[wikilinks]] bauen automatisch einen navigierbaren Wissensgraphen.

• Hybrid-Retrieval — Stichwortsuche + semantische Embeddings + Graphverschiebung, kombiniert und neu bewertet.

• Speichertypen inspiriert von der Kognitionswissenschaft: episodisch, semantisch, prozedural, faktenbasiert.

• Salience-Scoring (0–1), das mit der Zeit abfällt und bei Zugriff verstärkt wird.

• Intelligentes Indexieren — mtime-gespeichert, nur veränderte Dateien werden neu geparst.

• Kontextkompression — bewusste Fensterung (token) für LLM-Prompts.

• Markdown-natives Vault — jeder Erinnerungs ist eine .md-Datei mit YAML frontmatter; kein proprietäres Format.

KI-Funktionen

• Smart Auto-Organization Engine — extrahiert Themen, Personen, Aufgaben, Entscheidungen, Fragen, Stimmung, Risiken, Ideen und für Wiederken Lebenslauf-Details aus Notizen.

• AutoTagger — schlägt Tags vor per semantischer Analyse, Strukturerkennung und Musterlernen.

• LinkSuggester — schlägt [[wikilinks]] zu verwandten Notizen vor; bidirektionale Möglichkeiten inklusive.

• GapDetector — zeigt fehlende Themen, schwache Abdeckung, isolierte Notizen und nicht gesetzte Links auf.

• Wissensanalyse — Vault-Statistiken, Themen-Clustering, Lernpfade, Verbindungsanalyse.

Schnittstellen

• Python-API — MemoryKernel mit synchronen, asynchronen und Batch-Varianten.

• CLI — 24+ Befehle für Ingest, Suche, Stapeloperationen, Import, Export, Backup und KI-Functionen.

• MCP-Server — 30+ Tools, stdio-Transport, ersatzlose Alternative (drop-in) für jeden MCP-kompatiblen Client.

• Web-UI — React + D3-Graph-Visualisierung, Suche und Bearbeitung (FastAPI-Backend + Vite-Frontend).

• HTTP-API — versioniertes /api/v1/, OpenAPI-Snapshot in CI, bereit für die Komplexität von Service-to-Service-Integration.

Enterprise- & SaaS-Bereitschaft

• Welche Bereitschaft — Mehrtätige, mit Dateisystem-getrenenzten Mandanten, ein Warm-Kernel-LRU-Register, Audit-Logs pro Mandant und End-to-end-Isolationstests als hohe Flughöhe.

• Authentifizierung über OIDC mit OIDC (JWKS) oder hashed API keys; rollenspezifische Authentifizierungs-Bereiche; Identität im Audit-Log verankert.

• Web-Härtung — restriktive CORS, slowapi-Rate-Limiting, Begrenzung der Anforderungsgröße, strukturierte JSON-Logs mit Request-IDs, 500-Handler ohne Informationslecks.

• Speicher-Härtung — path-traversal-sichere Vault-Schreibzugriffe, Soft/Hard-Limits für die Vault-Größe, versionierte Cachedateien.

• Geplante Löschung für den Anlagen-Fall GDPR Art 17: Tombstone mit konfigurierbarer Gnadenfrist, automatisches Last-Backup, täglicher Reaper-Skript, Endpunkt zum Verhindern vor Ablauf.

• Observability — OpenTelemetry FastAPI/asyncio-Auto-Instrumentation + Prometheus /metrics, OTLP-Export.

• Zuverlässigkeit — Concurrency-Audit, Stress-Tests für paralleles Schreiben, versioniertes Backup-Format mit Integritätschecks.

• Distribution — sauber gepinnte Abhängigkeiten, Docker Compose für Self-Hosting, Sicherheits-Workflow (bandit + pip-audit).

Hinweise für Betreiber: Siehe sind unter docs/INSTALL_ENTERPRISE.md, docs/SSO_SETUP.md, docs/GDPR_RUNBOOK.md, docs/BACKUP_RESTORE_RUNBOOK.md, docs/OBSERVABILITY_GUIDE.md und docs/RBAC_GUIDE.md.

🚀 Schnellstart

**Möchten Sie selbst hosten? docs/HOSTING_GUIDE.md behandelt vier echte kostenlose Pfad — Oracle Free Tier, Cloudflare-Tunnel + eigene Hardware (für die meisten empfohlen), GCP Always-Free-Kombination und GitHub-Repo als Vault. Workspace-Identität auf via OIDC und Datenaustauschab als Portabilitäts-Backup sind in docs/GOOGLE_WORKSPACE_SETUP.md erklärt.

Installation

pip install memograph

Installieren Sie mit optionalen Abhängigkeiten:

# For OpenAI support
pip install memograph[openai]

# For Anthropic Claude support
pip install memograph[anthropic]

# For Ollama support
pip install memograph[ollama]

# For embedding support
pip install memograph[embeddings]

# Install everything
pip install memograph[all]

Python-Verwendung

from memograph import MemoryKernel, MemoryType

# Initialize the kernel attached to your vault path
kernel = MemoryKernel("~/my-vault")

# Ingest all notes in the vault
stats = kernel.ingest()
print(f"Indexed {stats['indexed']} memories.")

# Programmatically add a new memory
kernel.remember(
    title="Meeting Note",
    content="Decided to use BFS graph traversal for retrieval.",
    memory_type=MemoryType.EPISODIC,
    tags=["design", "retrieval"]
)

# Retrieve context for an LLM query
context = kernel.context_window(
    query="how does retrieval work?",
    tags=["retrieval"],
    depth=2,
    top_k=8
)

print(context)

🔌 MCP-Server (Model Context Protocol)

MemoGraph enthält einen vollwertigen MCP-Server für die nahtlose Integration mit KI-Assistenten wie Cline und Claude Desktop.

📖 Neu bei MemoGraph MCP? Siehe MCP-Benutzerhandbuch für praktische Anweisungen und Beispiele!

🚨 Verbindungsprobleme? Siehe Setup- & Troubleshooting-Leitfaden – häufige Lösungen: Rückengebote für „cannot connect“-Fehler!

19 verfügbare Tools

Unterstützte Clients

Der MCP-Server von MemoGraph ist ein stdio-Server – er läuft zusammen mit jeder MCP-kompatiblen agentenbasierten CLI oder jedem Editor. Das vollständige Setup-Kochbuch (Konfigurationsdateipfade, Formatbesonderheiten, Verifikationsschritte) findest du in docs/MCP_CLIENTS.md:

MCP-Server starten

Nach pip install memograph (oder uv tool install memograph) sind die drei Startbefehle äquivalent:

memograph-mcp                              # console script (recommended)
python -m memograph.mcp.run_server         # module form (works with any Python)
uvx --from memograph memograph-mcp         # zero-install via uv

memograph-mcp und memograph sind beide als Konsolenskripte registriert: Der erste startet den MCP-Server, der zweite mit (CLI). Sie kollidieren nicht. übersetzt:

memograph-mcp und memograph sind beide als Konsolenskripte registriert: Ersteres startet den MCP-Server, Letzteres ist die CLI. Sie kollidieren nicht.

Wenn beide als Console-Scripts registriert sind, sind memograph-mcp und memograph zwei getrennte Befehle: memograph-mcp startet den MCP-Server, memograph die CLI.

memograph-mcp und memograph sind beide als Konsolenskripte registriert: der erste Befehl startet den MCP-Server, der zweite ist die CLI. Sie kollidieren nicht.

memograph-mcp und memograph sind beide als Konsolenskripte registriert: der erste Befehl startet den MCP-Server, der zweite die CLI. Sie kollidieren nicht.

memograph-mcp                              # console script (recommended)
python -m memograph.mcp.run_server         # module form (works with any Python)
uvx --from memograph memograph-mcp         # zero-install via uv

memograph-mcp und memograph sind beide als Konsolenskripte registriert: der erste Befehl startet den MCP-Server, der zweite ist die CLI. Sie kollidieren nicht.

Nur-Lese-Modus

Für gemeinsame Bereitstellungen oder nicht vertrauenswürdige Clients setze MEMOGRAPH_READONLY=true. Der Server lehnt jedes Vault-schreibende Werkzeug ab – create_memory, import_document, update_memory, delete_memory, relate_memories, bulk_create, batch_update, batch_delete, import_backup_tool und die Auto-Save-Hooks – und gibt stattdessen ein strukturiertes {"success": false, "readonly": true, "error": "..."}-Antwortobjekt zurück. Lese-Werkzeuge (search_vault, query_with_context, list_memories, get_memory, Analysen, Graph-Durchläufe) bleiben voll funktionsfähig.

Schnellstart für Claude Desktop

Füge dies zu deiner claude_desktop_config.json hinzu:

{
  "mcpServers": {
    "memograph": {
      "command": "memograph-mcp",
      "env": {
        "MEMOGRAPH_VAULT": "/path/to/your/vault"
      }
    }
  }
}

Wenn das memograph-mcp-Binary nicht im PATH des Clients liegt (häufig der Fall, wenn der Client ohne deine Shell-Umgebung startet), verwende stattdessen die explizite Modulform:

{
  "mcpServers": {
    "memograph": {
      "command": "python",
      "args": ["-m", "memograph.mcp.run_server"],
      "env": {
        "MEMOGRAPH_VAULT": "/path/to/your/vault"
      }
    }
  }
}

Schnellstart für Cline

Füge dies zu deiner ~/.cline/mcp_settings.json hinzu:

{
  "mcp": {
    "servers": {
      "memograph": {
        "command": "memograph-mcp",
        "env": {
          "MEMOGRAPH_VAULT": "/path/to/your/vault"
        }
      }
    }
  }
}

Für Claude Code, Cursor, Windsurf, Continue, Zed, VS Code, Goose, Gemini CLI, Codex CLI, LM Studio, Cherry Studio und Bob Shell siehe docs/MCP_CLIENTS.md.

Aus der MCP-Registry installieren

NEU: MemoGraph ist jetzt in der offiziellen MCP-Registry verfügbar! 🎉

Registry-URL: https://github.com/modelcontextprotocol/servers/tree/main/src/memograph

pip install memograph

Füge anschließend das Snippet für deinen Client in dessen Konfigurationsdatei ein (siehe Tabelle oben oder docs/MCP_CLIENTS.md).

Vorteile der MCP-Registry-Eintragung:

• ✅ Offizielle Registry, unterstützt von Anthropic, GitHub und Microsoft

• ✅ Auffindbar für alle MCP-Kompatiblen Clients

• ✅ Verifizierte Server-Karte und -Metadaten

• ✅ Direkter Link vom PyPI-Paket

• ✅ Vertrauenswürdig in der MCP-Community

Hinweis: Die Registry verwendet die PyPI-Paketversion. Wenn du pip install memograph ausführst, erhältst du automatisch die neueste in der Registry gelistete Version.

Weitere Informationen zum Einreichen und zur Konfiguration findest du unter MCP_REGISTRY_GUIDE.md.

Verwendungsbeispiele

Verwende nach der Einrichtung natürliche Sprache mit deinem KI-Assistenten:

"Search my vault for memories about Python"
"Create a memory titled 'Project Ideas' with content '...'"
"Update memory abc-123 to have salience 0.9"
"Delete memory xyz-456"
"What tools are available?"
"Get vault statistics"

Eine vollständige MCP-Konfigurationsanleitung findest du in CONFIG_REFERENCE.md.

Auto-Save-Hooks verwenden

MemoGraph bietet autonome Hooks, um Gespräche automatisch zu speichern:

• ⚠️ Wichtig: Hooks sind passiv Tools – siehe Leitfaden für autonome Hooks für die Einrichtung.

• 📝 Schnelltest: Füge Claude Desktop eine benutzerdefinierte Anweisung hinzu (Anweisungen im Leitfaden).

• 🔧 Konfiguration: Einrichtbar mit MEMOGRAPH_AUTONOMOUS_MODE=true.

Vollständigen Leitfaden für autonome Hooks lesen →

🎯 CLI-Verwendung

MemoGraph wird mit einer leistungsstarken CLI für die Verwaltung deines Vaults und für Gespräche damit geliefert.

Ingest

Indiziere deine Markdown-Dateien in die Graph-Datenbank:

memograph --vault ~/my-vault ingest

Erzwinge die Neuindizierung aller Dateien:

memograph --vault ~/my-vault ingest --force

Remember

Füge schnell ein Memory über die Kommandozeile hinzu:

memograph --vault ~/my-vault remember \
    --title "Team Sync" \
    --content "Discussed Q3 goals." \
    --tags planning q3

Kontextfenster

Erzeuge Kontext für eine Abfrage:

memograph --vault ~/my-vault context \
    --query "What did we decide about the database?" \
    --tags architecture \
    --depth 2 \
    --top-k 5

Ask (interaktiver Chat)

Starte eine interaktive Chat-Sitzung mit dem Kontext deines Vaults:

memograph --vault ~/my-vault ask --chat --provider ollama --model llama3

Oder stelle eine einzelne Frage:

memograph --vault ~/my-vault ask \
    --query "Summarize our design decisions" \
    --provider claude \
    --model claude-3-5-sonnet-20240620

Diagnose

Prüfe deine Umgebung und die Verbindung zu LLM-Anbietern:

memograph --vault ~/my-vault doctor

### Import Documents

Import documents (TXT, PDF, DOCX) and convert them to markdown:

```bash
# Import a single file
memograph --vault ~/my-vault import document.pdf --type episodic

# Import entire folder
memograph --vault ~/my-vault import ~/Documents --recursive

# Preview files without importing (dry run)
memograph --vault ~/my-vault import ~/Documents --dry-run

# Auto-ingest after import
memograph --vault ~/my-vault import document.pdf --auto-ingest

Stapeloperationen

Verwalte mehrere Memories effizient auf einmal:

# Bulk create memories from JSON/CSV
memograph --vault ~/my-vault batch-create memories.json

# Bulk update memories by filter
memograph --vault ~/my-vault batch-update \
    --filter-tags outdated \
    --add-tags reviewed \
    --salience 0.8

# Bulk delete with safety checks
memograph --vault ~/my-vault batch-delete \
    --filter-type episodic \
    --filter-max-salience 0.3 \
    --dry-run

Datenverwaltung

Exportiere, sichere und stelle deinen Vault wieder her:

# Export vault to JSON/CSV/Markdown
memograph --vault ~/my-vault export --format json --output backup.json

# Create timestamped backup
memograph --vault ~/my-vault backup --output ./backups

# Restore from backup
memograph --vault ~/my-vault import-backup backup.zip

Konfiguration & Statistiken

Verwalte Einstellungen und Freischalte Vault-Analysen:

# View vault statistics
memograph --vault ~/my-vault stats

# Configure settings
memograph config set embedding_provider openai
memograph config get embedding_provider
memograph config list

# Manage profiles
memograph config profile create work --vault ~/work-vault
memograph config profile use work

MCP-Setup

Interaktiver Assistent für die MCP-Server-Konfiguration von Claude Desktop oder Cline:

# Run interactive setup wizard
memograph setup-mcp

# Verify MCP configuration
memograph verify-mcp

📖 Vollständige CLI-Dokumentation: Siehe dazu CLI Usage Guide mit über 200 Beispielen und alle 24 Befehlen umfassenden Details.

KI-Funktionen

MemoGraph enthält köstige KI-gestützte Sportlichkeiten, um deinen Wissensmanagement-Workflow zu verbessern. Mit AI Features Guide gibt es eine komplette Dokumentation.

🏷️ AutoTagger – Intelligente Tag-Empfehlungen

Schlage automatisch relevante Tags mithilfe von semantischer Analyse, Inhaltsstruktur und vorhandenen Mustern vor:

# Suggest tags for a note
memograph suggest-tags note.md

# Apply high-confidence suggestions automatically
memograph suggest-tags note.md --apply

# Adjust confidence threshold and limit
memograph suggest-tags note.md --min-confidence 0.5 --max-suggestions 10

Funktionen: Häufigkeitsbasierte Extraktion • Semantische Ähnlichkeit • Strukturerkennung • Musterlernen • Konfidenz-Scoring

🔗 LinkSuggester – Intelligente Wikilink-Empfehlungen

Empfiehl intelligent Wikilinks zu verwandten Notizen mithilfe von semantischer Ähnlichkeit und Graph-Analyse:

# Suggest links for a note
memograph suggest-links note.md

# Apply suggestions automatically
memograph suggest-links note.md --apply

# Show bidirectional link opportunities
memograph suggest-links note.md --show-bidirectional

Funktionen: Semantische Suche • Stichwortabgleich • Graph-basierte Vorschläge • Bidirektionale Erkennung • Zielvorschauen

🔍 GapDetector – Wissensbasis-Analyse

Identifiziere fehlende Themen, schwache Abdeckung und isolierte Noten in deinem Vault:

# Detect all gaps
memograph detect-gaps

# Focus on high-severity gaps
memograph detect-gaps --min-severity 0.7

# Export results to JSON
memograph detect-gaps --output json > gaps.json

Lückentypen: Fehlende Themen • Schwache Abdeckung • Determinierte Notizen • Fehlende Links

📊 Wissensanalyse – Umfassende Einblicke

Erhalte eine umfassende Analyse deiner gesamten Wissensbasis:

# Full analysis with all features
memograph analyze-knowledge

# Export detailed report to JSON
memograph analyze-knowledge --output json > analysis.json

Analyse umfasst: Vault-Statistiken • Themen-Clustering • Lernpfade • Lücken-Erkennung • Verbindungsanalyse

Python-API für KI-Funktionen

from memograph import MemoryKernel
from memograph.ai import AutoTagger, LinkSuggester, GapDetector

kernel = MemoryKernel("~/my-vault")
kernel.ingest()

# Get tag suggestions
tagger = AutoTagger(kernel, min_confidence=0.4)
suggestions = await tagger.suggest_tags(
    content="Python is great for data science",
    title="Data Science with Python"
)

# Get link suggestions
suggester = LinkSuggester(kernel, min_confidence=0.5)
links = await suggester.suggest_links(
    content="Python async programming tutorial",
    title="Async Python"
)

# Detect knowledge gaps
detector = GapDetector(kernel, min_severity=0.5)
gaps = await detector.detect_gaps()

# Comprehensive analysis
analysis = await detector.analyze_knowledge_base()

📖 Vollständige Dokumentation:

• AI Features Guide – Vollständige Anleitung mit Beispielen

• Web-UI-Leitfaden – KI-Funktionen im Browser nutzen

• MCP AI Tools Guide – KI-Funktionen für Claude und Cline

💡 Anwendungsfälle: Notiz automatisch organisieren • Verbindungen entdecken • Lücken identifizieren • Konsistenz bewahren • Lernpfade erstellen

📚 Grundkonzepte

Memory-Typen

MemoGraph unterstützt verschiedene, von der Kognitionswissenschaft inspirierte Memory-Typen:

• Episodisch: Persönliche Erfahrungen und Ereignisse (z.B. Besprechungsnotizen)

• Semantisch: Begriff „Semantisch“ = Fakten und Allgemeinwissen (z. B. Doku)

• Prozedural: (Prozedural) Wissen, wie X geht, und Prozesse (z.B. Tutorials)

• Fakt: (Fakt) Fakt und Informationsbausteine (z.B. Konfigurationswerte)

Graph-Durchlauf

Die Bibliothek verwendet BFS (Breadth-First-Search) zum Durchlaufen deines Wissensgraphen:

# Retrieve nodes with depth=2 (2 hops from seed nodes)
nodes = kernel.retrieve_nodes(
    query="graph algorithms",
    depth=2,  # Traverse up to 2 levels deep
    top_k=10  # Return top 10 relevant memories
)

Salienz-Scoring

Jedes Memory besitzt einen Salienz-Wert (0.0–1.0), der dessen Wichtigkeit widerspiegelt:

---
title: "Critical Architecture Decision"
salience: 0.9
memory_type: semantic
---

We decided to use PostgreSQL for better ACID guarantees...

🏗️ Projektstruktur

MemoGraph/
├── memograph/          # Main package
│   ├── core/           # Core functionality
│   │   ├── kernel.py   # Memory kernel
│   │   ├── graph.py    # Graph implementation
│   │   ├── retriever.py # Hybrid retrieval
│   │   ├── indexer.py  # File indexing
│   │   └── parser.py   # Markdown parsing
│   ├── adapters/       # LLM and embedding adapters
│   │   ├── embeddings/ # Embedding providers
│   │   ├── frameworks/ # Framework integrations
│   │   └── llm/        # LLM providers
│   ├── storage/        # Storage and caching
│   ├── mcp/            # MCP server implementation
│   └── cli.py          # CLI implementation
├── tests/              # Test suite
├── examples/           # Example usage
└── scripts/            # Utility scripts

🤝 Mitwirken

Wir freuen uns über Beiträge! Bitte wirf einen Blick in unseren Contributing Guide.

Entwicklungsumgebung

1. Clone das Repository:

   git clone https://github.com/Indhar01/MemoGraph.git
   cd MemoGraph

2. Installiere das Entwicklungsmodus:

   pip install -e ".[all,dev]"

3. Installiere die Pre-Commit-Hooks:

   pre-commit install

4. Führe Tests aus:

   pytest

Code-Qualität

Wir halten hohe Code-Qualitätsstandards ein:

• Minierung: Ruff für schnelle Python-Linting

• Formatierung: Ruff-Formatierer für einen einheitlichen Code-Stil

• Typ-Prüfung: MyPy für statische Type-Analyse

• Tests: Pytest mit umfassender Testabdeckung

• Pre-Commit-Hooks: Automatisierte Prüfungen vor jedem Commit

📚 Dokumentation

Erste Schritte

• Hosting-Leitfaden - 💸 Kostenlose Hosting-Optionen (Oracle Free Tier, Cloudflare Tunnel, GCP, GitHub-vault) mit Checkliste zur Härtung der Systeme

• Google Workspace-Setup - 🔐 OIDC-Identität + Drive-Portabilitäts-Backup

• MCP-Clients-Leitfaden - 🔌 Setup-Snippets für 15+ agentische CLIs/Editoren (Claude Code, Cursor, Windsurf, Continue, OIDC, Zed, VS Code, Goose, Gemini CLI, Codex CLI, LM Studio, …)

• MCP-Benutzerhandbuch - ⭐ Hier starten! Vollständiger Leitfaden zur Verwendung von MemoGraph MCP

• Setup & Fehlerbehebung - 🚨 Keine Verbindung möglich? Schritt-für-Schritt-Lösungen für Verbindungsprobleme

• MCP-Testleitfaden - Teste deinen MCP-Server nach dem Setup

Für Entwickler & Mitwirkende

• MCP-Registry-Leitfaden - Veröffentlichung in der offiziellen MCP-Registry

• Versionierungsstrategie - Semantische Versionierung und Release-Planung

• AGENTS.md - Leitfaden für KI-Agenten, die mit dieser Codebase arbeiten

• Mitwirkungsleitfaden - So kannst du zum Projekt beitragen

• Verhaltenskodex - Community-Richtlinien

• Sicherheitsrichtlinie - Sicherheitsmeldungen und bewährte Verfahren

• Changelog - Versionshistorie und Änderungen

🔒 Sicherheit

Informationen zum Melden von Schwachstellen findest du unter Sicherheitsrichtlinie.

📄 Lizenz

Dieses Projekt ist unter der MIT-Lizenz lizenziert - alle Details dazu findest du in der Lizenzdatei.

🌟 Danksagungen

Entstanden aus dem Bedürfnis nach besserer Speicherverwaltung in LLM-Anwendungen. Entwickelt mit:

• Graph-basierte Wissensdarstellung

• Hybride Retrieval-Strategien

• Prinzipien der Kognitionswissenschaft

📬 Kontakt & Support

• Issues: GitHub Issues

• Diskussionen: GitHub Discussions

📣 Community & Feedback

Wir schätzen Feedback und Beiträge der Community! So kannst du dich beteiligen:

Issues melden

Einen Bug gefunden oder eine Funktionsanfrage zu? Eröffne ein Issue auf GitHub unter:
Öffne ein Issue

Diskussionen

Mach mit bei GitHub Discussions:

• Stelle Fragen

• Teile Anwendungsfälle

• Schlage Verbesserungen vor

• Zeig, was du gebaut hast

Mitwirken

Beiträge sind willkommen! Einzelheiten findest du im Mitwirkungsleitfaden:

• Code-Beiträge

• Verbesserung der Dokumentation

• Fehlermeldungen und Funktionsanfragen

• Community-Support

Bleib auf dem Laufenden

• ⭐ Setze den Repository auf GitHub ein Urheberom

• 👁️ Beobachte Updates und Releases

• 📦 Folge dem Projekt auf PyPI

• 🔗 Schau dir den MCP-Registry-Eintrag an

🚀 Status

Aktuelle Version: 0.3.0

Einzelmandant-Bereitstellungen sind stabil und für die Produktion empfalung aktiv.
Mehr-Mandant-Bereitstellungen sind funktional vollständig; End-to-End-Isolationstests dienen als Alpha-Release-Bedingung. Die öffentliche API wird bis Version 1.0 stabilisiert.

• ✅ Kernfunktionalität stabil und getestet (172+ Tests in Security‑, Contract- und Mandant-Suiten)

• ✅ Paket-weite Typ-Prüfung mit MyPy

• ✅ Ruff linting + formatting + Pre-Commit-Hooks

• ✅ OpenAPI-1.0 Contracts-Snapshot in der CI

• ✅ Multi-Tenant-Isolations-invariants verified by an e2e-Testsuite

• ⚠️ Die öffentliche API kann sich bis v1.0.0 in Minor-Releases ändern

Kürzliche Neuerungen

• Phase 3.7 — DSGVO-konforme geplante Löschung von Mandanten: Tombstone-Methode mit Wartefrist, täglicher Reaper, automatische abschließende Backups.

• Phase 3.5 — TenantRegistry in den Request-Pfad integriert; Nicht-Admin-Routen lösen ihren Kern pro Mandant auf.

• Phase-3-Scaffold — Multi-Tenancy-ADR, TenantStorage, TenantRegistry, Admin-Routen für den Mandanten-Lebenszyklus.

• Phase 2 — OpenTelemetry + Prometheus, strukturiertes JSON-Logging, Konkurrenz-Audit, Belastungstests.

• Phase 1 — OIDC- und API-Key-Auth, slowapi-Rate-Limiting, restriktive CORS, Anfrage- und Vault-Größenbegrenzung, Schema-versionierte Caches, OpenAPI-1-Contract, Sicherheits-Testsuite.

• Phase 0 — Pfad-Traversal-sichere Vault-Schreibvorgänge, fehlerhunterberichte Info-Leak-Handler, gepinnte Abhängigkeiten, Docker-Compose, Sicherheits-CI-Workflow.

• 📦 Im offiziellen MCP-Registry veröffentlicht (io.github.indhar01/memograph)

Mit ❤️ gemacht für ein besseres LLM-Speichermanagement.