...
← Curs Aplicații AI cu Claude și OpenAI: toate lecțiile
Lecția 4 · Cum funcționează LLM-urile

Fereastra de context și memoria conversației

Când vorbești cu un chatbot, pare că își amintește tot ce i-ai spus. Surpriza pentru oricine construiește prima aplicație: API-ul nu ține minte nimic. Fiecare apel pornește de la zero, iar „memoria” este istoricul pe care aplicația ta îl retrimite de fiecare dată. În această lecție vezi ce este fereastra de context, cât de mare e și cum gestionezi istoricul fără să plătești degeaba.

Contextul: tot ce vede modelul la un apel

Contextul este tot textul pe care modelul îl are în față la un apel: instrucțiunile (system, din modulul 2), toate mesajele conversației trimise în messages și, pe măsură ce îl scrie, răspunsul. Modelul nu vede nimic altceva: nici apelurile anterioare, nici baza ta de date, nici ce a răspuns altui utilizator.

Fereastra de context este limita maximă de tokeni care încap într-un apel. Pentru modelele din curs: 1.000.000 de tokeni la Claude Haiku, Sonnet și Opus 5.5 și 272.000 la modelele GPT-6 Luna, GPT-6.1 Sol și GPT-6 Astra. Un milion de tokeni înseamnă câteva sute de pagini de text.

Ce trimite aplicația la fiecare apel (contextul):systemuserreplica 1assistantreplica 2usermesajul nourăspunsul(max_tokens)spațiu liberpână la limitălimita ferestreiClaude Haiku / Sonnet / Opus 5.5: 1.000.000 de tokeniGPT-6 Luna, GPT-6.1 Sol, GPT-6 Astra: 272.000 de tokeniapelul următor: totul din nouAPI-ul nu păstrează nimic între apeluri: „memoria” este lista messages pe care o retrimiți tu.
Contextul unui apel: system, istoricul conversației, mesajul nou și răspunsul trebuie să încapă împreună în fereastra modelului; la apelul următor se trimit din nou toate.

API-ul nu are memorie

Să vedem ce se întâmplă dacă trimiți fiecare mesaj al utilizatorului separat, cum ar face o aplicație scrisă în grabă:

import anthropic

MODEL = "claude-haiku-5-5"
client = anthropic.Anthropic()

# două apeluri separate, fiecare cu UN singur mesaj
r1 = client.messages.create(
    model=MODEL, max_tokens=200,
    messages=[{"role": "user", "content": "Bună, sunt Andrei și am comanda 1042."}],
)
print("Asistent:", r1.content[0].text)

r2 = client.messages.create(
    model=MODEL, max_tokens=200,
    messages=[{"role": "user", "content": "Când ajunge comanda mea?"}],
)
print("Asistent:", r2.content[0].text)
Asistent: Bună, Andrei! Cu ce te pot ajuta legat de comanda 1042?
Asistent: Nu știu despre ce comandă vorbești. Îmi poți da numărul comenzii?

La al doilea apel, modelul nu are de unde să știe de comanda 1042: pentru el, conversația începe acum. Soluția este să trimiți întreaga conversație de fiecare dată, ca listă de mesaje care alternează user și assistant:

import anthropic

MODEL = "claude-haiku-5-5"
client = anthropic.Anthropic()

istoric = [
    {"role": "user", "content": "Bună, sunt Andrei și am comanda 1042."},
    {"role": "assistant", "content": "Bună, Andrei! Cu ce te pot ajuta legat de comanda 1042?"},
    {"role": "user", "content": "Când ajunge comanda mea?"},
]

raspuns = client.messages.create(model=MODEL, max_tokens=200, messages=istoric)
print("Asistent:", raspuns.content[0].text)
Asistent: Comanda 1042 a plecat ieri din depozit și ajunge mâine, Andrei.
Așa funcționează și aplicațiile de chat

Claude.ai sau ChatGPT „își amintesc” conversația pentru că aplicația păstrează istoricul și îl retrimite la fiecare mesaj nou. Când construiești un chatbot, această sarcină este a ta.

Istoricul care crește (și costă)

Într-o aplicație reală, istoricul este o listă în care adaugi mesajul utilizatorului înainte de apel și răspunsul modelului după apel. Urmărește coloana cu tokenii trimiși:

import anthropic

MODEL = "claude-haiku-5-5"
client = anthropic.Anthropic()

intrebari = [
    "Bună, sunt Andrei și am comanda 1042.",
    "Când ajunge comanda mea?",
    "Pot schimba adresa de livrare?",
]

istoric = []
for intrebare in intrebari:
    istoric.append({"role": "user", "content": intrebare})
    raspuns = client.messages.create(model=MODEL, max_tokens=200, messages=istoric)
    text = raspuns.content[0].text
    istoric.append({"role": "assistant", "content": text})
    print(f"[{raspuns.usage.input_tokens} tokeni trimiși] {text}")
[21 tokeni trimiși] Bună, Andrei! Cu ce te pot ajuta legat de comanda 1042?
[65 tokeni trimiși] Comanda 1042 a plecat ieri din depozit și ajunge mâine, Andrei.
[110 tokeni trimiși] Da, Andrei. Coletul e deja la curier, așa că schimbi adresa din linkul de urmărire primit pe email.
1
Înainte de apel adaugi mesajul nou cu rolul user.
2
Trimiți toată lista istoric.
3
După apel adaugi răspunsul cu rolul assistant, ca la replica următoare modelul să-și vadă propriile răspunsuri.
4
La fiecare replică, input_tokens crește: plătești din nou pentru tot istoricul. O conversație de 50 de replici costă mult mai mult decât 50 de întrebări separate.

Când istoricul devine prea lung

Chiar dacă fereastra este mare, nu vrei să trimiți la nesfârșit tot istoricul: costul crește la fiecare replică, răspunsurile devin mai lente, iar informațiile importante se pierd printre cele vechi. Dacă depășești limita ferestrei, API-ul refuză cererea cu o eroare 400. Strategiile obișnuite:

  • Ultimele N mesaje: păstrezi doar finalul conversației (simplu și suficient pentru majoritatea chatboților de suport).
  • Rezumat: când istoricul trece de un prag, ceri modelului un rezumat al părții vechi și îl pui în locul ei.
  • Fapte importante separat: numele clientului, numărul comenzii sau preferințele le ții în variabile și le pui în system, nu le lași să se piardă în istoric.

O funcție care păstrează ultimele mesaje trebuie să respecte o regulă a API-ului: **primul mesaj trebuie să fie user**. Altfel primești 400.

def pastreaza_ultimele(istoric, n):
    """Ultimele n mesaje, dar lista trebuie să înceapă cu un mesaj user."""
    scurt = istoric[-n:]
    while scurt and scurt[0]["role"] != "user":
        scurt = scurt[1:]
    return scurt


istoric = [
    {"role": "user", "content": "Salut!"},
    {"role": "assistant", "content": "Bună! Cu ce te ajut?"},
    {"role": "user", "content": "Aveți laptopuri?"},
    {"role": "assistant", "content": "Da, 12 modele."},
    {"role": "user", "content": "Care e cel mai ușor?"},
]

for m in pastreaza_ultimele(istoric, 4):
    print(m["role"], "->", m["content"])
user -> Aveți laptopuri?
assistant -> Da, 12 modele.
user -> Care e cel mai ușor?

Greșeli frecvente

  • Trimiți doar ultimul mesaj: modelul „uită” tot și cere din nou informații pe care clientul tocmai le-a dat.
  • Uiți să adaugi răspunsul modelului în istoric: la replica următoare modelul nu știe ce a promis.
  • Pui două mesaje user la rând fără să vrei sau începi lista cu assistant: la Claude, primul mesaj trebuie să fie user (altfel 400).
  • Păstrezi un singur istoric pentru toți utilizatorii: conversațiile se amestecă. Fiecare utilizator (sau sesiune) are lista lui.
  • Lași istoricul să crească la nesfârșit: costul pe replică urcă fără ca răspunsurile să devină mai bune.
SuportChat pe site

Istoricul fiecărei sesiuni stă pe server; se trimit ultimele 20 de mesaje plus numărul comenzii în system.

EducațieTutor pentru elevi

Lecția curentă și ultimele întrebări ale elevului intră în context, nu toate sesiunile din semestru.

ClinicăProgramări

Asistentul păstrează pe durata conversației specialitatea și ziua alese, ca să nu le ceară de două ori.

Exercițiul tău

Asistentul unei clinici trebuie să răspundă la o întrebare care are sens doar în contextul conversației. Construiește lista istoric cu cele 3 mesaje (prezentarea pacientei, răspunsul anterior al asistentului, întrebarea nouă), trimite-o și afișează Asistent: + răspunsul, apoi Mesaje trimise: + numărul de mesaje.

  • Creează lista istoric cu 3 dicționare, în ordinea user, assistant, user.
  • Folosește constantele PREZENTARE, RASPUNS_ANTERIOR și INTREBARE ca valori pentru content.
  • Trimite lista cu client.messages.create(model=MODEL, max_tokens=300, messages=istoric).
  • Afișează Asistent: + textul răspunsului și Mesaje trimise: + len(istoric).
Răspunsul anterior al asistentului se pune în listă cu {"role": "assistant", "content": RASPUNS_ANTERIOR}.

Soluția exercițiului

import anthropic

MODEL = "claude-haiku-5-5"
client = anthropic.Anthropic()

PREZENTARE = "Bună, sunt Maria Pop și vreau o programare la dermatologie."
RASPUNS_ANTERIOR = "Bună, Maria! Pentru ce zi dorești programarea la dermatologie?"
INTREBARE = "Joi dimineață. Ce acte trebuie să aduc?"

istoric = [
    {"role": "user", "content": PREZENTARE},
    {"role": "assistant", "content": RASPUNS_ANTERIOR},
    {"role": "user", "content": INTREBARE},
]

raspuns = client.messages.create(model=MODEL, max_tokens=300, messages=istoric)
print("Asistent:", raspuns.content[0].text)
print("Mesaje trimise:", len(istoric))
Excelent! Continuă cu lecția următoare →
main.pyPython
ConsolăSe încarcă...
Mediul de lucru se încarcă. Poți citi lecția între timp.
Rulează codul cu butonul de sus sau cu Ctrl + Enter / Cmd + Enter.
Parcursul tău Cum funcționează LLM-urile Lecția 4 · Fereastra de context și memoria conversației
Progres 0% 0 din 10
Lecția curentă 4 / 8 Cum funcționează llm-urile