Skip to main content
Glama
deenesjakoruzh
gannonh

memento-mcp

by gannonh
OverviewSchemaRelated ServersScoreDiscussions
TypeScript
Hybrid

Memento MCP: Ein Knowledge Graph Memory System für LLMs

Memento MCP-Logo

Skalierbares, leistungsstarkes Wissensgraphen-Speichersystem mit semantischem Abruf, kontextuellem Abruf und zeitlicher Wahrnehmung. Bietet jedem LLM-Client, der das Modellkontextprotokoll unterstützt (z. B. Claude Desktop, Cursor, Github Copilot), einen robusten, adaptiven und persistenten ontologischen Langzeitspeicher.

Memento MCP-Tests Schmiedeabzeichen

Kernkonzepte

Entitäten

Entitäten sind die primären Knoten im Wissensgraphen. Jede Entität verfügt über:

  • Ein eindeutiger Name (Kennung)

  • Ein Entitätstyp (z. B. „Person“, „Organisation“, „Ereignis“)

  • Eine Liste von Beobachtungen

  • Vektoreinbettungen (für die semantische Suche)

  • Vollständiger Versionsverlauf

Beispiel:

{
  "name": "John_Smith",
  "entityType": "person",
  "observations": ["Speaks fluent Spanish"]
}

Beziehungen

Relationen definieren gerichtete Verbindungen zwischen Entitäten mit erweiterten Eigenschaften:

  • Stärkeindikatoren (0,0-1,0)

  • Konfidenzniveaus (0,0–1,0)

  • Umfangreiche Metadaten (Quelle, Zeitstempel, Tags)

  • Zeitliches Bewusstsein mit Versionsverlauf

  • Zeitbasierter Vertrauensverlust

Beispiel:

{
  "from": "John_Smith",
  "to": "Anthropic",
  "relationType": "works_at",
  "strength": 0.9,
  "confidence": 0.95,
  "metadata": {
    "source": "linkedin_profile",
    "last_verified": "2025-03-21"
  }
}

Related MCP server: Memory MCP Server

Speicher-Backend

Memento MCP verwendet Neo4j als Speicher-Backend und bietet eine einheitliche Lösung sowohl für die Graphspeicherung als auch für die Vektorsuchfunktionen.

Warum Neo4j?

  • Unified Storage : Konsolidiert sowohl den Grafik- als auch den Vektorspeicher in einer einzigen Datenbank

  • Native Graph-Operationen : Speziell für Graph-Traversierung und Abfragen entwickelt

  • Integrierte Vektorsuche : Vektorähnlichkeitssuche für Einbettungen direkt in Neo4j integriert

  • Skalierbarkeit : Bessere Leistung mit großen Wissensgraphen

  • Vereinfachte Architektur : Klares Design mit einer einzigen Datenbank für alle Vorgänge

Voraussetzungen

  • Neo4j 5.13+ (erforderlich für Vektorsuchfunktionen)

Neo4j Desktop-Setup (empfohlen)

Der einfachste Weg, mit Neo4j zu beginnen, ist die Verwendung von Neo4j Desktop :

  1. Laden Sie Neo4j Desktop von https://neo4j.com/download/ herunter und installieren Sie es

  2. Erstellen eines neuen Projekts

  3. Hinzufügen einer neuen Datenbank

  4. Setzen Sie das Passwort auf memento_password (oder Ihr bevorzugtes Passwort).

  5. Starten der Datenbank

Die Neo4j-Datenbank wird verfügbar sein unter:

  • Bolt-URI : bolt://127.0.0.1:7687 (für Treiberverbindungen)

  • HTTP : http://127.0.0.1:7474 (für Neo4j-Browser-UI)

  • Standardanmeldeinformationen : Benutzername: neo4j , Passwort: memento_password (oder was auch immer Sie konfiguriert haben)

Neo4j-Setup mit Docker (Alternative)

Alternativ können Sie Docker Compose verwenden, um Neo4j auszuführen:

# Start Neo4j container
docker-compose up -d neo4j

# Stop Neo4j container
docker-compose stop neo4j

# Remove Neo4j container (preserves data)
docker-compose rm neo4j

Bei Verwendung von Docker ist die Neo4j-Datenbank verfügbar unter:

  • Bolt-URI : bolt://127.0.0.1:7687 (für Treiberverbindungen)

  • HTTP : http://127.0.0.1:7474 (für Neo4j-Browser-UI)

  • Standardanmeldeinformationen : Benutzername: neo4j , Passwort: memento_password

Datenpersistenz und -verwaltung

Neo4j-Daten bleiben aufgrund der Docker-Volume-Konfiguration in der Datei docker-compose.yml über Containerneustarts und sogar Versionsupgrades hinweg erhalten:

volumes:
  - ./neo4j-data:/data
  - ./neo4j-logs:/logs
  - ./neo4j-import:/import

Diese Zuordnungen stellen Folgendes sicher:

  • Das Verzeichnis /data (enthält alle Datenbankdateien) bleibt auf Ihrem Host unter ./neo4j-data bestehen.

  • Das Verzeichnis /logs bleibt auf Ihrem Host unter ./neo4j-logs bestehen

  • Das Verzeichnis /import (zum Importieren von Datendateien) bleibt unter ./neo4j-import bestehen.

Sie können diese Pfade in Ihrer Datei docker-compose.yml ändern, um Daten bei Bedarf an anderen Orten zu speichern.

Aktualisieren der Neo4j-Version

Sie können Neo4j-Editionen und -Versionen ohne Datenverlust ändern:

  1. Aktualisieren Sie die Neo4j-Image-Version in docker-compose.yml

  2. Starten Sie den Container mit docker-compose down && docker-compose up -d neo4j

  3. Initialisieren Sie das Schema mit npm run neo4j:init

Die Daten bleiben während dieses Vorgangs erhalten, solange die Volume-Zuordnungen gleich bleiben.

Vollständiges Zurücksetzen der Datenbank

Wenn Sie Ihre Neo4j-Datenbank vollständig zurücksetzen müssen:

# Stop the container
docker-compose stop neo4j

# Remove the container
docker-compose rm -f neo4j

# Delete the data directory contents
rm -rf ./neo4j-data/*

# Restart the container
docker-compose up -d neo4j

# Reinitialize the schema
npm run neo4j:init
Daten sichern

Um Ihre Neo4j-Daten zu sichern, können Sie einfach das Datenverzeichnis kopieren:

# Make a backup of the Neo4j data
cp -r ./neo4j-data ./neo4j-data-backup-$(date +%Y%m%d)

Neo4j CLI-Dienstprogramme

Memento MCP enthält Befehlszeilenprogramme zur Verwaltung von Neo4j-Vorgängen:

Verbindung testen

Testen Sie die Verbindung zu Ihrer Neo4j-Datenbank:

# Test with default settings
npm run neo4j:test

# Test with custom settings
npm run neo4j:test -- --uri bolt://127.0.0.1:7687 --username myuser --password mypass --database neo4j

Schema initialisieren

Im Normalbetrieb erfolgt die Initialisierung des Neo4j-Schemas automatisch, wenn Memento MCP eine Verbindung zur Datenbank herstellt. Für den regulären Gebrauch müssen Sie keine manuellen Befehle ausführen.

Die folgenden Befehle sind nur für Entwicklungs-, Test- oder erweiterte Anpassungsszenarien erforderlich:

# Initialize with default settings (only needed for development or troubleshooting)
npm run neo4j:init

# Initialize with custom vector dimensions
npm run neo4j:init -- --dimensions 768 --similarity euclidean

# Force recreation of all constraints and indexes
npm run neo4j:init -- --recreate

# Combine multiple options
npm run neo4j:init -- --vector-index custom_index --dimensions 384 --recreate

Erweiterte Funktionen

Semantische Suche

Suchen Sie semantisch verwandte Entitäten auf der Grundlage ihrer Bedeutung und nicht nur anhand von Schlüsselwörtern:

  • Vektoreinbettungen : Entitäten werden mithilfe der Einbettungsmodelle von OpenAI automatisch in einen hochdimensionalen Vektorraum kodiert

  • Kosinus-Ähnlichkeit : Finden Sie verwandte Konzepte, auch wenn sie unterschiedliche Terminologie verwenden

  • Konfigurierbare Schwellenwerte : Legen Sie Mindestähnlichkeitswerte fest, um die Ergebnisrelevanz zu steuern

  • Cross-Modal-Suche : Abfrage mit Text, um relevante Entitäten zu finden, unabhängig davon, wie sie beschrieben wurden

  • Unterstützung mehrerer Modelle : Kompatibel mit mehreren Einbettungsmodellen (OpenAI text-embedding-3-small/large)

  • Kontextbezogene Abfrage : Rufen Sie Informationen basierend auf der semantischen Bedeutung und nicht auf genauen Schlüsselwortübereinstimmungen ab

  • Optimierte Standardeinstellungen : Angepasste Parameter für das Gleichgewicht zwischen Präzision und Rückruf (Ähnlichkeitsschwelle 0,6, Hybridsuche aktiviert)

  • Hybridsuche : Kombiniert semantische und Stichwortsuche für umfassendere Ergebnisse

  • Adaptive Suche : Das System wählt intelligent zwischen reiner Vektor-, reiner Stichwort- oder Hybridsuche basierend auf Abfragemerkmalen und verfügbaren Daten

  • Leistungsoptimierung : Priorisiert die Vektorsuche für semantisches Verständnis und behält gleichzeitig Fallback-Mechanismen für mehr Ausfallsicherheit bei

  • Abfragebasierte Verarbeitung : Passt die Suchstrategie basierend auf der Abfragekomplexität und den verfügbaren Entitätseinbettungen an

Zeitliches Bewusstsein

Verfolgen Sie den vollständigen Verlauf von Entitäten und Beziehungen mit der zeitpunktbezogenen Graphenabfrage:

  • Vollständiger Versionsverlauf : Jede Änderung an einer Entität oder Beziehung wird mit Zeitstempeln gespeichert

  • Point-in-Time-Abfragen : Rufen Sie den genauen Status des Wissensgraphen zu jedem beliebigen Zeitpunkt in der Vergangenheit ab

  • Änderungsverfolgung : Zeichnet automatisch die Zeitstempel „createdAt“, „updatedAt“, „validFrom“ und „validTo“ auf

  • Zeitliche Konsistenz : Behalten Sie eine historisch genaue Sicht auf die Entwicklung des Wissens bei

  • Zerstörungsfreie Updates : Updates erstellen neue Versionen, anstatt vorhandene Daten zu überschreiben

  • Zeitbasiertes Filtern : Filtern Sie Diagrammelemente basierend auf zeitlichen Kriterien

  • Historische Erkundung : Untersuchen Sie, wie sich bestimmte Informationen im Laufe der Zeit verändert haben

Vertrauensverlust

Die Vertrauenswürdigkeit von Beziehungen nimmt mit der Zeit automatisch ab, basierend auf einer konfigurierbaren Halbwertszeit:

  • Zeitbasierter Verfall : Das Vertrauen in Beziehungen nimmt natürlich mit der Zeit ab, wenn es nicht gestärkt wird

  • Konfigurierbare Halbwertszeit : Definieren Sie, wie schnell Informationen unsicherer werden (Standard: 30 Tage)

  • Mindestvertrauensgrenzen : Legen Sie Schwellenwerte fest, um einen übermäßigen Verfall wichtiger Informationen zu verhindern

  • Zerfallsmetadaten : Jede Beziehung enthält detaillierte Informationen zur Zerfallsberechnung

  • Zerstörungsfrei : Die ursprünglichen Vertrauenswerte bleiben neben den verfallenen Werten erhalten

  • Reinforcement Learning : Beziehungen gewinnen an Vertrauen, wenn sie durch neue Beobachtungen verstärkt werden

  • Flexibilität der Referenzzeit : Berechnen Sie den Zerfall basierend auf beliebigen Referenzzeiten für die historische Analyse

Erweiterte Metadaten

Umfangreiche Metadatenunterstützung für Entitäten und Beziehungen mit benutzerdefinierten Feldern:

  • Quellenverfolgung : Aufzeichnen, woher die Informationen stammen (Benutzereingaben, Analysen, externe Quellen)

  • Konfidenzniveaus : Weisen Sie Beziehungen basierend auf der Gewissheit Konfidenzwerte (0,0-1,0) zu

  • Beziehungsstärke : Geben Sie die Wichtigkeit oder Stärke von Beziehungen an (0,0–1,0).

  • Zeitliche Metadaten : Verfolgen Sie, wann Informationen hinzugefügt, geändert oder überprüft wurden

  • Benutzerdefinierte Tags : Fügen Sie beliebige Tags zur Klassifizierung und Filterung hinzu

  • Strukturierte Daten : Speichern Sie komplexe strukturierte Daten in Metadatenfeldern

  • Abfrageunterstützung : Suchen und Filtern basierend auf Metadateneigenschaften

  • Erweiterbares Schema : Fügen Sie nach Bedarf benutzerdefinierte Felder hinzu, ohne das Kerndatenmodell zu ändern

MCP-API-Tools

Die folgenden Tools stehen LLM-Client-Hosts über das Model Context Protocol zur Verfügung:

Entitätsverwaltung

  • Entitäten erstellen

    • Erstellen Sie mehrere neue Entitäten im Wissensgraphen

    • Eingabe: entities (Array von Objekten)

      • Jedes Objekt enthält:

        • name (Zeichenfolge): Entitätskennung

        • entityType (Zeichenfolge): Typklassifizierung

        • observations (Zeichenfolge[]): Zugehörige Beobachtungen

  • Beobachtungen hinzufügen

    • Hinzufügen neuer Beobachtungen zu vorhandenen Entitäten

    • Eingabe: observations (Array von Objekten)

      • Jedes Objekt enthält:

        • entityName (Zeichenfolge): Zielentität

        • contents (Zeichenfolge[]): Neue hinzuzufügende Beobachtungen

  • delete_entities

    • Entfernen von Entitäten und ihren Beziehungen

    • Eingabe: entityNames (string[])

  • Beobachtungen löschen

    • Entfernen Sie bestimmte Beobachtungen von Entitäten

    • Eingabe: deletions (Array von Objekten)

      • Jedes Objekt enthält:

        • entityName (Zeichenfolge): Zielentität

        • observations (Zeichenfolge[]): Zu entfernende Beobachtungen

Beziehungsmanagement

  • Beziehungen erstellen

    • Erstellen Sie mehrere neue Beziehungen zwischen Entitäten mit erweiterten Eigenschaften

    • Eingabe: relations (Array von Objekten)

      • Jedes Objekt enthält:

        • from (Zeichenfolge): Name der Quell-Entität

        • to (Zeichenfolge): Name der Zielentität

        • relationType (Zeichenfolge): Beziehungstyp

        • strength (Zahl, optional): Beziehungsstärke (0,0-1,0)

        • confidence (Zahl, optional): Konfidenzniveau (0,0-1,0)

        • metadata (Objekt, optional): Benutzerdefinierte Metadatenfelder

  • get_relation

    • Erhalten Sie eine bestimmte Beziehung mit ihren erweiterten Eigenschaften

    • Eingang:

      • from (Zeichenfolge): Name der Quell-Entität

      • to (Zeichenfolge): Name der Zielentität

      • relationType (Zeichenfolge): Beziehungstyp

  • Update-Relation

    • Aktualisieren einer vorhandenen Beziehung mit erweiterten Eigenschaften

    • Eingabe: relation (Objekt):

      • Enthält:

        • from (Zeichenfolge): Name der Quell-Entität

        • to (Zeichenfolge): Name der Zielentität

        • relationType (Zeichenfolge): Beziehungstyp

        • strength (Zahl, optional): Beziehungsstärke (0,0-1,0)

        • confidence (Zahl, optional): Konfidenzniveau (0,0-1,0)

        • metadata (Objekt, optional): Benutzerdefinierte Metadatenfelder

  • delete_relations

    • Entfernen Sie bestimmte Beziehungen aus dem Diagramm

    • Eingabe: relations (Array von Objekten)

      • Jedes Objekt enthält:

        • from (Zeichenfolge): Name der Quell-Entität

        • to (Zeichenfolge): Name der Zielentität

        • relationType (Zeichenfolge): Beziehungstyp

Graphoperationen

  • Diagramm lesen

    • Lesen Sie den gesamten Wissensgraphen

    • Keine Eingabe erforderlich

  • Suchknoten

    • Suche nach Knoten basierend auf der Abfrage

    • Eingabe: query (Zeichenfolge)

  • offene_Knoten

    • Abrufen bestimmter Knoten nach Namen

    • Eingabe: names (Zeichenfolge[])

Semantische Suche

  • semantische_suche

    • Semantische Suche nach Entitäten mithilfe von Vektoreinbettungen und Ähnlichkeit

    • Eingang:

      • query (Zeichenfolge): Die Textabfrage, nach der semantisch gesucht werden soll

      • limit (Zahl, optional): Maximale Anzahl der zurückzugebenden Ergebnisse (Standard: 10)

      • min_similarity (Zahl, optional): Minimaler Ähnlichkeitsschwellenwert (0,0–1,0, Standard: 0,6)

      • entity_types (string[], optional): Ergebnisse nach Entitätstypen filtern

      • hybrid_search (boolesch, optional): Kombinieren Sie Schlüsselwort- und semantische Suche (Standard: true)

      • semantic_weight (Zahl, optional): Gewichtung der semantischen Ergebnisse bei der Hybridsuche (0,0–1,0, Standard: 0,6)

    • Merkmale:

      • Wählt intelligent die optimale Suchmethode (Vektor, Schlüsselwort oder Hybrid) basierend auf dem Abfragekontext aus

      • Behandelt Abfragen ohne semantische Übereinstimmungen mithilfe von Fallback-Mechanismen

      • Sorgt für eine hohe Leistung durch automatische Optimierungsentscheidungen

  • get_entity_embedding

    • Holen Sie sich die Vektoreinbettung für eine bestimmte Entität

    • Eingang:

      • entity_name (Zeichenfolge): Der Name der Entität, für die die Einbettung abgerufen werden soll

Zeitliche Merkmale

  • Entitätsverlauf abrufen

    • Vollständigen Versionsverlauf einer Entität abrufen

    • Eingabe: entityName (Zeichenfolge)

  • Beziehungsverlauf abrufen

    • Vollständigen Versionsverlauf einer Beziehung abrufen

    • Eingang:

      • from (Zeichenfolge): Name der Quell-Entität

      • to (Zeichenfolge): Name der Zielentität

      • relationType (Zeichenfolge): Beziehungstyp

  • get_graph_at_time

    • Holen Sie sich den Zustand des Graphen zu einem bestimmten Zeitstempel

    • Eingabe: timestamp (Zahl): Unix-Zeitstempel (Millisekunden seit Epoche)

  • get_decayed_graph

    • Erhalten Sie ein Diagramm mit zeitverzögerten Konfidenzwerten

    • Eingabe: options (Objekt, optional):

      • reference_time (Zahl): Referenzzeitstempel für die Zerfallsberechnung (Millisekunden seit Epoche)

      • decay_factor (Zahl): Optionale Überschreibung des Zerfallsfaktors

Konfiguration

Umgebungsvariablen

Konfigurieren Sie Memento MCP mit diesen Umgebungsvariablen:

# Neo4j Connection Settings
NEO4J_URI=bolt://127.0.0.1:7687
NEO4J_USERNAME=neo4j
NEO4J_PASSWORD=memento_password
NEO4J_DATABASE=neo4j

# Vector Search Configuration
NEO4J_VECTOR_INDEX=entity_embeddings
NEO4J_VECTOR_DIMENSIONS=1536
NEO4J_SIMILARITY_FUNCTION=cosine

# Embedding Service Configuration
MEMORY_STORAGE_TYPE=neo4j
OPENAI_API_KEY=your-openai-api-key
OPENAI_EMBEDDING_MODEL=text-embedding-3-small

# Debug Settings
DEBUG=true

Befehlszeilenoptionen

Die Neo4j CLI-Tools unterstützen die folgenden Optionen:

--uri <uri>              Neo4j server URI (default: bolt://127.0.0.1:7687)
--username <username>    Neo4j username (default: neo4j)
--password <password>    Neo4j password (default: memento_password)
--database <n>           Neo4j database name (default: neo4j)
--vector-index <n>       Vector index name (default: entity_embeddings)
--dimensions <number>    Vector dimensions (default: 1536)
--similarity <function>  Similarity function (cosine|euclidean) (default: cosine)
--recreate               Force recreation of constraints and indexes
--no-debug               Disable detailed output (debug is ON by default)

Einbettungsmodelle

Verfügbare OpenAI-Einbettungsmodelle:

  • text-embedding-3-small : Effizient, kostengünstig (1536 Dimensionen)

  • text-embedding-3-large : Höhere Genauigkeit, teurer (3072 Dimensionen)

  • text-embedding-ada-002 : Legacy-Modell (1536 Dimensionen)

OpenAI API-Konfiguration

Um die semantische Suche zu verwenden, müssen Sie die Anmeldeinformationen für die OpenAI-API konfigurieren:

  1. Erhalten Sie einen API-Schlüssel von OpenAI

  2. Konfigurieren Sie Ihre Umgebung mit:

# OpenAI API Key for embeddings
OPENAI_API_KEY=your-openai-api-key
# Default embedding model
OPENAI_EMBEDDING_MODEL=text-embedding-3-small

Hinweis : In Testumgebungen simuliert das System die Embedding-Generierung, wenn kein API-Schlüssel angegeben wird. Für Integrationstests wird jedoch die Verwendung echter Embeddings empfohlen.

Integration mit Claude Desktop

Konfiguration

Fügen Sie dies zu Ihrer claude_desktop_config.json hinzu:

{
  "mcpServers": {
    "memento": {
      "command": "npx",
      "args": ["-y", "@gannonh/memento-mcp"],
      "env": {
        "MEMORY_STORAGE_TYPE": "neo4j",
        "NEO4J_URI": "bolt://127.0.0.1:7687",
        "NEO4J_USERNAME": "neo4j",
        "NEO4J_PASSWORD": "memento_password",
        "NEO4J_DATABASE": "neo4j",
        "NEO4J_VECTOR_INDEX": "entity_embeddings",
        "NEO4J_VECTOR_DIMENSIONS": "1536",
        "NEO4J_SIMILARITY_FUNCTION": "cosine",
        "OPENAI_API_KEY": "your-openai-api-key",
        "OPENAI_EMBEDDING_MODEL": "text-embedding-3-small",
        "DEBUG": "true"
      }
    }
  }
}

Alternativ können Sie für die lokale Entwicklung Folgendes verwenden:

{
  "mcpServers": {
    "memento": {
      "command": "/path/to/node",
      "args": ["/path/to/memento-mcp/dist/index.js"],
      "env": {
        "MEMORY_STORAGE_TYPE": "neo4j",
        "NEO4J_URI": "bolt://127.0.0.1:7687",
        "NEO4J_USERNAME": "neo4j",
        "NEO4J_PASSWORD": "memento_password",
        "NEO4J_DATABASE": "neo4j",
        "NEO4J_VECTOR_INDEX": "entity_embeddings",
        "NEO4J_VECTOR_DIMENSIONS": "1536",
        "NEO4J_SIMILARITY_FUNCTION": "cosine",
        "OPENAI_API_KEY": "your-openai-api-key",
        "OPENAI_EMBEDDING_MODEL": "text-embedding-3-small",
        "DEBUG": "true"
      }
    }
  }
}

Wichtig : Geben Sie das Einbettungsmodell in Ihrer Claude Desktop-Konfiguration immer explizit an, um ein konsistentes Verhalten sicherzustellen.

Empfohlene Systemaufforderungen

Für eine optimale Integration mit Claude fügen Sie Ihrer Systemeingabeaufforderung diese Anweisungen hinzu:

You have access to the Memento MCP knowledge graph memory system, which provides you with persistent memory capabilities.
Your memory tools are provided by Memento MCP, a sophisticated knowledge graph implementation.
When asked about past conversations or user information, always check the Memento MCP knowledge graph first.
You should use semantic_search to find relevant information in your memory when answering questions.

Testen der semantischen Suche

Nach der Konfiguration kann Claude über natürliche Sprache auf die semantischen Suchfunktionen zugreifen:

  1. So erstellen Sie Entitäten mit semantischen Einbettungen:

    User: "Remember that Python is a high-level programming language known for its readability and JavaScript is primarily used for web development."

  2. So führen Sie eine semantische Suche durch:

    User: "What programming languages do you know about that are good for web development?"

  3. So rufen Sie bestimmte Informationen ab:

    User: "Tell me everything you know about Python."

Der Vorteil dieses Ansatzes liegt darin, dass die Benutzer auf natürliche Weise interagieren können, während das LLM die Komplexität der Auswahl und Verwendung der geeigneten Gedächtnistools übernimmt.

Anwendungen in der realen Welt

Die adaptiven Suchfunktionen von Memento bieten praktische Vorteile:

  1. Vielseitigkeit der Abfragen : Benutzer müssen sich keine Gedanken über die Formulierung von Fragen machen – das System passt sich automatisch an verschiedene Abfragetypen an

  2. Ausfallsicherheit : Selbst wenn keine semantischen Übereinstimmungen verfügbar sind, kann das System ohne Benutzereingriff auf alternative Methoden zurückgreifen

  3. Leistungseffizienz : Durch die intelligente Auswahl der optimalen Suchmethode gleicht das System Leistung und Relevanz für jede Abfrage aus

  4. Verbesserte Kontextsuche : LLM-Konversationen profitieren von einer besseren Kontextsuche, da das System relevante Informationen in komplexen Wissensgraphen finden kann

Wenn ein Nutzer beispielsweise fragt: „Was wissen Sie über maschinelles Lernen?“, kann das System konzeptionell verwandte Entitäten abrufen, auch wenn diese nicht explizit „maschinelles Lernen“ erwähnen – etwa Entitäten zu neuronalen Netzwerken, Data Science oder bestimmten Algorithmen. Sollte die semantische Suche jedoch nicht genügend Ergebnisse liefern, passt das System seinen Ansatz automatisch an, um sicherzustellen, dass dennoch nützliche Informationen zurückgegeben werden.

Fehlerbehebung

Vektorsuchdiagnose

Memento MCP verfügt über integrierte Diagnosefunktionen zur Behebung von Problemen bei der Vektorsuche:

  • Einbettungsüberprüfung : Das System prüft, ob Entitäten gültige Einbettungen haben und generiert diese automatisch, wenn sie fehlen

  • Vektorindexstatus : Überprüft, ob der Vektorindex vorhanden ist und sich im ONLINE-Status befindet

  • Fallback-Suche : Wenn die Vektorsuche fehlschlägt, greift das System auf die textbasierte Suche zurück

  • Detaillierte Protokollierung : Umfassende Protokollierung von Vektorsuchvorgängen zur Fehlerbehebung

Debug-Tools (wenn DEBUG=true)

Wenn der Debug-Modus aktiviert ist, stehen zusätzliche Diagnosetools zur Verfügung:

  • diagnose_vector_search : Informationen zum Neo4j-Vektorindex, Einbettungszählungen und Suchfunktion

  • force_generate_embedding : Erzwingt die Generierung einer Einbettung für eine bestimmte Entität

  • debug_embedding_config : Informationen zur aktuellen Konfiguration des Einbettungsdienstes

Entwickler-Reset

So setzen Sie Ihre Neo4j-Datenbank während der Entwicklung vollständig zurück:

# Stop the container (if using Docker)
docker-compose stop neo4j

# Remove the container (if using Docker)
docker-compose rm -f neo4j

# Delete the data directory (if using Docker)
rm -rf ./neo4j-data/*

# For Neo4j Desktop, right-click your database and select "Drop database"

# Restart the database
# For Docker:
docker-compose up -d neo4j

# For Neo4j Desktop:
# Click the "Start" button for your database

# Reinitialize the schema
npm run neo4j:init

Bau und Entwicklung

# Clone the repository
git clone https://github.com/gannonh/memento-mcp.git
cd memento-mcp

# Install dependencies
npm install

# Build the project
npm run build

# Run tests
npm test

# Check test coverage
npm run test:coverage

Installation

Installation über Smithery

So installieren Sie memento-mcp für Claude Desktop automatisch über Smithery :

npx -y @smithery/cli install @gannonh/memento-mcp --client claude

Globale Installation mit npx

Sie können Memento MCP direkt mit npx ausführen, ohne es global zu installieren:

npx -y @gannonh/memento-mcp

Diese Methode wird für die Verwendung mit Claude Desktop und anderen MCP-kompatiblen Clients empfohlen.

Lokale Installation

Zur Entwicklung oder Mitarbeit am Projekt:

# Install locally
npm install @gannonh/memento-mcp

# Or clone the repository
git clone https://github.com/gannonh/memento-mcp.git
cd memento-mcp
npm install

Lizenz

MIT

Install Server
A
security – no known vulnerabilities
A
license - permissive license
A
quality - confirmed to work

How are these scores calculated?

Resources

Tools

View all tools

Appeared in Searches

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/gannonh/memento-mcp'

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