AI Engineering Academy · Lektion

Chatverläufe in Redis und PostgreSQL speichern

Chatverläufe in Redis und PostgreSQL speichern ist eine kostenlose AI Engineering Academy-Lektion auf CoddyKit. Dies ist Lektion 4 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des AI Engineering Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der AI Engineering Academy-Kurs umfasst insgesamt 4 Lektionen.

Warum sollte der Chatverlauf extern persistiert werden?

Ein im Arbeitsspeicher gehaltener Gesprächsverlauf geht verloren, wenn Ihre Anwendung neu gestartet wird oder auf mehrere Instanzen skaliert. Externe Persistenz löst drei Probleme: Der Verlauf bleibt nach Abstürzen erhalten, mehrere Serverinstanzen können denselben Verlauf gemeinsam nutzen, und vergangene Sitzungen lassen sich für zurückkehrende Nutzer laden. Redis und PostgreSQL sind dafür die beiden beliebtesten Backends.

Schnittstelle für Chat-Nachrichtenverläufe in LangChain

LangChain definiert eine BaseChatMessageHistory-Schnittstelle mit zwei Methoden: add_message(message) und messages (Property). Jedes Speicher-Backend, das diese Schnittstelle implementiert, kann in jeder LangChain-Kette als Speicher eingesetzt werden. Sowohl die Redis- als auch die PostgreSQL-Implementierung folgt dieser Schnittstelle.

from langchain_community.chat_message_histories import RedisChatMessageHistory

# Each unique session_id gets its own history namespace
history = RedisChatMessageHistory(
    session_id='user:alice:session:42',
    url='redis://localhost:6379'
)

# Add messages
history.add_user_message('What is RAG?')
history.add_ai_message('RAG stands for Retrieval-Augmented Generation...')

# Retrieve stored messages
for msg in history.messages:
    print(msg.type, ':', msg.content[:50])

Redis-Verlauf mit einer Kette verbinden

Umschließen Sie Ihre Kette mit RunnableWithMessageHistory und stellen Sie eine Factory-Funktion bereit, die für jede Sitzung das passende Verlaufsobjekt zurückgibt. LangChain lädt den Verlauf automatisch vor jedem Aufruf und speichert neue Nachrichten nach jeder Antwort.

from langchain_core.runnables.history import RunnableWithMessageHistory
from langchain_community.chat_message_histories import RedisChatMessageHistory
from langchain_openai import ChatOpenAI
from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder

llm = ChatOpenAI(model='gpt-4o-mini')
prompt = ChatPromptTemplate.from_messages([
    ('system', 'You are a helpful assistant.'),
    MessagesPlaceholder(variable_name='history'),
    ('human', '{input}')
])

chain = prompt | llm

chain_with_history = RunnableWithMessageHistory(
    chain,
    lambda session_id: RedisChatMessageHistory(
        session_id=session_id,
        url='redis://localhost:6379'
    ),
    input_messages_key='input',
    history_messages_key='history'
)

Die Kette mit einer Sitzungs-ID aufrufen

Wenn Sie eine mit Nachrichtenverlauf umschlossene Kette aufrufen, übergeben Sie die Sitzungs-ID im config-Dictionary unter configurable. LangChain leitet jeden Aufruf automatisch an den richtigen Verlaufsspeicher weiter, sodass Alice und Bob vollständig getrennte Gesprächsverläufe haben.

# First turn for session alice-001
response = chain_with_history.invoke(
    {'input': 'My name is Alice.'},
    config={'configurable': {'session_id': 'alice-001'}}
)
print(response.content)

# Second turn — the chain remembers Alice's name from Redis
response = chain_with_history.invoke(
    {'input': 'What is my name?'},
    config={'configurable': {'session_id': 'alice-001'}}
)
print(response.content)  # Should say 'Your name is Alice.'

Redis-Schlüssel für Chatverläufe entwerfen

Redis speichert die Nachrichten jeder Sitzung als Liste unter einem aus der Sitzungs-ID abgeleiteten Schlüssel. Verwenden Sie ein strukturiertes Schlüsselschema wie chat:<app>:<user_id>:<session_id>, um Kollisionen zwischen Anwendungen zu vermeiden und effizientes Scannen nach Nutzer zu ermöglichen. Setzen Sie für alte Sitzungsschlüssel eine TTL, um ein ungebremstes Anwachsen des Speicherbedarfs zu verhindern.

import redis

r = redis.Redis.from_url('redis://localhost:6379')

# List all chat sessions for user alice
keys = r.keys('message_store:alice-*')
print('Active sessions:', len(keys))

# Set a 30-day TTL on a session to auto-expire old history
for key in keys:
    r.expire(key, 60 * 60 * 24 * 30)

Tabellenentwurf für Chatverläufe in PostgreSQL

Erstellen Sie für SQL-basierte Persistenz eine Tabelle mit Spalten für Sitzungs-ID, Nachrichtenrolle, Inhalt und Zeitstempel. PostgreSQL eignet sich besonders, wenn Ihr Chatverlauf abgefragt, auditiert oder mit Daten aus Benutzerkonten verknüpft werden soll. Das Paket langchain_postgres stellt eine fertige Implementierung bereit.

-- SQL table for storing chat messages
CREATE TABLE chat_messages (
    id          SERIAL PRIMARY KEY,
    session_id  TEXT NOT NULL,
    role        TEXT NOT NULL,   -- 'human' or 'ai'
    content     TEXT NOT NULL,
    created_at  TIMESTAMPTZ DEFAULT NOW()
);

CREATE INDEX idx_chat_session ON chat_messages (session_id, created_at);

PostgresChatMessageHistory in LangChain

Die Klasse PostgresChatMessageHistory aus langchain_postgres funktioniert genauso wie die Redis-Variante, speichert Nachrichten jedoch in Ihrer PostgreSQL-Datenbank. Übergeben Sie eine Verbindungszeichenfolge und eine Sitzungs-ID; die Erstellung der Tabelle und die Serialisierung der Nachrichten werden automatisch übernommen.

from langchain_postgres import PostgresChatMessageHistory
import psycopg

CONNECTION_STRING = 'postgresql://user:pass@localhost:5432/mydb'

# Create history object for a session
history = PostgresChatMessageHistory(
    table_name='chat_messages',
    session_id='alice-001',
    connection=psycopg.connect(CONNECTION_STRING)
)

history.add_user_message('Tell me about embeddings.')
history.add_ai_message('Embeddings are dense vector representations...')

print(f'Stored {len(history.messages)} messages')

Vorherige Sitzungen für zurückkehrende Nutzer laden

Wenn ein Nutzer nach dem Schließen Ihrer App zurückkehrt, können Sie seine letzte Sitzung wiederherstellen, indem Sie den Verlauf aus Redis oder PostgreSQL laden. Zeigen Sie dem Nutzer eine Zusammenfassung des bisherigen Stands oder setzen Sie die Unterhaltung nahtlos fort, indem Sie den gespeicherten Verlauf in den nächsten Prompt einfügen.

def get_or_create_history(user_id: str, session_id: str):
    history = RedisChatMessageHistory(
        session_id=f'{user_id}:{session_id}',
        url='redis://localhost:6379'
    )
    if history.messages:
        print(f'Resuming session with {len(history.messages)} messages.')
    else:
        print('Starting a new session.')
    return history

Verlauf in der Datenbank kürzen

In lang laufenden Sitzungen können sich Tausende von Nachrichten ansammeln. Implementieren Sie eine Strategie zum Kürzen, die Nachrichten vor einem Stichtag löscht oder nur die letzten N Nachrichten in der Datenbank behält. Dadurch bleibt der Abruf schnell und es wird verhindert, dass Kontextfenster überlaufen, wenn Sie den Verlauf laden.

# Keep only the last 20 messages per session in PostgreSQL
CLEAN_SQL = '''
    DELETE FROM chat_messages
    WHERE session_id = %s
    AND id NOT IN (
        SELECT id FROM chat_messages
        WHERE session_id = %s
        ORDER BY created_at DESC
        LIMIT 20
    )
'''

def trim_session(conn, session_id: str, keep_last: int = 20):
    with conn.cursor() as cur:
        cur.execute(CLEAN_SQL, (session_id, session_id))
    conn.commit()

Zwischen Redis und PostgreSQL wählen

Beide Backends sind für den Produktionseinsatz geeignet, haben aber unterschiedliche Stärken. Redis bietet Lesezugriffe im Sub-Millisekundenbereich und eignet sich daher ideal für Echtzeit-Chats, bei denen die Latenz entscheidend ist. PostgreSQL bietet vollständige SQL-Abfragemöglichkeiten, ACID-Transaktionen und eine einfache Integration in Ihre bestehende Benutzerdatenbank für Analysen und Audits. Viele Produktionssysteme verwenden Redis als primären Cache und PostgreSQL für die dauerhafte Archivierung.

Sicherheit: Verläufe in Multi-Tenant-Systemen isolieren

In Multi-Tenant-Anwendungen müssen Sie sicherstellen, dass Nutzer nicht auf die Verläufe anderer Nutzer zugreifen können. Nehmen Sie immer die Benutzer-ID in den Sitzungsschlüssel auf, überprüfen Sie vor dem Laden des Verlaufs, ob die Sitzungs-ID zum authentifizierten Nutzer gehört, und geben Sie niemals rohe Sitzungsschlüssel in clientseitigen URLs oder Cookies preis.

Guter Schlüssel: chat:app1:user:42:session:abc
Schlechter Schlüssel: session:abc (erratbar, ohne Benutzerbereich)

Kurze Überprüfung

Testen Sie Ihr Verständnis der externen Persistierung von Chatverläufen.

Zusammenfassung der Lektion

In dieser Lektion haben Sie gelernt: RedisChatMessageHistory speichert Chatverläufe in Redis mit sitzungsspezifischen Schlüsseln, PostgresChatMessageHistory ermöglicht eine dauerhaft gespeicherte, per SQL abfragbare Datenhaltung und RunnableWithMessageHistory bindet jedes Backend über eine session_id-Factory an Ihre Kette an. Als Nächstes beschäftigen Sie sich mit dem ReAct-Framework zum Erstellen von Agenten, die schlussfolgern und handeln können.

Häufig gestellte Fragen

Ist die Lektion „Chatverläufe in Redis und PostgreSQL speichern“ kostenlos?

Ja — der vollständige Text von „Chatverläufe in Redis und PostgreSQL speichern“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des AI Engineering Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der AI Engineering Academy-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „Chatverläufe in Redis und PostgreSQL speichern“?

Sie speichern den Gesprächsverlauf mit RedisChatMessageHistory und PostgresChatMessageHistory extern, sodass der Speicher nach Neustarts der Anwendung erhalten bleibt und über mehrere Instanzen skali… Du übst AI Engineering Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um AI Engineering Academy zu starten?

Keine Vorkenntnisse erforderlich. AI Engineering Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 4 von 4.

Wie lange dauert die Lektion „Chatverläufe in Redis und PostgreSQL speichern“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser AI Engineering Academy-Lektion Code schreiben und ausführen?

Ja. Jede AI Engineering Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

Warum zustandslose LLMs externen Speicher benötigen
Puffer- und Fensterspeicher
Zusammenfassungsspeicher und tokenbewusstes Kürzen
Chatverläufe in Redis und PostgreSQL speichern

← Zurück zu AI Engineering Academy