Wie verbindet man Mem0 mit Ollama, um einen lokalen Speicher zu erstellen?

Sprachmodelle speichern nicht automatisch, was in früheren Konversationen geschehen ist. Wenn Sie eine Anwendung schließen, die Sitzung wechseln oder alte Nachrichten aus dem Kontextfenster löschen, verliert das Modell diese Informationen.

Eine Möglichkeit, diese Einschränkung zu überwinden, besteht darin, Verbinde Memo mit OllamaOllama führt das generative Modell und das Einbettungsmodell lokal aus, während Mem0 nützliche Informationen aus Konversationen extrahiert, diese organisiert und es ermöglicht, sie wieder abzurufen, wenn sie erneut relevant werden.

Anstatt stets den gesamten Verlauf an das Modell zu senden, kann die Anwendung einige wenige, mit der aktuellen Anfrage zusammenhängende Erinnerungen abrufen und in die Eingabeaufforderung einfügen. Dadurch wird der Kontextumfang reduziert und Präferenzen, Ziele oder wichtige Fakten können sitzungsübergreifend beibehalten werden.

Die Installation kann vollständig innerhalb Ihrer Infrastruktur funktionieren, wenn Sie Ollama, Mem0 OSS und eine lokale Datenbank verwenden. Der Datenschutz hängt jedoch von allen verbundenen Komponenten ab. Wenn Sie ein externes Modell, einen Reranker, eine Datenbank oder einen Managed Service hinzufügen, können Daten Ihr System verlassen.

Was bewirkt Mem0 und welche Funktion erfüllt Ollama?

Mem0 und Ollama lösen unterschiedliche Probleme. Ollama ist für den Betrieb der Modelle verantwortlich.Mem0 stellt die notwendigen Operationen zum Hinzufügen, Suchen, Abfragen, Aktualisieren und Löschen von Speichern bereit.

Beim Speichern kann Mem0 eine Konversation analysieren und Fakten extrahieren, die später nützlich sein könnten. Zum Beispiel:

• Der Nutzer bevorzugt kurze Antworten.
• Er entwickelt eine Anwendung in Rust.
• Er möchte keine Horrorfilmempfehlungen.
• Ihr Ziel ist es, ein Rennen in unter vier Stunden zu absolvieren.

Mem0 wandelt jede Erinnerung mithilfe des Einbettungsmodells in eine numerische Repräsentation um und speichert diese zusammen mit Inhalt und Metadaten. Bei einer Suche kombiniert es die Anfrage mit Filtern wie der Benutzerkennung und gibt die relevantesten Erinnerungen zurück.

Aktuelle Versionen von Mem0 verwenden primär additive Extraktion. Das bedeutet, dass neue Informationen gespeichert werden können, ohne dass vorherige Daten automatisch gelöscht werden. Sollten Daten veraltet sein und korrigiert werden müssen, kann die Anwendung die entsprechenden Operationen explizit ausführen. update() o delete().

Mem0 ersetzt nicht das Konversationsmodell. Die Anwendung muss die Erinnerungen abrufen, sie in die Systemnachricht oder den Kontext einbinden und Ollama auffordern, die Antwort zu generieren.

Komponenten, die zum Verbinden von Mem0 mit Ollama benötigt werden

Zum Aufbau eines lokalen Systems benötigen Sie folgende Komponenten:

• Memo OSS: Verwaltet das Extrahieren, Speichern und Abrufen von Erinnerungen.
• Ollama: Es führt das generative Modell und das Einbettungsmodell aus.
• Ein Sprachmodell: Es interpretiert die Gespräche und generiert die Antworten.
• Ein Einbettungsmodell: wandelt Erinnerungen und Abfragen in Vektoren um.
• Ein Vektorlager: Es erhält die Vektoren und ermöglicht die Suche nach verwandten Erinnerungen.
• Eine Bewerbung: Es verbindet Konversation, Abruf und Speicherung von Erinnerungen.

Qdrant und Chroma sind zwei gängige Speicheroptionen:

Speichern	Empfohlene Verwendung
Qdrant	Persistente Dienste, mehrere Anwendungen und Bereitstellungen mit Docker
Chroma	Lokale Tests und kleine Anwendungen mit Ordnerspeicherung

Qdrant bietet eine separate API und ermöglicht so eine einfache Trennung der Vektordatenbank von der Anwendung. Chroma kann eine lokale Route verwenden, was erste Tests vereinfacht.

Wie installiert man Mem0, Ollama und Qdrant?

Installieren Sie zunächst Ollama und überprüfen Sie, ob der Dienst ausgeführt wird. Laden Sie anschließend ein Sprachmodell und ein Einbettungsmodell herunter:

ollama pull llama3.1:latest
ollama pull nomic-embed-text:latest

llama3.1:latest Dies ist das Modell, das im offiziellen Mem0-Beispiel verwendet wird. Sie können es jedoch durch ein anderes, mit Ollama kompatibles Modell ersetzen. Kleinere Modelle benötigen weniger Speicher, extrahieren Daten aber möglicherweise weniger genau oder halten sich weniger gut an das erwartete Format.

Installieren Sie die Python-Abhängigkeiten:

pip install mem0ai qdrant-client openai ollama

Um Qdrant in Docker auszuführen und Daten mithilfe eines Volumes zu sichern, verwenden Sie Folgendes:

docker volume create qdrant_storage

docker run -d \
  --name qdrant \
  -p 6333:6333 \
  -p 6334:6334 \
  -v qdrant_storage:/qdrant/storage \
  qdrant/qdrant

Der Hafen 6333 stellt die HTTP-API und die 6334 Es wird für gRPC verwendet. In diesem Beispiel stellt Mem0 die Verbindung über die HTTP-API her.

Prüfen Sie, ob Ollama antwortet:

curl http://localhost:11434/api/tags

Sie können Qdrant überprüfen, indem Sie Folgendes öffnen:

http://localhost:6333/dashboard

Diese Ports dürfen nicht direkt mit dem Internet verbunden werden. Falls die Dienste auf verschiedenen Computern laufen, verwenden Sie ein privates Netzwerk, ein VPN oder Firewall-Regeln, die nur die notwendigen Verbindungen zulassen.

Lokale Konfiguration von Mem0 mit Ollama und Qdrant

Die Konfiguration muss explizit angeben, dass Ollama als LLM und als Einbettungsanbieter verwendet wird. Außerdem muss sie definieren, wo sich Qdrant befindet und welche Dimensionen die Einbettungen erzeugen.

from mem0 import Memory

OLLAMA_URL = "http://localhost:11434"
CHAT_MODEL = "llama3.1:latest"
EMBEDDING_MODEL = "nomic-embed-text:latest"

config = {
    "vector_store": {
        "provider": "qdrant",
        "config": {
            "collection_name": "memoria_agente",
            "host": "localhost",
            "port": 6333,
            "embedding_model_dims": 768,
        },
    },
    "llm": {
        "provider": "ollama",
        "config": {
            "model": CHAT_MODEL,
            "temperature": 0,
            "max_tokens": 2000,
            "ollama_base_url": OLLAMA_URL,
        },
    },
    "embedder": {
        "provider": "ollama",
        "config": {
            "model": EMBEDDING_MODEL,
            "ollama_base_url": OLLAMA_URL,
        },
    },
    "history_db_path": "./mem0_history.db",
    "custom_instructions": """
    Extrae únicamente información que pueda ser útil en conversaciones futuras:
    - Preferencias estables
    - Objetivos y proyectos
    - Restricciones importantes
    - Decisiones confirmadas

    Ignora saludos, conversación casual y hechos temporales sin importancia.
    Devuelve un objeto JSON con la clave facts y una lista de recuerdos.
    """,
}

memory = Memory.from_config(config)

Memory.from_config() Es zwingt Mem0 zur Verwendung der angegebenen Provider. Der Konstruktor Memory() Es stellt keine automatische Verbindung zu Mem0 Cloud her, kann aber standardmäßige OpenAI-basierte Komponenten anwenden und einen Schlüssel anfordern, wenn Sie diese nicht ersetzen.

custom_instructions Es ermöglicht Ihnen festzulegen, welche Informationen gespeichert werden sollen. Es muss als Eigenschaft der obersten Ebene vor dem Erstellen der Instanz angegeben werden. Memory.

Warum die Einbettungsdimensionen übereinstimmen müssen

Das Modell nomic-embed-text erzeugt Vektoren von 768 AbmessungenDaher wird die Qdrant-Collection wie folgt konfiguriert:

embedding_model_dims=768

Wenn der Speicher Vektoren einer anderen Größe erwartet, wird Qdrant die Daten ablehnen und Mem0 kann die Speicher nicht korrekt speichern oder abfragen.

Wenn Sie Ihr Einbettungsmodell ändern, überprüfen Sie dessen Dimensionen, bevor Sie die Einstellungen anpassen. Gegebenenfalls müssen Sie auch eine neue Sammlung erstellen und alle vorhandenen Vektoren neu generieren.

Mischen Sie keine Einbettungen, die von verschiedenen Modellen innerhalb derselben Sammlung erzeugt wurden. Selbst wenn zwei Modelle Vektoren mit identischen Dimensionen generieren, sind ihre semantischen Räume möglicherweise nicht kompatibel.

Wie man Erinnerungen speichert und wiederfindet

Um eine Konversation zu speichern, übergeben Sie eine Liste der Nachrichten an memory.add() und stellt eine stabile Kennung für den Benutzer dar:

mensajes = [
    {
        "role": "user",
        "content": "Estoy desarrollando una aplicación en Rust"
    },
    {
        "role": "assistant",
        "content": "Lo recordaré para adaptar los próximos ejemplos"
    }
]

resultado = memory.add(
    mensajes,
    user_id="usuario_001"
)

print(resultado)

Mit infer=TrueStandardmäßig verwendet Mem0 das Modell, um strukturierte Speicher zu extrahieren. Wenn Sie den Inhalt beibehalten möchten, ohne diese Extraktion anzuwenden, können Sie Folgendes verwenden: infer=False.

Um verwandte Informationen zu finden:

recuerdos = memory.search(
    "¿Qué lenguaje utiliza en su proyecto?",
    filters={"user_id": "usuario_001"},
    top_k=5
)

for recuerdo in recuerdos["results"]:
    print(recuerdo["memory"])

Der Filter nach user_id Das ist von entscheidender Bedeutung. Wenn eine Anwendung, die von mehreren Personen genutzt wird, eine Suche durchführt, ohne den Identifikator korrekt anzuwenden, könnte sie Erinnerungen abrufen, die einem anderen Benutzer gehören.

Sie können auch verwenden agent_id um die Erinnerungen verschiedener Agenten zu trennen und run_id um Gespräche, Projekte oder bestimmte Prozesse zu unterteilen.

Wie man einen vollständigen Chat mit Ollama und Mem0 erstellt

Damit Ollama die Speicher nutzen kann, muss die Anwendung vier Schritte ausführen:

1. Die Frage des Nutzers empfangen.
2. Suche nach verwandten Erinnerungen mit Mem0.
3. Füge sie dem an Ollama gesendeten Kontext hinzu.
4. Frage und Antwort als neue Interaktion speichern.

Ollama bietet eine mit dem OpenAI-Format kompatible API. Wir können sie verwenden, um die vollständige Schleife zu erstellen:

from openai import OpenAI

ollama_chat = OpenAI(
    base_url=f"{OLLAMA_URL}/v1",
    api_key="ollama"
)

def chat(mensaje_usuario, user_id):
    resultado = memory.search(
        mensaje_usuario,
        filters={"user_id": user_id},
        top_k=5
    )

    recuerdos = [
        item["memory"]
        for item in resultado["results"]
    ]

    contexto = "\n".join(
        f"- {recuerdo}" for recuerdo in recuerdos
    )

    respuesta = ollama_chat.chat.completions.create(
        model=CHAT_MODEL,
        messages=[
            {
                "role": "system",
                "content": (
                    "Eres un asistente útil. Utiliza los recuerdos "
                    "solo cuando sean relevantes.\n\n"
                    f"Recuerdos del usuario:\n{contexto}"
                ),
            },
            {
                "role": "user",
                "content": mensaje_usuario,
            },
        ],
    ).choices[0].message.content

    memory.add(
        [
            {
                "role": "user",
                "content": mensaje_usuario,
            },
            {
                "role": "assistant",
                "content": respuesta,
            },
        ],
        user_id=user_id,
    )

    return respuesta

Sie können jetzt ein Gespräch beginnen:

print(
    chat(
        "Estoy creando un programa de escritorio en Rust",
        user_id="usuario_001"
    )
)

Nach dem Neustart der Anwendung könnte derselbe Benutzer fragen:

print(
    chat(
        "¿Qué lenguaje estoy utilizando en mi proyecto?",
        user_id="usuario_001"
    )
)

Wenn die Speicherung korrekt war, ruft Mem0 die Informationen ab und Ollama kann sie zur Antwort nutzen.

Wie man Chroma anstelle von Qdrant verwendet

Für einen kleinen lokalen Test können Sie Qdrant durch Chroma ersetzen. Der korrekte Providername auf Mem0 lautet: chroma:

"vector_store": {
    "provider": "chroma",
    "config": {
        "collection_name": "memoria_agente",
        "path": "./chroma_db",
    },
}

Der angegebene Ordner path Diese Datei enthält die permanenten Daten von Chroma. Sie muss in Ihre Backups einbezogen werden und darf beim Aktualisieren der Anwendung nicht gelöscht werden.

Das vom Projekt verwendete Python-Paket heißt weiterhin chromadbDer Bezeichner, den Sie in der Mem0-Konfiguration angeben müssen, lautet: chroma.

Wie man veraltete Erinnerungen korrigiert oder löscht

Das Gedächtnis eines Assistenten sollte nicht als unfehlbare Quelle betrachtet werden. Das Modell kann eine falsch interpretierte Tatsache speichern, Informationen behalten, die nicht mehr gültig sind, oder mehrere ähnliche Erinnerungen generieren.

Sie können alle mit einem Benutzer verknüpften Erinnerungen anzeigen:

resultado = memory.get_all(
    filters={"user_id": "usuario_001"}
)

for recuerdo in resultado["results"]:
    print(recuerdo["id"], recuerdo["memory"])

Um eine bestimmte Erinnerung zu korrigieren:

memory.update(
    memory_id="ID_DEL_RECUERDO",
    data="El usuario está desarrollando una aplicación en Python"
)

Um es zu entfernen:

memory.delete(
    memory_id="ID_DEL_RECUERDO"
)

Eine für Endbenutzer bestimmte Anwendung sollte Steuerelemente zum Anzeigen, Korrigieren und Löschen gespeicherter Daten bieten. Es empfiehlt sich außerdem, eine Ablaufrichtlinie für temporäre Informationen festzulegen.

Wie man die Qualität des Gedächtnisses verbessern kann

Die Qualität hängt vom Modell, den Anweisungen, dem Gesprächsverlauf und der Menge der gesendeten Informationen ab. Die Verwendung eines größeren Modells garantiert nicht immer bessere Ergebnisse, obwohl sehr kleine Modelle Nuancen übersehen oder falsche Formate zurückgeben können.

Diese Übungen helfen, das Gedächtnis zu verbessern:

• Durch die Anwendung einer niedrigen Temperatur wird die Extraktion stabiler.
• Definieren Sie klar, welche Kategorien es wert sind, erinnert zu werden.
• Begrüßungen, Wiederholungen und irrelevante Gespräche sind nicht gestattet.
• Speichern Sie sowohl die Nachricht des Benutzers als auch die Antwort des Agenten.
• Verwenden Sie unterschiedliche Kennungen für Benutzer, Agenten und Projekte.
• Begrenzen Sie die Anzahl der abgerufenen Erinnerungen, um den Kontext nicht zu überfrachten.
• Überprüfen Sie regelmäßig fehlerhafte, doppelte oder veraltete Erinnerungen.
• Testen Sie die Suchvorgänge mit echten Suchanfragen, bevor Sie sie in Produktion nehmen.

Erinnerungen sollten nicht als Befehle mit höchster Priorität behandelt werden. Sie sind vielmehr Kontextinformationen, die unvollständig oder veraltet sein können. Dadurch wird das Risiko verringert, dass eine manipulierte Erinnerung das Gesamtverhalten des Agenten beeinflusst.

Leistungsoptimierung

Jeder Anruf an memory.add() Das Modell kann ausgeführt werden, um die zu speichernden Fakten zu extrahieren. Daher erhöht die Speichereinsparung die Latenz und den Ressourcenverbrauch.

In kleinen Anwendungen kann der Gesprächsverlauf nach der Antwortgenerierung gespeichert werden. Bei Diensten mit mehreren gleichzeitigen Anfragen ist es vorzuziehen, … AsyncMemoryein Hintergrundprozess oder eine Aufgabenwarteschlange.

Mem0 bietet eine asynchrone Schnittstelle, um zu vermeiden, dass Anwendungen blockiert werden, die mit asyncio oder FastAPI:

from mem0 import AsyncMemory

memory = AsyncMemory.from_config(config)

resultado = await memory.search(
    "proyecto actual",
    filters={"user_id": "usuario_001"},
    top_k=5
)

await memory.add(
    mensajes,
    user_id="usuario_001"
)

Übergeben Sie den Auftrag nicht an einen sekundären Thread, ohne dessen Ausnahmen zu behandeln. Wenn das Programm vor Abschluss des Speichervorgangs beendet wird, kann die Konversation verloren gehen. Eine persistente Warteschlange ermöglicht die Wiederholung fehlgeschlagener Operationen.

Sie können auch unterschiedliche Modelle für Konversation und Datenextraktion verwenden. Ein leistungsfähigeres generatives Modell kann die Antworten verarbeiten, während ein kleineres Modell die Speicherung übernimmt. Überprüfen Sie vorher, ob das zweite Modell die Anweisungen korrekt befolgt und das erforderliche Format einhält.

Häufige Fehler beim Verbinden von Mem0 mit Ollama

Mem0 fordert einen OpenAI-Schlüssel an

Die Konfiguration ist unvollständig, und einige Komponenten verwenden noch ihren Standardanbieter. Bitte überprüfen Sie, ob Sie beides konfiguriert haben. llm als embedder mit dem Lieferanten ollama.

Verbindung zu Ollama nicht möglich

Überprüfen Sie, ob die API antwortet:

curl http://localhost:11434/api/tags

Wenn Mem0 innerhalb von Docker ausgeführt wird, localhost Dies bezieht sich auf den Container, nicht auf den Host-Computer. In Docker Desktop müssen Sie möglicherweise Folgendes verwenden:

http://host.docker.internal:11434

Qdrant weist Vektoren zurück

Die Sammlung und das Einbettungsmodell verwenden unterschiedliche Dimensionen. nomic-embed-text, konfiguriert 768 Dimensionen und erstellt eine neue Sammlung, falls die bestehende Sammlung mit einer anderen Größe generiert wurde.

Die Suche liefert keine Erinnerungen

Prüfen Sie, ob Sie dasselbe verwenden. user_id Überprüfen Sie während des Speicherns und Suchens auch den Namen des Einbettungsmodells, die Filter und den Inhalt. resultado["results"].

Mem0 speichert irrelevante Informationen

Ente custom_instructionsEs senkt die Temperatur und legt fest, welche Kategorien ein- oder ausgeschlossen werden sollen. Prüfen Sie außerdem, ob das gewählte Modell strukturierte Anweisungen befolgen kann.

Erinnerungen widersprechen neueren Informationen

Aktuelle Versionen können frühere Daten beibehalten, anstatt sie automatisch zu überschreiben. Fügen Sie Datumsangaben oder Metadaten hinzu und verwenden Sie diese Funktion. update() o delete() wenn Sie Informationen korrigieren müssen.

Der Speicher geht verloren, wenn Qdrant ersetzt wird.

Überprüfen Sie, ob der Container ein eingebundenes Volume verwendet. /qdrant/storageDas Neustarten eines Containers ist nicht dasselbe wie dessen Löschung, aber die Neuerstellung ohne persistenten Speicher kann dazu führen, dass Daten in der neuen Bereitstellung fehlen.

Datenschutz und Datensicherung

Eine lokale Installation vermeidet die zwingende Abhängigkeit von verwalteten APIs von Mem0, OpenAI oder anderen Anbietern. Dennoch sollten Sie die Infrastruktur genauso schützen wie jede andere Anwendung, die personenbezogene Daten speichert.

• Ollama oder Qdrant dürfen nicht direkt mit dem Internet in Kontakt gebracht werden.
• Verschlüsseln Sie Festplatten und Sicherungskopien, wenn diese private Daten enthalten.
• Wenden Sie Authentifizierungs- und Zugriffskontrollen auf die Anwendung an.
• Speicherbereiche mithilfe zuverlässiger Benutzeridentifikatoren trennen.
• Es ermöglicht Ihnen, gespeicherte Informationen anzuzeigen und zu löschen.
• Bewahren Sie Passwörter, API-Schlüssel oder Bankdaten nicht als Erinnerungsstücke auf.
• Es zeichnet Fehler auf, ohne vollständige Gespräche oder Erinnerungen zu erfassen.
• Prüfen Sie, ob die Datenverarbeitung den Bestimmungen der DSGVO entsprechen muss.

Bei Qdrant müssen Sie das Volume sichern. qdrant_storage und die Datei, die definiert ist durch history_db_pathBei Chroma müssen Sie den konfigurierten Ordner kopieren nach path und die Verlaufsdatenbank.

Durch die Verbindung von Mem0 mit Ollama lässt sich ein Assistent erstellen, der Informationen zwischen Sitzungen speichert, ohne zwingend auf externe Dienste angewiesen zu sein. Ollama führt die Modelle aus, Mem0 extrahiert und ruft die gespeicherten Daten ab, und Qdrant oder Chroma stellen die dauerhafte Speicherung bereit.

Entscheidend ist nicht nur das Speichern von Konversationen. Die Anwendung muss relevante Informationen abrufen, Kontext bereitstellen, ihren Umfang mithilfe von Kennungen einschränken und Mechanismen zum Korrigieren oder Löschen von Informationen bieten. Mit diesen Vorkehrungen lässt sich ein nützlicher, persistenter und kontrollierbarer lokaler Speicher aufbauen.