AI Engineering Academy · Leçon

Conserver l’historique des conversations dans Redis et PostgreSQL

Leçon 4 sur 413 étapes

Conserver l’historique des conversations dans Redis et PostgreSQL est une leçon AI Engineering Academy gratuite sur CoddyKit. Ceci est la leçon 4 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage AI Engineering Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours AI Engineering Academy comprend 4 leçons au total.

Pourquoi conserver l'historique des conversations à l'extérieur ?

L'historique des conversations conservé en mémoire disparaît lorsque votre application redémarre ou s'étend à plusieurs instances. La persistance externe résout trois problèmes : l'historique survit aux plantages, plusieurs instances de serveur partagent le même historique et vous pouvez charger les sessions passées pour les utilisateurs qui reviennent. Redis et PostgreSQL sont les deux systèmes de stockage les plus populaires pour cela.

Interface d'historique des messages de conversation de LangChain

LangChain définit une interface BaseChatMessageHistory avec deux méthodes : add_message(message) et messages (propriété). Tout moteur de stockage qui implémente cette interface peut être utilisé comme mémoire pour n'importe quelle chaîne LangChain. Les implémentations Redis et PostgreSQL suivent toutes deux cette interface.

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])

Connecter l'historique Redis à une chaîne

Enveloppez votre chaîne avec RunnableWithMessageHistory et fournissez une fonction fabrique qui renvoie l'objet d'historique approprié pour chaque session. LangChain charge automatiquement l'historique avant chaque appel et enregistre les nouveaux messages après chaque réponse.

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'
)

Invoquer la chaîne avec un ID de session

Lorsque vous invoquez une chaîne enveloppée avec un historique de messages, transmettez l'ID de session dans le dictionnaire config, sous configurable. LangChain achemine automatiquement chaque appel vers le stockage d'historique approprié ; Alice et Bob disposent ainsi d'historiques de conversation totalement distincts.

# 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.'

Concevoir les clés Redis pour l'historique des conversations

Redis stocke les messages de chaque session sous forme de liste associée à une clé dérivée de l'ID de session. Utilisez un schéma de clés structuré tel que chat:<app>:<user_id>:<session_id> afin d'éviter les collisions entre applications et de permettre un parcours efficace par utilisateur. Définissez un TTL pour les anciennes clés de session afin d'empêcher la croissance illimitée du stockage.

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)

Concevoir la table d'historique des conversations PostgreSQL

Pour une persistance fondée sur SQL, créez une table contenant des colonnes pour l'ID de session, le rôle du message, le contenu et l'horodatage. PostgreSQL est idéal lorsque votre historique de conversations doit être interrogé, audité ou joint aux données des comptes utilisateurs. Le paquet langchain_postgres fournit une implémentation prête à l'emploi.

-- 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 dans LangChain

La classe PostgresChatMessageHistory du paquet langchain_postgres fonctionne comme la version Redis, mais stocke les messages dans votre base de données PostgreSQL. Transmettez une chaîne de connexion et un ID de session ; la classe gère automatiquement la création de la table et la sérialisation des messages.

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')

Charger les sessions précédentes pour les utilisateurs de retour

Lorsqu'un utilisateur revient dans votre application après l'avoir fermée, vous pouvez restaurer sa dernière session en chargeant l'historique depuis Redis ou PostgreSQL. Présentez-lui un résumé de l'endroit où il s'est arrêté, ou poursuivez la conversation sans interruption en injectant l'historique enregistré dans l'invite suivante.

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

Réduire l'historique dans la base de données

Les sessions de longue durée peuvent accumuler des milliers de messages. Mettez en œuvre une stratégie de réduction qui supprime les messages antérieurs à une limite ou qui ne conserve que les N derniers messages dans la base de données. La récupération reste ainsi rapide et les fenêtres de contexte ne débordent pas lors du chargement de l'historique.

# 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()

Choisir entre Redis et PostgreSQL

Les deux moteurs sont prêts pour la production, mais possèdent des atouts différents. Redis offre des lectures en moins d'une milliseconde, ce qui le rend idéal pour les conversations en temps réel où la latence est prioritaire. PostgreSQL offre la possibilité d'effectuer des requêtes SQL complètes, des transactions ACID et une intégration simple avec votre base de données utilisateurs existante pour l'analyse et l'audit. De nombreux systèmes de production utilisent Redis comme cache principal et PostgreSQL pour l'archivage durable.

Sécurité : isoler les historiques dans une application multi-tenant

Dans les applications multi-tenant, vous devez vous assurer que les utilisateurs ne peuvent pas accéder aux historiques des autres. Incluez toujours l'ID utilisateur dans la clé de session, vérifiez que l'ID de session appartient bien à l'utilisateur authentifié avant de charger l'historique, et n'exposez jamais les clés de session brutes dans les URL ou les cookies côté client.

Bonne clé : chat:app1:user:42:session:abc
Mauvaise clé : session:abc (devinable, sans portée utilisateur)

Vérification rapide

Testez votre compréhension de la persistance externe de l'historique des conversations.

Réponds-y dans la leçon interactive

Récapitulatif de la leçon

Dans cette leçon, vous avez appris que : RedisChatMessageHistory stocke l'historique des conversations dans Redis avec des clés propres à chaque session, PostgresChatMessageHistory permet un stockage durable interrogeable avec SQL et RunnableWithMessageHistory relie n'importe quel moteur à votre chaîne grâce à une fabrique utilisant session_id. Nous allons maintenant découvrir le framework ReAct pour créer des agents capables de raisonner et d'agir.

Gratuit pour commencer

Apprends Python avec un tuteur IA — gratuit

Écris et exécute du vrai code dans ton navigateur, obtiens de l'aide instantanée d'un tuteur IA disponible 24h/24, et reprends là où tu t'es arrêté sur le web ou dans l'app.

Cours: 30
Leçons: 120

Commencer gratuitement Voir le cours complet

Questions Fréquemment Posées

La leçon « Conserver l’historique des conversations dans Redis et PostgreSQL » est-elle gratuite ?

Oui — le texte complet de « Conserver l’historique des conversations dans Redis et PostgreSQL » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours AI Engineering Academy, passe à CoddyKit PRO. Le cours AI Engineering Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Conserver l’historique des conversations dans Redis et PostgreSQL » ?

Stockez l’historique des conversations en externe avec RedisChatMessageHistory et PostgresChatMessageHistory afin que la mémoire survive aux redémarrages de l’application et s’étende à plusieurs inst… Tu pratiques AI Engineering Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer AI Engineering Academy ?

Aucune expérience préalable n'est requise. AI Engineering Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 4 sur 4.

Combien de temps prend la leçon « Conserver l’historique des conversations dans Redis et PostgreSQL » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon AI Engineering Academy ?

Oui. Chaque leçon AI Engineering Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

Pourquoi les LLM sans état ont besoin d’une mémoire externe
Mémoire tampon et mémoire à fenêtre
Mémoire par résumé et troncature tenant compte des tokens
Conserver l’historique des conversations dans Redis et PostgreSQL

← Retour à AI Engineering Academy