LangChain Teil 4 – Arbeitsspeicher und Speicher in LangChain nutzen: Ein umfassender Leitfaden

Code finden Sie hier: GitHub – jamesbmour/blog_tutorials:

In der sich ständig weiterentwickelnden Welt der Konversations-KI und Sprachmodelle sind die Aufrechterhaltung des Kontexts und die effiziente Verwaltung des Informationsflusses entscheidende Komponenten bei der Entwicklung intelligenter Anwendungen. LangChain, ein leistungsstarkes Framework für die Arbeit mit großen Sprachmodellen (LLMs), bietet robuste Tools für die Speicherverwaltung und Datenpersistenz und ermöglicht die Erstellung kontextsensitiver Systeme.

In diesem Leitfaden befassen wir uns mit den Nuancen der Nutzung von Speicher und Speicher in LangChain, um intelligentere, reaktionsfähigere Anwendungen zu erstellen.

1. Arbeiten mit Speicher in LangChain

Die Speicherverwaltung in LangChain ermöglicht es Anwendungen, den Kontext beizubehalten, wodurch Interaktionen kohärenter und kontextbezogener relevant werden. Lassen Sie uns die verschiedenen Speichertypen und ihre Anwendungsfälle untersuchen.

1.1. Arten von Gedächtnis

LangChain bietet verschiedene Speichertypen, um verschiedene Szenarien zu bewältigen. Hier konzentrieren wir uns auf zwei Schlüsseltypen:

ConversationBufferMemory

Dieser Speichertyp ist ideal für die kurzfristige Kontextspeicherung sowie das Erfassen und Abrufen aktueller Interaktionen in einem Gespräch.

from langchain.memory import ConversationBufferMemory

memory = ConversationBufferMemory()
memory.save_context({"input": "Hi, I'm Alice"}, {"output": "Hello Alice, how can I help you today?"})
memory.save_context({"input": "What's the weather like?"}, {"output": "I'm sorry, I don't have real-time weather information. Is there anything else I can help you with?"})

print(memory.load_memory_variables({}))

ConversationSummaryMemory

Für längere Gespräche ist ConversationSummaryMemory eine gute Wahl. Es fasst die wichtigsten Punkte zusammen und behält den Kontext bei, ohne überwältigende Details.

from langchain.memory import ConversationSummaryMemory
from langchain.llms import Ollama 

llm = Ollama(model='phi3',temperature=0)
memory = ConversationSummaryMemory(llm=llm)
memory.save_context({"input": "Hi, I'm Alice"}, {"output": "Hello Alice, how can I help you today?"})
memory.save_context({"input": "I'm looking for a good Italian restaurant"}, {"output": "Great! I'd be happy to help you find a good Italian restaurant. Do you have any specific preferences or requirements, such as location, price range, or specific dishes you're interested in?"})

print(memory.load_memory_variables({}))

1.2. Auswahl des richtigen Speichertyps für Ihren Anwendungsfall

Die Auswahl des geeigneten Speichertyps hängt von mehreren Faktoren ab:

• Dauer und Komplexität: Kurze Sitzungen profitieren von der detaillierten Kontexterhaltung mit ConversationBufferMemory, während langfristige Interaktionen möglicherweise eine Zusammenfassung über ConversationSummaryMemory erfordern.
• Detail vs. Überblick: Bestimmen Sie, ob ein detaillierter Interaktionsverlauf oder allgemeine Zusammenfassungen für Ihre Anwendung wertvoller sind.
• Leistung: Berücksichtigen Sie die Kompromisse zwischen Speichergröße und Abrufgeschwindigkeit.

Anwendungsfälle:

• ConversationBufferMemory: Ideal für schnellen Kundensupport oder FAQ-ähnliche Interaktionen.
• ConversationSummaryMemory: Am besten geeignet für langfristige Engagements wie Projektmanagement oder laufende Kundeninteraktionen.

1.3. Speicher in Ketten und Agenten integrieren

Speicher kann nahtlos in LangChain-Ketten und -Agenten integriert werden, um die Konversationsfunktionen zu verbessern.

from langchain.chains import ConversationChain  
from langchain.memory import ConversationBufferMemory
# llm = OpenAI(temperature=0)
memory = ConversationBufferMemory()
conversation = ConversationChain(
    llm=llm,
    memory=memory,
    verbose=True
)

conversation.predict(input="Hi, I'm Alice")
conversation.predict(input="What's my name?")

Dieses Beispiel veranschaulicht, wie ConversationBufferMemory verwendet werden kann, um sich an frühere Interaktionen zu erinnern und so natürlichere Gespräche zu ermöglichen.

2. Speichern und Abrufen von Daten

Persistente Speicherung stellt sicher, dass Gesprächsverlauf und -kontext sitzungsübergreifend erhalten bleiben, was Kontinuität bei Interaktionen ermöglicht.

2.1. Speichern von Gesprächsverlauf und -status

Für eine grundlegende Persistenz können Sie dateibasierten Speicher mit JSON verwenden:

import json

class PersistentMemory:
    def __init__(self, file_path):
        self.file_path = file_path
        self.load_memory()

    def load_memory(self):
        try:
            with open(self.file_path, 'r') as f:
                self.chat_memory = json.load(f)
        except FileNotFoundError:
            self.chat_memory = {'messages': []}

    def save_memory(self):
        with open(self.file_path, 'w') as f:
            json.dump({'messages': self.chat_memory['messages']}, f)

# Usage
memory = PersistentMemory(file_path='conversation_history.json')
print(memory.chat_memory)

Mit dieser Methode können Sie den Konversationsverlauf in einem einfachen, für Menschen lesbaren Format beibehalten.

2.2. Integration mit Datenbanken und Speichersystemen

Für eine skalierbarere und effizientere Speicherung wird die Integration mit Datenbanken wie SQLite empfohlen:

import sqlite3

class SQLiteMemory:
    def __init__(self, db_path):
        self.db_path = db_path
        self.conn = sqlite3.connect(db_path)
        self.create_table()

    def create_table(self):
        cursor = self.conn.cursor()
        cursor.execute('''
            CREATE TABLE IF NOT EXISTS conversations
            (id INTEGER PRIMARY KEY, input TEXT, output TEXT)
        ''')
        self.conn.commit()

    def save_context(self, inputs, outputs):
        cursor = self.conn.cursor()
        cursor.execute('INSERT INTO conversations (input, output) VALUES (?, ?)',
                       (inputs['input'], outputs['output']))
        self.conn.commit()

    def load_memory_variables(self, inputs):
        cursor = self.conn.cursor()
        cursor.execute('SELECT input, output FROM conversations ORDER BY id DESC LIMIT 10')
        rows = cursor.fetchall()
        history = "\\n".join([f"Human: {row[0]}\\nAI: {row[1]}" for row in reversed(rows)])
        return {"history": history }

# Usage
memory = SQLiteMemory('conversation_history.db')

print(memory.load_memory_variables({}))

3 Speichernutzung und Leistung optimieren

Um sicherzustellen, dass Ihre Anwendung weiterhin reagiert, ziehen Sie die folgenden Optimierungsstrategien in Betracht:

• Effiziente Datenstrukturen: Verwenden Sie Strukturen wie deque für die Verwaltung von Puffern fester Größe.
• Caching-Strategien: Reduzieren Sie Datenbankabfragen durch die Implementierung von Caching für häufig aufgerufene Daten.
• Datenbereinigung: Bereinigen oder fassen Sie alte Daten regelmäßig zusammen, um eine überschaubare Speichergröße beizubehalten.

Hier ist ein Beispiel einer Speicherklasse mit grundlegendem Caching:

import time

class CachedSQLiteMemory(SQLiteMemory):
    def __init__(self, db_path, cache_ttl=60):
        super().__init__(db_path)
        self.cache = None
        self.cache_time = 0
        self.cache_ttl = cache_ttl

    def load_memory_variables(self, inputs):
        current_time = time.time()
        if self.cache is None or (current_time - self.cache_time) > self.cache_ttl:
            var = self.cache
            self.cache = super().load_memory_variables(inputs)
            self.cache_time = current_time
            return self.cache

memory = CachedSQLiteMemory('conversation_history.db', cache_ttl=30)

Diese Implementierung speichert die Ergebnisse von Datenbankabfragen für einen bestimmten Zeitraum zwischen, wodurch die Belastung der Datenbank verringert und die Leistung für Anwendungen verbessert wird, die häufig auf Speicherdaten zugreifen.

Abschluss

Eine effektive Speicherverwaltung ist ein Eckpfeiler beim Aufbau intelligenter, kontextbewusster Konversations-KI-Anwendungen. LangChain bietet ein flexibles und leistungsstarkes Framework für die Speicherverwaltung, das es Entwicklern ermöglicht, Speichertypen an bestimmte Anwendungsfälle anzupassen, persistente Speicherlösungen zu implementieren und die Leistung für große Anwendungen zu optimieren.

Durch die Auswahl des richtigen Speichertyps, die Integration von persistentem Speicher und die Nutzung fortschrittlicher Techniken wie benutzerdefinierter Speicherklassen und Caching-Strategien können Sie anspruchsvolle KI-Systeme erstellen, die den Kontext beibehalten, die Benutzererfahrung verbessern und trotz der Größe und Komplexität effizient arbeiten der Interaktionen wachsen.

Mit diesen Tools und Techniken sind Sie bestens gerüstet, um das volle Potenzial von LangChain bei der Erstellung reaktionsfähiger, intelligenter und kontextbezogener KI-Anwendungen auszuschöpfen. Ganz gleich, ob Sie Kundensupport-Bots, virtuelle Assistenten oder komplexe Konversationssysteme entwickeln, die Beherrschung von Speicher und Speicher in LangChain wird ein Schlüsselfaktor für Ihren Erfolg sein.

Wenn Sie mein Schreiben unterstützen oder mir ein Bier spendieren möchten:
https://buymeacoffee.com/bmours