Agentic Coding koos tööriistakutsetega
Sellel lehel
Tund uuendatud 2. novembril 2026. Algsed näited kasutasid Devstrali, mis eemaldati API-st 31. juulil 2026. Nüüd kasutatakse Mistral Small 4 (
mistral-small-2603) ja agentne tsükkel järgib Mistrali dokumentatsiooni mudelit (kõiki vastuses olevaid tööriistakutseid töödeldakse kuni lõpliku vastuseni). Allikas: Function calling.
Mis on agentne kodeerimine?
Agentne kodeerimine muudab seda, mida sa mudelilt tegelikult palud. Selle asemel, et küsida üht koodilõiku, siis teist, siis kolmandat ja need ise kokku liita, määrad sa tervikliku ülesande. Mudel lahendab selle, aheldades sammud ise: uurimine, planeerimine, teostus ja kontrollimine. Sina jääd otsustajaks selles, mida teha tuleb, kuid lõpetad iga liigutuse mikrohaldamise.
Devstrali mudelid loodi just selleks töövooks; praegused üldotstarbelised mudelid, mida juhib Mistral Small 4, haldavad seda tööriistakutsete kaudu. Agent ei vasta lihtsalt küsimusele; ta tegutseb repositooriumis.
Agentne tsükkel
1. faas — Mõistmine
Agent alustab alati orienteerumisega. Ta loeb kaustade ja failide struktuuri, tuvastab taotletud ülesandega seotud failid, jälgib moodulite vahelisi sõltuvusi, et näha, mida muudatus mõjutada võib, ja paneb kirja olemasolevad konventsioonid – nimetamine, testide korraldus ja korduvad mustrid. See faas võib tunduda viljatuna, kuna koodi ei kirjutata, kuid just see määrab, kas tulemus näeb välja nagu sinu oma või nagu võõra oma.
2. faas — Planeerimine
Enne esimese rea kirjutamist formuleerib agent plaani. Ta jagab ülesande järjestatud alamülesanneteks, eristab muudetavaid faile loodavatest, ennustab kõrvalmõjusid ja regressiooniriske ning lepib kokku tehnilises lähenemises. See on hetk, mil sinu sekkumine on kõige odavam: plaani parandamine võtab kolmkümmend sekundit; juba kirjutatud kümne faili parandamine võtab palju kauem aega.
3. faas — Teostus
Teostus viib plaani samm-sammult ellu. Agent redigeerib olemasolevaid faile, loob vajadusel uusi, uuendab importimisi ja sõltuvusi, mida tema muudatused nihutasid, ning kohandab tee peal konfiguratsioonifaile. Järjepidevus nende muudatuste vahel on täpselt see, mida täitmismudel (completion model) garanteerida ei suuda.
4. faas — Kontrollimine
Lõpuks tuleb tõestus, et töö peab vastu. Agent käivitab olemasoleva testikomplekti, kirjutab uued testid just lisatud koodile, veendub, et build õnnestub, ja vaatab oma diffi üle vigade või ekslike muudatuste osas. Agent, kes selle faasi vahele jätab, toodab usutavat, mitte korrektset koodi.
Läbitöötatud näide: vea parandamine
Oletame, et ütled agendile: „Kasutajad saavad 500 vea, kui nad esitavad vormi, mille meiliaadress sisaldab märki ’+’.“ Tsükkel võtab siis sellise kuju:
1. MÕISTMINE
-> Otsi vormiga seotud faile (otsi koodist „email“)
-> Loe esitamist haldavat kontrollerit
-> Loe meiliaadressi valideerimise funktsiooni
-> Tuvasta regex, mis lükkab '+' tagasi
2. PLANEERIMINE
-> Muuda valideerimise regexi, et see aktsepteeriks '+'
-> Lisa ühiktest meiliaadressidele, mis sisaldavad '+'
-> Veendu, et koodi ükski teine osa ei filtreeri '+' välja
3. TEOSTUS
-> Muuda src/validators/email.py: paranda regexi muster
-> Loo tests/test_email_validation.py: lisa juhtumid '+' märgiga
-> Muuda src/controllers/form.py: lisa logi silumiseks
4. KONTROLLIMINE
-> Käivita pytest -> kõik testid õnnestuvad
-> Kontrolli diffi -> muudatused on järjepidevad ja minimaalsed
Pane tähele plaani kolmandat rida: agent ei paranda lihtalt kohta, kus viga ilmneb; ta kontrollib, et ükski teine filter ei lükkaks seda märki mujal tagasi. Just põhjuse, mitte ainult sümptomi otsing eristab agentset parandust lapitööst.
Tööriistade kasutamine praktikas
Agent tegutseb oma keskkonnas funktsioonikutsete kaudu. Sa deklareerid päringus saadaolevad tööriistad, kaasates nende nime, kirjelduse ja parameetrite skeemi; mudel valib, milliseid neist kutsuda ja milliste argumentidega.
# Näide agentsest vestlusest
messages = [
{
"role": "user",
"content": "Lisa auth-moodulisse tugeva parooli valideerimine."
}
]
tools = [
{
"type": "function",
"function": {
"name": "read_file",
"description": "Loe projektifaili sisu",
"parameters": {
"type": "object",
"properties": {
"path": {"type": "string", "description": "Faili tee"}
},
"required": ["path"]
}
}
},
{
"type": "function",
"function": {
"name": "write_file",
"description": "Kirjuta või muuda projektifaili",
"parameters": {
"type": "object",
"properties": {
"path": {"type": "string"},
"content": {"type": "string"}
},
"required": ["path", "content"]
}
}
},
{
"type": "function",
"function": {
"name": "run_command",
"description": "Käivita shelli käsk",
"parameters": {
"type": "object",
"properties": {
"command": {"type": "string"}
},
"required": ["command"]
}
}
}
]
response = client.chat.complete(
model="mistral-small-2603",
messages=messages,
tools=tools,
tool_choice="auto", # vaikimisi väärtus: mudel otsustab, kas tööriista kutsuda
)
Selle päringu puhul algab tüüpiline jada read_file("src/auth/validators.py") kutsega, et mõista olemasolevat koodi, jätkub read_file("tests/test_auth.py") kutsega, et näha praeguste testide vormingut, ning liigub seejärel kirjutamisele: write_file("src/auth/validators.py", ...) koos lisatud valideerimisreegliga, write_file("tests/test_auth.py", ...) koos uute juhtumitega ja lõpuks run_command("pytest tests/test_auth.py") kontrollimiseks. Järjestus loeb: avades mõlemad failid enne ühegi tähemärgi puudutamist, võtab agent arvesse sinu konventsioone ja kordab neid, selle asemel et importida mujalt nähtuid.
Mitme vooruga agentne tsükkel
Midagi sellest ei toimu ühe kõnega. Agentse kodeerimise südameks on mitme vooruga tsükkel: mudel pakub välja tegevuse, sinu kood viib selle täide ja sa saadad tulemuse tagasi, et see saaks otsustada järgmise sammu üle. Sa hoiad tegelikku teostust enda kontrolli all, mis toimib ka sinu ohutuspiiranguna.
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): # ohutuspiirang: agent ei tohi kunagi lõputult tsüklisse jääda
tool_calls = response.choices[0].message.tool_calls
if not tool_calls:
break # tööriistakutseid pole enam: lõplik vastus on saabunud
for tool_call in tool_calls: # vastus võib sisaldada mitut kutset
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)
Kolm detaili on olulised. Agendi sõnum ja iga tööriista tulemus süstitakse ajalukku tagasi, paaris tool_call_id-ga: jäta kas või üks neist välja ja agent kaotab niidi, kutsudes samu tööriistu lõputus tsüklis. Üks vastus võib sisaldada mitut tööriistakutset, kuna paralleelsed kutsed on vaikimisi lubatud (parallel_tool_calls=False keelab need): töötle need kõik ära. Lõpuks piira voorude arvu ja lase inimesel valideerida shelli käske ja failikirjutusi: agent, kes viib täide kõik, mida ta ette paneb, on risk, mitte ajasääst.
Peamised punktid
- Agentne kodeerimine järgib tsüklit: mõista, planeeri, teosta, kontrolli
- Agent tegutseb repositooriumis tööriistakutsete kaudu (
tools,tool_choice) - Mitme vooruga tsükkel võimaldagendil iteratsiooni teha kuni täieliku lahenduseni
- Agent muudab ühe ülesande raames mitut faili järjepidevalt
- Kontrollimise faas (testid, build) on usaldusväärsuse jaoks hädavajalik