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

Executarea și returnarea rezultatului

Lecția 6 din 14 Actualizată 2 noiembrie 2026 Dezvoltator
Pe această pagină
  1. Pasul pe care îl controlați în totalitate
  2. Executarea funcției la nivelul clientului
  3. Construirea mesajului de tip Tool
  4. Trimiterea rezultatului și obținerea răspunsului final
  5. Fluxul complet într-un singur bloc
  6. Structura mesajelor la fiecare pas
  7. Atenție la formatul conținutului
  8. Puncte cheie

Pasul pe care îl controlați în totalitate

Ați primit un tool_call de la model. Acesta vă indică ce funcție să apelați și cu ce argumente—nimic mai mult. Acum codul dumneavoastră preia controlul: execută funcția, recuperează rezultatul și îl trimite înapoi modelului sub forma unui mesaj cu rolul tool. Această lecție acoperă întregul ciclu dus-întors. Acesta este singurul moment din ciclu în care luați toate deciziile.

Executarea funcției la nivelul clientului

Să revenim asupra dicționarului de dispecerizare din Lecția 4 și să îl conectăm la răspunsul modelului.

import json
from functools import partial

# Funcții deja definite
available_functions = {
    "retrieve_payment_status": partial(retrieve_payment_status, df),
    "retrieve_payment_date": partial(retrieve_payment_date, df),
}

# Modelul a returnat un tool_call
tool_call = response.choices[0].message.tool_calls[0]
function_name = tool_call.function.name
function_params = json.loads(tool_call.function.arguments)

# Executarea funcției
if function_name in available_functions:
    result = available_functions[function_name](**function_params)
    print(f"Result: {result}")
    # → '{"status": "paid"}'
else:
    result = json.dumps({"error": f"Function {function_name} not available"})

Două mecanisme sunt active aici. Primul este **function_params, care despachetează dicționarul din JSON în argumente numite: dacă modelul a generat {"transaction_id": "T1001"}, apelul este exact echivalent cu retrieve_payment_status(transaction_id="T1001"). Al doilea este blocul else. Este mai puțin spectaculos, dar esențial. Un model poate halucina un nume de funcție care nu există în dispecerizarea dumneavoastră; fără această verificare, aplicația dumneavoastră va genera o eroare KeyError, iar conversația se va bloca complet. Cu ea, eroarea devine o informație pe care modelul o poate gestiona cu grație.

Construirea mesajului de tip Tool

Rezultatul trebuie trimis înapoi modelului într-un format specific—un mesaj cu rolul "tool":

tool_message = {
    "role": "tool",
    "name": function_name,
    "content": result,  # Trebuie să fie un șir de caractere
    "tool_call_id": tool_call.id
}
CâmpRol
role"tool"—identifică mesajul ca fiind un rezultat de funcție
nameNumele funcției executate
contentRezultatul sub formă de șir JSON
tool_call_idID-ul tool_call-ului original—permite modelului să asocieze rezultatul cu apelul corect

Trimiterea rezultatului și obținerea răspunsului final

Modelul nu are memorie de la un apel la altul: nu își amintește că v-a cerut ceva. Prin urmare, trebuie să reconstruiți întreaga conversație pentru el, inclusiv propria sa solicitare de apelare a unui instrument, înainte de a prezenta rezultatul.

# 1. Adăugarea mesajului asistentului (cu tool_call)
messages.append(response.choices[0].message)

# 2. Adăugarea rezultatului funcției
messages.append({
    "role": "tool",
    "name": function_name,
    "content": result,
    "tool_call_id": tool_call.id
})

# 3. Apelarea modelului din nou cu contextul complet
final_response = client.chat.complete(
    model="mistral-large-latest",
    messages=messages,
    tools=tools
)

# 4. Afișarea răspunsului final
print(final_response.choices[0].message.content)
# → "Payment T1001 status is: paid."

Ordinea celor două operațiuni append este non-negociabilă: mesajul asistentului care conține tool_call trebuie să precede mesajul tool care îi răspunde. Inversarea lor creează un istoric inconsistent pe care API-ul îl va respinge.

Fluxul complet într-un singur bloc

Iată întregul proces, de la întrebarea utilizatorului până la răspunsul final:

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

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

# Funcții și instrumente (definite anterior)
available_functions = {
    "retrieve_payment_status": partial(retrieve_payment_status, df),
    "retrieve_payment_date": partial(retrieve_payment_date, df),
}

# Pașii 1-2: Întrebarea utilizatorului + apel API
messages = [
    {"role": "user", "content": "What is the status of payment T1001?"}
]

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

# Pașii 3-4: Extragerea tool_call și executarea
message = response.choices[0].message

if message.tool_calls:
    tool_call = message.tool_calls[0]
    function_name = tool_call.function.name
    function_params = json.loads(tool_call.function.arguments)

    # Executare la nivelul clientului
    result = available_functions[function_name](**function_params)

    # Pasul 5: Trimiterea rezultatului înapoi la model
    messages.append(message)
    messages.append({
        "role": "tool",
        "name": function_name,
        "content": result,
        "tool_call_id": tool_call.id
    })

    final_response = client.chat.complete(
        model=model, messages=messages, tools=tools
    )
    print(final_response.choices[0].message.content)
else:
    print(message.content)

Structura mesajelor la fiecare pas

Merită să inspectați lista messages odată ce ciclul s-a încheiat, deoarece este cea mai bună metodă de a depana apelurile de funcții care nu se comportă corect. Aceasta conține patru mesaje.

# Mesajul 1: Întrebarea utilizatorului
{"role": "user", "content": "What is the status of payment T1001?"}

# Mesajul 2: Răspunsul modelului cu tool_call
{"role": "assistant", "tool_calls": [{"id": "call_abc123", ...}]}

# Mesajul 3: Rezultatul funcției
{"role": "tool", "name": "retrieve_payment_status",
 "content": '{"status": "paid"}', "tool_call_id": "call_abc123"}

# Mesajul 4 (implicit): Răspunsul final al modelului
# → "Payment T1001 status is: paid."

Urmăriți ID-ul call_abc123: acesta ia naștere în Mesajul 2 și reapare în Mesajul 3. Acest fir conductor leagă cererea de răspunsul său. Această structură reprezintă modelul fundamental al apelării de funcții; fiecare variație pe care o veți întâlni ulterior, fie că este multi-tur sau paralelă, nu face decât să repete sau să dubleze acest model.

Atenție la formatul conținutului

O eroare apare mai des decât toate celelalte la un loc, și ține de tipul câmpului content: acesta trebuie să fie întotdeauna un șir de caractere.

# Corect — șir JSON
{"content": '{"status": "paid"}'}

# Corect — text simplu
{"content": "The status is paid"}

# Incorect — dicționar Python (va cauza o eroare)
{"content": {"status": "paid"}}

Diferența dintre primul și al treilea exemplu constă în ghilimelele care încadrează JSON-ul. Dacă funcția dumneavoastră returnează un dicționar, convertiți-l cu json.dumps() înainte de a-l trimite—de aceea toate funcțiile din Lecția 4 se terminau cu un json.dumps().

Puncte cheie

  • Executarea funcției are loc la nivelul clientului, în codul dumneavoastră—niciodată de către model
  • Rezultatul este trimis înapoi într-un mesaj cu rolul "tool" și cu tool_call_id corespunzător
  • Câmpul content al mesajului tool trebuie să fie un șir de caractere (un șir JSON)
  • După trimiterea rezultatului, apelați din nou chat.complete() pentru ca modelul să poată formula răspunsul final
  • Verificați întotdeauna dacă funcția solicitată există în dicționarul dumneavoastră de dispecerizare