Salt la conținutul principal
Română— Alege o limbă
Meniu

Conversație pe mai multe ture

Lecția 7 din 14 Actualizată 2 noiembrie 2026 Dezvoltator
Pe această pagină
  1. Dincolo de apelurile unice
  2. Principiul: Menținerea istoricului
  3. Bucla completă de conversație
  4. Exemplu de conversație pe mai multe ture
  5. Înlănțuirea apelurilor secvențiale
  6. Gestionarea dimensiunii istoricului
  7. Puncte cheie

Dincolo de apelurile unice

Într-o aplicație din lumea reală, utilizatorii nu pun o singură întrebare și apoi dispar. Ei înlănțuie cereri, revin la subiecte anterioare și oferă indicii precum „dar despre acesta?“ pe care propoziția izolată nu le poate rezolva. Apelarea funcțiilor trebuie să funcționeze în acest context de conversație pe mai multe ture, unde modelul poate apela funcții la fiecare pas al dialogului fără a pierde niciodată șirul celor întâmplate anterior.

Principiul: Menținerea istoricului

Cheia se rezumă la o singură frază: păstrați toate mesajele într-o listă care crește la fiecare schimb. Modelul nu are memorie proprie între apelurile API; singurul context de care dispune este ceea ce îi trimiteți dumneavoastră înapoi. Acest istoric complet este ceea ce îi permite să înțeleagă referințele implicite.

import os
import json
from mistralai.client import Mistral
from functools import partial

client = Mistral(api_key=os.environ["MISTRAL_API_KEY"])
model = "mistral-large-latest"

# Istoricul conversației
messages = [
    {
        "role": "system",
        "content": "You are a payment tracking assistant. "
                   "Respond in concise English."
    }
]

Bucla completă de conversație

Codul de mai jos funcționează în două etape. process_tool_calls execută toate apelurile solicitate de model și repornește conversația cu rezultatele; chat gestionează un tur complet, de la input-ul utilizatorului până la textul final.

def process_tool_calls(response, messages, available_functions, tools):
    """Procesează tool_calls și returnează răspunsul final."""
    message = response.choices[0].message
    messages.append(message)

    # Execută fiecare tool_call
    for tool_call in message.tool_calls:
        function_name = tool_call.function.name
        function_params = json.loads(tool_call.function.arguments)

        if function_name in available_functions:
            result = available_functions[function_name](**function_params)
        else:
            result = json.dumps({"error": f"Unknown function {function_name}"})

        messages.append({
            "role": "tool",
            "name": function_name,
            "content": result,
            "tool_call_id": tool_call.id
        })

    # Reapelează modelul cu rezultatele
    return client.chat.complete(
        model=model, messages=messages, tools=tools
    )


def chat(user_input: str, messages: list, tools: list,
         available_functions: dict) -> str:
    """Gestionează un tur complet de conversație."""
    messages.append({"role": "user", "content": user_input})

    response = client.chat.complete(
        model=model, messages=messages, tools=tools
    )

    message = response.choices[0].message

    # Continuă bucla atâta timp cât modelul dorește să apeleze funcții
    while message.tool_calls and len(message.tool_calls) > 0:
        response = process_tool_calls(
            response, messages, available_functions, tools
        )
        message = response.choices[0].message

    # Modelul a terminat – răspunde cu text
    messages.append(message)
    return message.content

Bucla while este elementul critic. După primirea unui rezultat de funcție, modelul ar putea foarte bine să solicite încă unul: bucla continuă atâta timp cât se produc tool_calls și se oprește doar când modelul returnează finalmente text. Un simplu if ar gestiona primul apel și ar returna apoi un răspuns gol în orice caz în care erau necesare două apeluri.

Exemplu de conversație pe mai multe ture

Să vedem cum arată această buclă pe parcursul a patru ture înlănțuite.

# Turul 1
reponse = chat("What is the status of payment T1001?",
               messages, tools, available_functions)
print(f"Assistant : {reponse}")
# → "Payment T1001 status: paid."

# Turul 2 — întrebare de follow-up
reponse = chat("When was it made?",
               messages, tools, available_functions)
print(f"Assistant : {reponse}")
# → "Payment T1001 was made on March 15, 2026."

# Turul 3 — tranzacție nouă
reponse = chat("Compare with payment T1003.",
               messages, tools, available_functions)
print(f"Assistant : {reponse}")
# → "Payment T1003 is pending, unlike T1001 which is paid."

# Turul 4 — întrebare fără funcție
reponse = chat("Thanks, that's all for today.",
               messages, tools, available_functions)
print(f"Assistant : {reponse}")
# → "You're welcome! Feel free to ask if you have other questions."

Turul 2 este cel care merită examinat cu atenție. „When was it made?“ nu conține niciun identificator; istoricul este cel care permite modelului să înțeleagă că se referă tot la T1001 și să apeleze retrieve_payment_date cu argumentul corect. Dacă eliminați mesajele din Turul 1, această propoziție devine insolubilă. În Turul 3, modelul poate decide să apeleze multiple funcții—status și dată pentru T1003—pentru a construi comparația cu rezultatele deja obținute pentru T1001. Turul 4 nu declanșează niciun apel: modelul știe și când să se abțină.

Înlănțuirea apelurilor secvențiale

Unele cereri necesită ca modelul să aștepte un rezultat înainte de a ști ce să ceară în continuare. Bucla while din chat() gestionează acest caz fără o singură linie de cod suplimentară.

# Utilizatorul cere ceva ce necesită 2 apeluri secvențiale
reponse = chat(
    "Show me the status and date of payment T1002.",
    messages, tools, available_functions
)
# Modelul poate:
# 1. Să apeleze retrieve_payment_status(T1002)
# 2. Să primească rezultatul
# 3. Să apeleze retrieve_payment_date(T1002)
# 4. Să primească rezultatul
# 5. Să formuleze răspunsul final cu ambele informații

Privit din perspectiva istoricului de mesaje, fluxul secvențial arată astfel:

user → assistant(tool_call_1) → tool(result_1) → assistant(tool_call_2) → tool(result_2) → assistant(response)

Numărați intervențiile asistentului: trei, ceea ce înseamnă trei cereri facturate API-ului. Acesta este costul execuției secvențiale și motivul pentru care lecția următoare se concentrează pe apelurile paralele.

Gestionarea dimensiunii istoricului

În producție, o conversație de lungă durată devine costisitoare: fiecare tur trimite înapoi întregul set de mesaje anterioare, iar factura de token-uri crește pătratic. O strategie simplă este să păstrați doar mesajul de sistem și schimburile cele mai recente.

def trim_messages(messages: list, max_messages: int = 20) -> list:
    """Păstrează mesajul de sistem și ultimele N mesaje."""
    system_messages = [m for m in messages if hasattr(m, "role")
                       and m.get("role") == "system"
                       or (isinstance(m, dict) and m.get("role") == "system")]

    non_system = [m for m in messages if m not in system_messages]

    if len(non_system) > max_messages:
        non_system = non_system[-max_messages:]

    return system_messages + non_system

O precauție înainte de a integra această funcție: nu tăiați niciodată un tool_call fără mesajul tool corespunzător. Dacă trunchierea cade între cele două, API-ul primește o cerere de apel fără răspuns și respinge interogarea. Ajustați punctul de tăiere pentru a păstra perechile complete, în loc să numărați mesajele orb.

Puncte cheie

  • Mențineți un istoric complet al mesajelor pentru ca modelul să înțeleagă contextul
  • Folosiți o buclă while pentru a gestiona apelurile secvențiale de funcții
  • Modelul înțelege referințele implicite („acela“, „cel precedent“) datorită contextului
  • În producție, limitați dimensiunea istoricului păstrând totodată perechile tool_call/tool intacte
  • Funcția chat() prezentată aici este un model reutilizabil pentru orice aplicație de apelare a funcțiilor