Programarea agentivă cu apeluri de instrumente
Pe această pagină
Lecție actualizată la 2 noiembrie 2026. Exemplele originale foloseau Devstral, care a fost eliminat din API la 31 iulie 2026. Acestea utilizează acum Mistral Small 4 (
mistral-small-2603), iar bucla agentivă urmează modelul din documentația Mistral (toate apelurile de instrumente dintr-un răspuns sunt procesate până la obținerea răspunsului final). Sursă: Function calling.
Ce este programarea agentivă?
Programarea agentivă schimbă natura a ceea ce cereți modelului să facă. În loc să solicitați un fragment de cod, apoi altul, apoi un al treilea, și să le asamblați dumneavoastră, atribuiți o sarcină completă. Modelul o rezolvă înlănțuind pașii de unul singur: explorare, planificare, implementare și verificare. Dumneavoastră rămâneți factorul de decizie privind ce trebuie făcut, dar încetați să mai micromanageriați fiecare mișcare.
Modelele Devstral au fost construite pentru acest flux de lucru; modelele actuale de uz general, conduse de Mistral Small 4, gestionează acest proces prin apeluri de instrumente. Un agent nu doar răspunde la o întrebare; el acționează asupra repository-ului.
Ciclul agentiv
Faza 1 — Înțelegere
Agentul începe întotdeauna prin a se orienta. Citește structura dosarelor și a fișierelor, identifică fișierele relevante pentru sarcina solicitată, urmărește dependențele dintre module pentru a vedea ce ar putea afecta o modificare și notează convențiile existente – denumiri, organizarea testelor și tiparele recurente. Această fază pare neproductivă deoarece nu scrie niciun cod, totuși ea determină dacă codul rezultat va arăta ca al dumneavoastră sau ca al unui străin.
Faza 2 — Planificare
Înainte de a scrie o singură linie, agentul formulează un plan. Descompune sarcina în sub-sarcini ordonate, distinge fișierele de modificat de cele de creat, anticipează efectele secundare și riscurile de regresie și se decide asupra unei abordări tehnice. Acesta este momentul în care intervenția dumneavoastră costă cel mai puțin: corectarea unui plan durează treizeci de secunde; corectarea a zece fișiere pe care le-ați scris deja durează mult mai mult.
Faza 3 — Executare
Implementarea desfășoară planul pas cu pas. Agentul editează fișiere existente, creează altele noi atunci când structura o cere, actualizează importurile și dependențele mutate de modificările sale și ajustează fișierele de configurare pe parcurs. Coerența acestor modificări este exact ceea ce un model de completare nu poate garanta.
Faza 4 — Verificare
În final vine dovada că lucrarea rezistă. Agentul rulează suita de teste existentă, scrie teste noi pentru codul tocmai adăugat, se asigură că build-ul reușește și își revizuiește propriul diff pentru erori sau modificări rătăcite. Un agent care sare peste această fază produce cod plauzibil, nu cod corect.
Exemplu practic: remedierea unui bug
Să presupunem că îi spuneți agentului: „Utilizatorii primesc o eroare 500 când trimit un formular cu un e-mail care conține un ’+’.“ Ciclul ia apoi această formă:
1. ÎNȚELEGERE
-> Caută fișiere legate de formular (caută „email“ în cod)
-> Citește controllerul care gestionează submit-ul
-> Citește funcția de validare a e-mailului
-> Identifică regex-ul care respinge '+'
2. PLANIFICARE
-> Modifică regex-ul de validare pentru a accepta '+'
-> Adaugă un test unitar pentru e-mailurile cu '+'
-> Verifică dacă nicio altă parte a codului nu filtrează '+'
3. EXECUȚIE
-> Modifică src/validators/email.py: repară tiparul regex
-> Creează tests/test_email_validation.py: adaugă cazuri cu '+'
-> Modifică src/controllers/form.py: adaugă un log pentru depanare
4. VERIFICARE
-> Rulează pytest -> toate testele trec
-> Verifică diff -> modificările sunt coerente și minime
Observați a treia linie a planului: agentul nu doar repară locul unde se manifestă bug-ul; verifică faptul că niciun alt filtru nu respinge caracterul în altă parte. Această căutare a cauzei rădăcină, nu doar a simptomului, este ceea ce distinge o remediere agentivă de un plasture localizat.
Utilizarea instrumentelor în practică
Agentul acționează asupra mediului său prin apeluri de funcții. Declarați instrumentele disponibile în cerere, inclusiv numele, descrierea și schema parametrilor acestora; modelul alege pe care să le apeleze și cu ce argumente.
# Exemplu de conversație agentivă
messages = [
{
"role": "user",
"content": "Adaugă validarea parolelor puternice în modulul de auth."
}
]
tools = [
{
"type": "function",
"function": {
"name": "read_file",
"description": "Citește conținutul unui fișier din proiect",
"parameters": {
"type": "object",
"properties": {
"path": {"type": "string", "description": "Calea fișierului"}
},
"required": ["path"]
}
}
},
{
"type": "function",
"function": {
"name": "write_file",
"description": "Scrie sau modifică un fișier din proiect",
"parameters": {
"type": "object",
"properties": {
"path": {"type": "string"},
"content": {"type": "string"}
},
"required": ["path", "content"]
}
}
},
{
"type": "function",
"function": {
"name": "run_command",
"description": "Execută o comandă shell",
"parameters": {
"type": "object",
"properties": {
"command": {"type": "string"}
},
"required": ["command"]
}
}
}
]
response = client.chat.complete(
model="mistral-small-2603",
messages=messages,
tools=tools,
tool_choice="auto", # valoare implicită: modelul decide dacă să apeleze un instrument
)
Pentru această cerere, secvența tipică începe cu read_file("src/auth/validators.py") pentru a înțelege codul existent, continuă cu read_file("tests/test_auth.py") pentru a vedea formatul testelor curente, apoi trece la scriere: write_file("src/auth/validators.py", ...) cu regula de validare adăugată, write_file("tests/test_auth.py", ...) cu noile cazuri și, în final, run_command("pytest tests/test_auth.py") pentru verificare. Ordinea contează: deschizând ambele fișiere înainte de a atinge un singur caracter, agentul preia convențiile dumneavoastră și le reproduce, în loc să importe unele pe care le-a văzut în altă parte.
Bucla agentivă multi-tur
Nimic din toate acestea nu se întâmplă într-un singur apel. Inima programării agentive este bucla multi-tur: modelul propune o acțiune, codul dumneavoastră o execută, iar dumneavoastră trimiteți rezultatul înapoi pentru ca acesta să poată decide următorul pas. Păstrați controlul execuției reale, ceea ce servește, de asemenea, drept gardă de siguranță.
import json
TOOLS = {"read_file": read_file, "write_file": write_file, "run_command": run_command}
response = client.chat.complete(model="mistral-small-2603", messages=messages, tools=tools)
messages.append(response.choices[0].message)
for _ in range(30): # gardă de siguranță: un agent nu trebuie să facă buclă la infinit
tool_calls = response.choices[0].message.tool_calls
if not tool_calls:
break # nu mai sunt apeluri de instrumente: răspunsul final a sosit
for tool_call in tool_calls: # un răspuns poate conține multiple apeluri
name = tool_call.function.name
arguments = json.loads(tool_call.function.arguments)
result = TOOLS[name](**arguments)
messages.append({
"role": "tool",
"name": name,
"content": str(result),
"tool_call_id": tool_call.id,
})
response = client.chat.complete(model="mistral-small-2603", messages=messages, tools=tools)
messages.append(response.choices[0].message)
print(response.choices[0].message.content)
Trei detalii contează. Mesajul agentului și fiecare rezultat al instrumentului sunt reinjectate în istoric, împerecheate prin tool_call_id: omiteți unul dintre ele și agentul pierde firul, reamintind aceleași instrumente într-o buclă. Un singur răspuns poate conține multiple apeluri de instrumente, deoarece apelurile paralele sunt permise implicit (parallel_tool_calls=False le interzice): procesați-le pe toate. În final, limitați numărul de tururi și faceți ca un om să valideze comenzile shell și scrierile de fișiere: un agent care execută tot ce propune este un risc, nu un economisitor de timp.
Puncte cheie
- Programarea agentivă urmează un ciclu: înțelegere, planificare, execuție, verificare
- Agentul acționează asupra repository-ului prin apeluri de instrumente (
tools,tool_choice) - Bucla multi-tur permite agentului să itereze până la rezolvarea completă
- Agentul modifică multiple fișiere în mod coerent într-o singură sarcină
- Faza de verificare (teste, build) este esențială pentru fiabilitate