Agentné programovanie s volaním nástrojov
Na tejto strane
Lekcia aktualizovaná 2. novembra 2026. Pôvodné príklady používali model Devstral, ktorý bol z API odstránený 31. júla 2026. Teraz využívajú Mistral Small 4 (
mistral-small-2603) a agentná slučka sa riadi modelom z dokumentácie Mistral (všetky volania nástrojov v odpovedi sa spracujú až po získanie konečnej odpovede). Zdroj: Function calling.
Čo je agentné programovanie?
Agentné programovanie mení podstatu toho, čo od modelu požaduješ. Namiesto toho, aby si si pýtal jeden úryvok kódu, potom druhý, potom tretí a sám ich spájal, pridelíš modelu kompletnú úlohu. Model ju vyrieši tak, že sám prepojí jednotlivé kroky: prieskum, plánovanie, implementáciu a overenie. Ty zostávaš rozhodovacím orgánom pre to, čo treba urobiť, ale prestávaš mikromanažovať každý jeho pohyb.
Modely Devstral boli stavané práve pre tento pracovný postup; súčasné modely všeobecného určenia, na čele s Mistral Small 4, ho zvládajú prostredníctvom volania nástrojov. Agent nielenže odpovedá na otázku, ale koná priamo v repozitári.
Agentný cyklus
Fáza 1 — Porozumenie
Agent vždy začína tým, že si získa orientáciu. Prečíta si štruktúru priečinkov a súborov, identifikuje súbory relevantné pre požadovanú úlohu, vysleduje závislosti medzi modulmi, aby videl, čo by zmena mohla ovplyvniť, a zaznamená existujúce konvencie – pomenovanie, organizáciu testov a opakujúce sa vzorce. Táto fáza sa môže zdať neproduktívna, pretože sa pri nej nepíše žiadny kód, no práve ona rozhoduje o tom, či výsledný kód bude vyzerať ako tvoj, alebo ako dielo cudzieho človeka.
Fáza 2 — Plánovanie
Ešte pred napísaním jediného riadku kódu agent formuluje plán. Rozdelí úlohu na usporiadané podúlohy, rozlíši súbory, ktoré treba upraviť, od tých, ktoré treba vytvoriť, anticipuje vedľajšie účinky a riziká regresie a ustáli sa na technickom prístupe. Toto je moment, keď je tvoj zásah najlacnejší: oprava plánu tridsať sekúnd; oprava desiatich súborov, ktoré si už napísal, trvá oveľa dlhšie.
Fáza 3 — Exekúcia
Implementácia rozvíja plán krok za krokom. Agent upravuje existujúce súbory, vytvára nové, ak si to štruktúra vyžaduje, aktualizuje importy a závislosti posunuté jeho zmenami a cestou upravuje aj konfiguračné súbory. Konzistentnosť naprieč týmito zmenami je presne to, čo model dokončovania kódu nedokáže zaručiť.
Fáza 4 — Overenie
Nakoniec prichádza dôkaz, že práca obstojí. Agent spustí existujúcu sadu testov, napíše nové testy pre práve pridaný kód, zabezpečí, aby zostavenie (build) prebehlo úspešne, a skontroluje vlastný diff či neobsahuje chyby alebo nechcené úpravy. Agent, ktorý túto fázu preskočí, produkuje kód, ktorý vyzerá vierohodne, nie však kód, ktorý je správny.
Praktický príklad: oprava chyby
Predstav si, že povieš agentovi: „Používatelia dostávajú chybu 500, keď odošlú formulár s e-mailom obsahujúcim znak ’+’.“ Cyklus potom nadobudne túto formu:
1. POROZUMENIE
-> Vyhľadať súbory týkajúce sa formulára (hľadať "email" v kóde)
-> Prečítať controller spracovávajúci odoslanie
-> Prečítať funkciu na validáciu e-mailu
-> Identifikovať regulárny výraz, ktorý odmieta '+'
2. PLÁN
-> Upraviť validáciu regexu tak, aby akceptoval '+'
-> Pridať unit test pre e-maily s '+'
-> Overiť, či žiadna iná časť kódu neodfiltruje '+'
3. EXEKÚCIA
-> Upraviť src/validators/email.py: opraviť vzor regexu
-> Vytvoriť tests/test_email_validation.py: pridať prípady s '+'
-> Upraviť src/controllers/form.py: pridať logovanie pre ladenie
4. OVERENIE
-> Spustiť pytest -> všetky testy prejdú
-> Skontrolovať diff -> zmeny sú konzistentné a minimálne
Všimni si tretí riadok plánu: agent nielenže opraví miesto, kde sa chyba prejavuje, ale skontroluje, či žiadny iný filter neodmieta tento znak inde. Toto hľadanie príčiny, nielen symptómu, je tým, čo odlišuje agentnú opravu od rýchlej záplaty.
Používanie nástrojov v praxi
Agent koná vo svojom prostredí prostredníctvom volaní funkcií. V požiadavke deklaruješ dostupné nástroje vrátane ich názvu, popisu a schémy parametrov; model si vyberie, ktoré z nich zavolá a s akými argumentmi.
# Príklad agentnej konverzácie
messages = [
{
"role": "user",
"content": "Pridaj silnú validáciu hesla do modulu auth."
}
]
tools = [
{
"type": "function",
"function": {
"name": "read_file",
"description": "Prečíta obsah súboru projektu",
"parameters": {
"type": "object",
"properties": {
"path": {"type": "string", "description": "Cesta k súboru"}
},
"required": ["path"]
}
}
},
{
"type": "function",
"function": {
"name": "write_file",
"description": "Napíše alebo upraví súbor projektu",
"parameters": {
"type": "object",
"properties": {
"path": {"type": "string"},
"content": {"type": "string"}
},
"required": ["path", "content"]
}
}
},
{
"type": "function",
"function": {
"name": "run_command",
"description": "Vykoná príkaz shellu",
"parameters": {
"type": "object",
"properties": {
"command": {"type": "string"}
},
"required": ["command"]
}
}
}
]
response = client.chat.complete(
model="mistral-small-2603",
messages=messages,
tools=tools,
tool_choice="auto", # predvolená hodnota: model sa rozhodne, či zavolá nástroj
)
Pre túto požiadavku typická sekvencia začína príkazom read_file("src/auth/validators.py"), aby pochopil existujúci kód, pokračuje príkazom read_file("tests/test_auth.py"), aby videl formát aktuálnych testov, a potom prechádza k zapisovaniu: write_file("src/auth/validators.py", ...) s pridaným pravidlom validácie, write_file("tests/test_auth.py", ...) s novými prípadmi a nakoniec run_command("pytest tests/test_auth.py") na overenie. Poradie je dôležité: tým, že agent otvorí oba súbory skôr, než dotkne jediného znaku, osvojí si tvoje konvencie a reprodukuje ich, namiesto toho, aby importoval tie, ktoré videl inde.
Viackolová agentná slučka
Nič z toho sa neudeje v rámci jedného volania. Srdcom agentného programovania je viackolová slučka: model navrhne akciu, tvoj kód ju vykoná a ty mu pošleš výsledok späť, aby sa mohol rozhodnúť pre ďalší krok. Ty si zachovávaš kontrolu nad skutočnou exekúciou, čo zároveň slúži ako tvoja bezpečnostná poistka.
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): # poistka: agent sa nesmie nikdy točiť do nekonečna
tool_calls = response.choices[0].message.tool_calls
if not tool_calls:
break # žiadne ďalšie volania nástrojov: prišla konečná odpoveď
for tool_call in tool_calls: # odpoveď môže obsahovať viacero volaní
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)
Tri detaily sú kľúčové. Správa agenta aj každý výsledok nástroja sa znovu vkladajú do histórie, spárované pomocou tool_call_id: vynechaj niektorý z nich a agent stratí nit, pričom bude v slučke opakovať tie isté volania nástrojov. Jediná odpoveď môže obsahovať viacero volaní nástrojov, keďže paralelné volania sú predvolene povolené (parallel_tool_calls=False ich zakazuje): spracuj ich všetky. Nakoniec, obmedz počet kôl a nechaj človeka validovať príkazy shellu a zápisy do súborov: agent, ktorý vykoná všetko, čo navrhne, predstavuje riziko, nie úsporu času.
Kľúčové poznatky
- Agentné programovanie nasleduje cyklus: porozumieť, naplánovať, vykonať, overiť
- Agent koná v repozitári prostredníctvom volania nástrojov (
tools,tool_choice) - Viackolová slučka umožňuje agentovi iterovať až do úplného vyriešenia úlohy
- Agent konzistentne upravuje viacero súborov v rámci jednej úlohy
- Fáza overenia (testy, zostavenie) je nevyhnutná pre spoľahlivosť