Preskok na glavno vsebino
Slovenščina— Izberite jezik
Meni

Pogovori z več krogi v Pythonu

Lekcija 7 od 14 Posodobljeno 2. november 2026 Razvijalec
Na tej strani
  1. Spomin, ki v resnici ni spomin
  2. Tri vloge, ki strukturirajo zgodovino
  3. Popoln pogovor, korak za korakom
  4. Preprečevanje, da bi zgodovina postala pretirano draga
  5. Oblikovanje sistemskega sporočila
  6. Ključne ugotovitve

Spomin, ki v resnici ni spomin

Za razliko od iskalnika jezikovni model sledi niti pogovora: upošteva prejšnja sporočila in svoje odgovore gradi na tem zbranem kontekstu. Temu pravimo pogovor z več krogi (multi-turn), kar omogoča eliptična vprašanja, kot je „in z argumenti?”.

Tehnično pa se model ne spomni ničesar. Na strežniku med klici ni ohranjeno nobeno stanje. Pri vsaki zahtevi moraš ponovno poslati celotno zgodovino, ki jo model prebere od začetka do konca, preden odgovori. Ta mehanizem pojasnjuje dve stvari, na kateri se bomo kasneje vrnili: popolnoma si odgovoren za upravljanje spomina in vsak krog pogovora stane več kot prejšnji.

Tri vloge, ki strukturirajo zgodovino

Vsako sporočilo v zgodovini nosi vlogo, ki modelu pove, kdo govori. Vloga system določa splošno vedenje: ker je postavljena prva, vpliva na vsak naslednji odgovor.

{"role": "system", "content": "You are an expert assistant in French cuisine. Always respond in French using precise culinary terms."}

Vloga user prenaša uporabnikova sporočila – torej vprašanje ali navodilo, ki je bilo poslano:

{"role": "user", "content": "How do I make perfect puff pastry?"}

Končno vloga assistant vsebuje prejšnje odgovore modela. To so sporočila, ki jih ponovno vstaviš v zgodovino, da ohraniš koherenco. Če jih pozabiš, je enakovredno brisanju spomina pogovora ob vsakem koraku.

{"role": "assistant", "content": "To make perfect puff pastry, start by..."}

Popoln pogovor, korak za korakom

Spodnja koda uporablja to načelo: funkcija doda vprašanje v zgodovino, pokliče model, nato shrani odgovor na pravo mesto in ga vrne.

import os
from mistralai.client import Mistral

client = Mistral(api_key=os.environ["MISTRAL_API_KEY"])

historique = [
    {
        "role": "system",
        "content": "You are a teaching assistant specialized in Python programming. Respond concisely and include code examples."
    }
]

def poser_question(question: str) -> str:
    """Sends a question and updates the history."""
    historique.append({"role": "user", "content": question})

    response = client.chat.complete(
        model="mistral-small-latest",
        messages=historique,
    )

    reponse_texte = response.choices[0].message.content
    historique.append({"role": "assistant", "content": reponse_texte})

    return reponse_texte

# Turn 1
print("Q: What is a decorator in Python?")
r1 = poser_question("What is a decorator in Python?")
print(f"R: {r1}\n")

# Turn 2 — the model knows the context
print("Q: Can you show me a concrete example?")
r2 = poser_question("Can you show me a concrete example?")
print(f"R: {r2}\n")

# Turn 3 — implicit reference to previous turns
print("Q: How do I use it with arguments?")
r3 = poser_question("How do I use it with arguments?")
print(f"R: {r3}\n")

Do tretjega kroga vprašanje nikoli več ne omeni besede „dekorator”. Model kljub temu razume, da se „uporaba” nanaša na ta koncept, ker ponovno prebere celoten izmenjavo. Odstrani vrstico, ki dodaja odgovor v zgodovino, in ponovno zaženi kodo: model bo vprašal, o čem govoriš. To je najhitrejši dokaz, da neprekinjenost ne izvira iz modela, temveč iz tvoje kode.

Preprečevanje, da bi zgodovina postala pretirano draga

Vsak model ima omejeno okno konteksta, merjeno v žetonih (tokens). Ko zgodovina raste, postane vsaka zahteva dražja, ker se vse znova prenese. Pogovor s tridesetimi krogi dejansko zaračuna svoj začetek tridesetkrat.

Najpreprostejša rešitev je obrezovanje: obdržiš sistemsko sporočilo in zadnjih N izmenjav:

MAX_MESSAGES = 20

def ajouter_message(historique, role, content):
    historique.append({"role": role, "content": content})

    # Keep the system message + the last N messages
    if len(historique) > MAX_MESSAGES + 1:  # +1 for the system message
        system_msg = historique[0]
        historique = [system_msg] + historique[-(MAX_MESSAGES):]

    return historique

Ta pristop je poceni, a brutalen: kar je uporabnik določil v drugem krogu, za vedno izgine. Ko je pogovor dolg in je starejši kontekst pomemben – na primer pri intervjuju za zbiranje zahtev – ga raje povzemi, namesto da ga zavržeš:

def resumer_historique(client, historique):
    """Summarizes old messages to free up context."""
    texte_complet = "\n".join(
        f"{m['role']}: {m['content']}"
        for m in historique[1:-4]  # Exclude system and the last 4 messages
    )

    resume = client.chat.complete(
        model="mistral-small-latest",
        messages=[
            {"role": "user", "content": f"Summarize this conversation in 3-4 sentences:\n{texte_complet}"}
        ]
    )

    return [
        historique[0],  # System message
        {"role": "assistant", "content": f"[Conversation Summary] {resume.choices[0].message.content}"},
    ] + historique[-4:]  # The last 4 messages

Ideja je stisniti oddaljeno preteklost v nekaj stavkov, hkrati pa ohraniti zadnja štiri sporočila nedotaknjena, saj nosijo neposredni kontekst. Povzetek porabi en klic več, a se v naslednjih krogih mnogokrat izplača.

Oblikovanje sistemskega sporočila

Sistemsko sporočilo je najmočnejše in najpogosteje neizkoriščeno orodje v tej lekciji. Mnogi se zadovoljijo s splošnim „Ti si koristen asistent”, kar ne doda ničesar. Dobro sistemsko sporočilo določa preverljive omejitve:

system_prompt = """You are a Corsen AI technical assistant.

Rules:
- Respond in French with a professional tone
- Provide code examples when relevant
- If you are unsure, say so rather than making things up
- Limit your responses to 200 words unless asked otherwise

Context: The user is working on a Python 3.12 project with FastAPI."""

Vsaka vrstica tu povzroči merljiv učinek: omejitev dolžine zadržuje stroške, povabilo k priznanju negotovosti zmanjšuje halucinacije, omemba tehnološkega sklada pa preprečuje splošne, neustrezne odgovore. Jedrnato, natančno, nedvoumno – to je vse, kar potrebuje.

Ključne ugotovitve

  • Celotna zgodovina se ponovno pošlje z vsako zahtevo – model se ne „spomni” ničesar
  • Tri vloge (system, user, assistant) strukturirajo pogovor
  • Sporočilo system določa splošno vedenje – vedno ga postavi prvo
  • Upravljaj velikost konteksta z obrezovanjem ali povzemanjem starih sporočil
  • Daljša kot je zgodovina, dražja je vsaka zahteva v žetonih