Skip to main content
Glama
deenesjakoruzh
evangstav

Memory MCP Server

by evangstav
OverviewSchemaRelated ServersScoreDiscussions
Python
Hybrid

Memory MCP Server

Ein Model Context Protocol (MCP) Server, der Knowledge-Graph-Funktionalität zur Verwaltung von Entitäten, Beziehungen und Beobachtungen im Arbeitsspeicher bietet, mit strengen Validierungsregeln zur Wahrung der Datenkonsistenz.

Installation

Installieren Sie den Server in Claude Desktop:

mcp install main.py -v MEMORY_FILE_PATH=/path/to/memory.jsonl

Related MCP server: Qualitative Researcher MCP Server

Datenvalidierungsregeln

Entitätsnamen

  • Müssen mit einem Kleinbuchstaben beginnen

  • Können Kleinbuchstaben, Zahlen und Bindestriche enthalten

  • Maximale Länge von 100 Zeichen

  • Müssen innerhalb des Graphen eindeutig sein

  • Beispiel für gültige Namen: python-project, meeting-notes-2024, user-john

Entitätstypen

Die folgenden Entitätstypen werden unterstützt:

  • person: Menschliche Entitäten

  • concept: Abstrakte Ideen oder Prinzipien

  • project: Arbeitsinitiativen oder Aufgaben

  • document: Jede Form von Dokumentation

  • tool: Software-Tools oder Dienstprogramme

  • organization: Unternehmen oder Gruppen

  • location: Physische oder virtuelle Orte

  • event: Zeitlich begrenzte Ereignisse

Beobachtungen

  • Nicht leere Zeichenfolgen

  • Maximale Länge von 500 Zeichen

  • Müssen pro Entität eindeutig sein

  • Sollten sachliche und objektive Aussagen sein

  • Zeitstempel einfügen, wenn relevant

Beziehungen

Die folgenden Beziehungstypen werden unterstützt:

  • knows: Verbindung von Person zu Person

  • contains: Eltern-/Kind-Beziehung

  • uses: Entität nutzt eine andere Entität

  • created: Urheberschafts-/Erstellungsbeziehung

  • belongs-to: Mitgliedschaft/Eigentum

  • depends-on: Abhängigkeitsbeziehung

  • related-to: Generische Beziehung

Zusätzliche Beziehungsregeln:

  • Sowohl Quell- als auch Zielentitäten müssen existieren

  • Selbstbezügliche Beziehungen sind nicht erlaubt

  • Keine zirkulären Abhängigkeiten erlaubt

  • Müssen vordefinierte Beziehungstypen verwenden

Verwendung

Der Server bietet Tools zur Verwaltung eines Knowledge-Graphen:

Entität abrufen

result = await session.call_tool("get_entity", {
    "entity_name": "example"
})
if not result.success:
    if result.error_type == "NOT_FOUND":
        print(f"Entity not found: {result.error}")
    elif result.error_type == "VALIDATION_ERROR":
        print(f"Invalid input: {result.error}")
    else:
        print(f"Error: {result.error}")
else:
    entity = result.data
    print(f"Found entity: {entity}")

Graph abrufen

result = await session.call_tool("get_graph", {})
if result.success:
    graph = result.data
    print(f"Graph data: {graph}")
else:
    print(f"Error retrieving graph: {result.error}")

Entitäten erstellen

# Valid entity creation
entities = [
    Entity(
        name="python-project",  # Lowercase with hyphens
        entityType="project",   # Must be a valid type
        observations=["Started development on 2024-01-29"]
    ),
    Entity(
        name="john-doe",
        entityType="person",
        observations=["Software engineer", "Joined team in 2024"]
    )
]
result = await session.call_tool("create_entities", {
    "entities": entities
})
if not result.success:
    if result.error_type == "VALIDATION_ERROR":
        print(f"Invalid entity data: {result.error}")
    else:
        print(f"Error creating entities: {result.error}")

Beobachtung hinzufügen

# Valid observation
result = await session.call_tool("add_observation", {
    "entity": "python-project",
    "observation": "Completed initial prototype"  # Must be unique for entity
})
if not result.success:
    if result.error_type == "NOT_FOUND":
        print(f"Entity not found: {result.error}")
    elif result.error_type == "VALIDATION_ERROR":
        print(f"Invalid observation: {result.error}")
    else:
        print(f"Error adding observation: {result.error}")

Beziehung erstellen

# Valid relation
result = await session.call_tool("create_relation", {
    "from_entity": "john-doe",
    "to_entity": "python-project",
    "relation_type": "created"  # Must be a valid type
})
if not result.success:
    if result.error_type == "NOT_FOUND":
        print(f"Entity not found: {result.error}")
    elif result.error_type == "VALIDATION_ERROR":
        print(f"Invalid relation data: {result.error}")
    else:
        print(f"Error creating relation: {result.error}")

Speicher durchsuchen

result = await session.call_tool("search_memory", {
    "query": "most recent workout"  # Supports natural language queries
})
if result.success:
    if result.error_type == "NO_RESULTS":
        print(f"No results found: {result.error}")
    else:
        results = result.data
        print(f"Search results: {results}")
else:
    print(f"Error searching memory: {result.error}")

Die Suchfunktionalität unterstützt:

  • Zeitliche Abfragen (z. B. "aktuellste", "letzte", "neueste")

  • Aktivitätsabfragen (z. B. "Training", "Übung")

  • Allgemeine Entitätssuchen

  • Fuzzy-Matching mit 80% Ähnlichkeitsschwellenwert

  • Gewichtete Suche über:

    • Entitätsnamen (Gewichtung: 1.0)

    • Entitätstypen (Gewichtung: 0.8)

    • Beobachtungen (Gewichtung: 0.6)

Entitäten löschen

result = await session.call_tool("delete_entities", {
    "names": ["python-project", "john-doe"]
})
if not result.success:
    if result.error_type == "NOT_FOUND":
        print(f"Entity not found: {result.error}")
    else:
        print(f"Error deleting entities: {result.error}")

Beziehung löschen

result = await session.call_tool("delete_relation", {
    "from_entity": "john-doe",
    "to_entity": "python-project"
})
if not result.success:
    if result.error_type == "NOT_FOUND":
        print(f"Entity not found: {result.error}")
    else:
        print(f"Error deleting relation: {result.error}")

Speicher leeren

result = await session.call_tool("flush_memory", {})
if not result.success:
    print(f"Error flushing memory: {result.error}")

Fehlertypen

Der Server verwendet die folgenden Fehlertypen:

  • NOT_FOUND: Entität oder Ressource nicht gefunden

  • VALIDATION_ERROR: Ungültige Eingabedaten

  • INTERNAL_ERROR: Serverseitiger Fehler

  • ALREADY_EXISTS: Ressource existiert bereits

  • INVALID_RELATION: Ungültige Beziehung zwischen Entitäten

Antwortmodelle

Alle Tools geben typisierte Antworten unter Verwendung dieser Modelle zurück:

EntityResponse

class EntityResponse(BaseModel):
    success: bool
    data: Optional[Dict[str, Any]] = None
    error: Optional[str] = None
    error_type: Optional[str] = None

GraphResponse

class GraphResponse(BaseModel):
    success: bool
    data: Optional[Dict[str, Any]] = None
    error: Optional[str] = None
    error_type: Optional[str] = None

OperationResponse

class OperationResponse(BaseModel):
    success: bool
    error: Optional[str] = None
    error_type: Optional[str] = None

Entwicklung

Tests ausführen

pytest tests/

Neue Funktionen hinzufügen

  1. Aktualisieren Sie die Validierungsregeln in validation.py

  2. Fügen Sie Tests in tests/test_validation.py hinzu

  3. Implementieren Sie Änderungen in knowledge_graph_manager.py

This server cannot be installed

-
security - not tested
A
license - permissive license
-
quality - not tested

How are these scores calculated?

Resources

Unclaimed servers have limited discoverability.

Looking for Admin?

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

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/evangstav/python-memory-mcp-server'

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