AI Engineering Academy · leksjon

Lagre chathistorikk i Redis og PostgreSQL

Lagre samtalehistorikk eksternt ved hjelp av RedisChatMessageHistory og PostgresChatMessageHistory, slik at minnet overlever omstarter av applikasjonen og kan skaleres på tvers av flere instanser.

Leksjon 4 av 413 trinn

Lagre chathistorikk i Redis og PostgreSQL er en gratis leksjon i AI Engineering Academy på CoddyKit. Dette er leksjon 4 av 4. Du kan lese hele leksjonen gratis nedenfor – og deretter øve praktisk i nettleseren med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt. Den er en del av læringsløpet i AI Engineering Academy, og fremdriften din synkroniseres mellom nettet og CoddyKit-appen. Kurset i AI Engineering Academy inneholder totalt 4 leksjoner.

Hvorfor lagre chatthistorikk eksternt?

Samtalehistorikk i minnet forsvinner når applikasjonen starter på nytt eller skaleres til flere instanser. Ekstern lagring løser tre problemer: historikken overlever krasj, flere serverinstanser kan dele den samme historikken, og De kan laste inn tidligere økter for brukere som kommer tilbake. Redis og PostgreSQL er de to mest populære backend-løsningene for dette.

Grensesnittet for chatmeldingshistorikk i LangChain

LangChain definerer et BaseChatMessageHistory-grensesnitt med to metoder: add_message(message) og messages (egenskap). Alle lagringsbackend-er som implementerer dette grensesnittet, kan settes inn som minne for enhver LangChain-kjede. Både Redis- og PostgreSQL-implementasjonene følger dette grensesnittet.

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

Koble Redis-historikk til en kjede

Pakk inn kjeden med RunnableWithMessageHistory, og angi en fabrikkfunksjon som returnerer riktig historikkobjekt for hver økt. LangChain laster automatisk inn historikken før hvert kall og lagrer nye meldinger etter hvert svar.

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

Kall kjeden med en økt-ID

Når De kaller en kjede som er pakket inn med meldingshistorikk, sender De økt-ID-en i config-ordboken under configurable. LangChain ruter automatisk hvert kall til riktig historikklager, slik at Alice og Bob får fullstendig separate samtalehistorikker.

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

Utforming av Redis-nøkler for chathistorikk

Redis lagrer meldingene for hver økt som en liste under en nøkkel som er avledet fra økt-ID-en. Bruk et strukturert nøkkelskjema, for eksempel chat:<app>:<user_id>:<session_id>, for å unngå nøkkelkollisjoner mellom applikasjoner og muliggjøre effektiv skanning per bruker. Angi en TTL for gamle øktnøkler for å forhindre ubegrenset vekst i lagringsmengden.

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)

Utforming av PostgreSQL-tabell for chathistorikk

For SQL-basert persistens oppretter De en tabell med kolonner for økt-ID, meldingsrolle, innhold og tidsstempel. PostgreSQL er ideelt når chathistorikken må kunne spørres mot, revideres eller kobles sammen med data fra brukerkontoer. Pakken langchain_postgres tilbyr en ferdig implementasjon.

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

Klassen PostgresChatMessageHistory fra langchain_postgres fungerer akkurat som Redis-versjonen, men lagrer meldinger i PostgreSQL-databasen Deres. Send inn en tilkoblingsstreng og en økt-ID, så håndterer den automatisk oppretting av tabeller og serialisering av meldinger.

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

Laste inn tidligere økter for tilbakevendende brukere

Når en bruker kommer tilbake til applikasjonen etter å ha lukket den, kan De gjenopprette brukerens siste økt ved å laste inn historikken fra Redis eller PostgreSQL. Presenter brukeren for et sammendrag av hvor vedkommende avsluttet, eller fortsett sømløst ved å sette inn den lagrede historikken i neste prompt.

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

Beskjære historikk i databasen

Langvarige økter kan samle tusenvis av meldinger. Implementer en strategi for beskjæring som sletter meldinger som er eldre enn en grense, eller som bare beholder de siste N meldingene i databasen. Dette holder uthentingen rask og forhindrer at kontekstvinduene blir overfylte når De laster inn historikken.

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

Velge mellom Redis og PostgreSQL

Begge backend-ene er klare for produksjonsbruk, men har ulike styrker. Redis tilbyr lesing på under ett millisekund, noe som gjør det ideelt for sanntidschat der forsinkelse er viktigst. PostgreSQL tilbyr full SQL-spørrbarhet, ACID-transaksjoner og enkel integrasjon med den eksisterende brukerdatabasen for analyse og revisjon. Mange produksjonssystemer bruker Redis som primærbuffer og PostgreSQL til varig arkivering.

Sikkerhet: Isolere historikk for flere leietakere

I applikasjoner med flere leietakere må De sikre at brukere ikke får tilgang til hverandres historikk. Ta alltid med bruker-ID-en i øktnøkkelen, valider at økt-ID-en tilhører den autentiserte brukeren før historikken lastes inn, og eksponer aldri rå øktnøkler i URL-er eller informasjonskapsler på klientsiden.

God nøkkel: chat:app1:user:42:session:abc
Dårlig nøkkel: session:abc (kan gjettes, uten brukerspesifikt omfang)

Kort kontroll

Test forståelsen Deres av ekstern persistens av chathistorikk.

Besvar den i den interaktive leksjonen

Oppsummering av leksjonen

I denne leksjonen lærte De at RedisChatMessageHistory lagrer chathistorikk i Redis med nøkler per økt, at PostgresChatMessageHistory muliggjør varig lagring som kan spørres mot med SQL, og at RunnableWithMessageHistory kobler enhver backend til kjeden via en session_id-fabrikk. Neste tema er ReAct-rammeverket for å bygge agenter som kan resonnere og handle.

Gratis å komme i gang

Lær deg Python med en AI-veileder – gratis

Skriv og kjør ekte kode i nettleseren, få umiddelbar hjelp fra en AI-veileder som er tilgjengelig døgnet rundt, og fortsett der du slapp – på nettet eller i appen.

Kurs: 30
Leksjoner: 120

Start læringen gratis Se hele kurset

Ofte stilte spørsmål

Er leksjonen «Lagre chathistorikk i Redis og PostgreSQL» gratis?

Ja – hele teksten i «Lagre chathistorikk i Redis og PostgreSQL» er gratis å lese her på nettet. For å øve interaktivt med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt, og for å låse opp resten av AI Engineering Academy-kurset, kan du oppgradere til CoddyKit PRO. Kurset i AI Engineering Academy inneholder totalt 4 leksjoner.

Hva lærer jeg i «Lagre chathistorikk i Redis og PostgreSQL»?

Lagre samtalehistorikk eksternt ved hjelp av RedisChatMessageHistory og PostgresChatMessageHistory, slik at minnet overlever omstarter av applikasjonen og kan skaleres på tvers av flere instanser. Du øver på AI Engineering Academy med praktisk kode som du kjører direkte i nettleseren, mens en AI-veileder som er tilgjengelig døgnet rundt, svarer på spørsmålene dine mens du jobber deg gjennom leksjonen.

Trenger jeg erfaring for å begynne med AI Engineering Academy?

Ingen tidligere erfaring er nødvendig. AI Engineering Academy på CoddyKit er lagt opp for både nybegynnere og viderekomne, så De kan begynne her eller helt fra start og lære i Deres eget tempo. Dette er leksjon 4 av 4.

Hvor lang tid tar leksjonen «Lagre chathistorikk i Redis og PostgreSQL»?

De fleste CoddyKit-leksjoner tar omtrent 5–10 minutter. Hver leksjon er kort og interaktiv, slik at De gjør jevne fremskritt og kan fortsette akkurat der De slapp – både på nettet og i appen.

Kan jeg skrive og kjøre kode i denne AI Engineering Academy-leksjonen?

Ja. Alle AI Engineering Academy-leksjoner har en innebygd kodeeditor, slik at De kan skrive og kjøre ekte kode direkte i nettleseren og få umiddelbar tilbakemelding fra AI – uten lokal konfigurering.

Alle leksjonene i dette kurset

Hvorfor tilstandsfrie LLM-er trenger eksternt minne
Buffer- og vindusminne
Sammendragsminne og tokenbevisst avkorting
Lagre chathistorikk i Redis og PostgreSQL

← Tilbake til AI Engineering Academy