Agentic Coding s voláním nástrojů
Na této stránce
Lekce aktualizována 2. listopadu 2026. Původní příklady používaly model Devstral, který byl 31. července 2026 odstraněn z API. Nyní využívají Mistral Small 4 (
mistral-small-2603) a agens smyčka postupuje podle modelu dokumentace Mistral (všechna volání nástrojů v odpovědi jsou zpracována až do finální odpovědi). Zdroj: Function calling.
Co je agentic coding?
Agentic coding mění podstatu toho, co od modelu požaduješ. Místo toho, abys si vyžádal jeden úsek kódu, pak druhý, pak třetí a sám je skládal dohromady, zadáš kompletní úkol. Model jej vyřeší tak, že sám řetězí jednotlivé kroky: průzkum, plánování, implementace a ověření. Ty zůstáváš rozhodovatelem v otázce, co je třeba udělat, ale přestaneš mikromanažovat každý jednotlivý tah.
Modely Devstral byly pro tento pracovní postup vytvořeny; současné modely pro obecné účely, v čele s Mistral Small 4, jej zvládají prostřednictvím volání nástrojů. Agent nejen odpovídá na otázku; působí přímo v repozitáři.
Cyklus agenta
Fáze 1 — Porozumění
Agent vždy začíná tím, že si ujasní situaci. Čte strukturu složek a souborů, identifikuje soubory relevantní pro požadovaný úkol, sleduje závislosti mezi moduly, aby viděl, co by změna mohla ovlivnit, a zaznamenává stávající konvence – pojmenování, organizaci testů a opakující se vzory. Tato fáze vypadá neproduktivně, protože nepíše žádný kód, přesto určuje, zda výsledný kód bude vypadat jako tvůj, nebo jako dílo cizince.
Fáze 2 — Plánování
Než napíše jedinou řádku, agent formuluje plán. Rozdělí úkol na uspořádané dílčí úkoly, rozliší soubory k úpravě od těch, které je třeba vytvořit, anticipuje vedlejší efekty a rizika regrese a ustálí technický přístup. Právě zde je tvůj zásah nejlevnější: oprava plánu trvá třicet sekund; oprava deseti souborů, které jsi již napsal, trvá mnohem déle.
Fáze 3 — Exekuce
Implementace krok za krokem rozvíjí plán. Agent upravuje existující soubory, vytváří nové, pokud to struktura vyžaduje, aktualizuje importy a závislosti posunuté jeho změnami a cestou upravuje konfigurační soubory. Konzistence napříč těmito změnami je přesně to, co model pro doplňování kódu nedokáže zaručit.
Fáze 4 — Ověření
Nakonec přichází důkaz, že práce obstojí. Agent spustí existující sadu testů, napíše nové testy pro právě přidaný kód, zajistí úspěšné sestavení (build) a zkontroluje vlastní diff na chyby nebo nechtěné úpravy. Agent, který tuto fázi přeskočí, produkuje kód, který vypadá věrohodně, nikoliv však kód správný.
Pracovní příklad: oprava chyby
Předpokládejme, že agentovi řekneš: „Uživatelé dostávají chybu 500, když odešlou formulář s e-mailem obsahujícím ’+’.“ Cyklus pak proběhne takto:
1. POROZUMĚNÍ
-> Vyhledat soubory související s formulářem (hledat "email" v kódu)
-> Přečíst controller zpracovávající odeslání
-> Přečíst funkci pro validaci e-mailu
-> Identifikovat regulární výraz odmítající '+'
2. PLÁNOVÁNÍ
-> Upravit validační regex tak, aby přijímal '+'
-> Přidat unit test pro e-maily s '+'
-> Ověřit, že žádná jiná část kódu filtr '+' neodmítá
3. EXEKUCE
-> Upravit src/validators/email.py: opravit vzor regexu
-> Vytvořit tests/test_email_validation.py: přidat případy s '+'
-> Upravit src/controllers/form.py: přidat log pro ladění
4. OVĚŘENÍ
-> Spustit pytest -> všechny testy projdou
-> Zkontrolovat diff -> změny jsou konzistentní a minimální
Všimni si třetího řádku plánu: agent nejen opraví místo, kde se chyba projevuje, ale zkontroluje, zda žádný jiný filtr tento znak jinde neodmítá. Právě toto hledání kořenové příčiny, nikoliv jen symptomu, odlišuje agens opravu od rychlé záplaty.
Používání nástrojů v praxi
Agent působí na své prostředí prostřednictvím volání funkcí. V požadavku deklaruješ dostupné nástroje, včetně jejich názvu, popisu a schématu parametrů; model si vybírá, které z nich zavolat a s jakými argumenty.
# Příklad agens konverzace
messages = [
{
"role": "user",
"content": "Přidej silnou validaci hesla do auth modulu."
}
]
tools = [
{
"type": "function",
"function": {
"name": "read_file",
"description": "Přečte obsah souboru projektu",
"parameters": {
"type": "object",
"properties": {
"path": {"type": "string", "description": "Cesta k souboru"}
},
"required": ["path"]
}
}
},
{
"type": "function",
"function": {
"name": "write_file",
"description": "Napíše nebo upraví soubor projektu",
"parameters": {
"type": "object",
"properties": {
"path": {"type": "string"},
"content": {"type": "string"}
},
"required": ["path", "content"]
}
}
},
{
"type": "function",
"function": {
"name": "run_command",
"description": "Spustí pří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", # výchozí hodnota: model se rozhodne, zda nástroj zavolat
)
Pro tento požadavek typická sekvence začíná read_file("src/auth/validators.py"), aby pochopil existující kód, pokračuje read_file("tests/test_auth.py"), aby viděl formát současných testů, a poté přechází k zápisu: write_file("src/auth/validators.py", ...) s přidaným validačním pravidlem, write_file("tests/test_auth.py", ...) s novými případy a nakonec run_command("pytest tests/test_auth.py") pro ověření. Na pořadí záleží: tím, že agent otevře oba soubory dříve, než změní jediný znak, převezme tvé konvence a reprodukuje je, místo aby importoval ty, které viděl jinde.
Vícenásobná agens smyčka
Nic z toho se neodehraje v jediném volání. Srdcem agentic codingu je vícekolová smyčka: model navrhne akci, tvůj kód ji provede a ty odešleš výsledek zpět, aby se mohl rozhodnout pro další krok. Kontrolu nad skutečnou exekucí si ponecháváš ty, což zároveň slouží jako tvoje bezpečnostní pojistka.
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): # pojistka: agent se nesmí nikdy točit donekonečna
tool_calls = response.choices[0].message.tool_calls
if not tool_calls:
break # žádná další volání nástrojů: dorazila finální odpověď
for tool_call in tool_calls: # odpověď může obsahovat více volání
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)
Záleží na třech detailech. Zpráva agenta a každý výsledek nástroje jsou znovu vloženy do historie, spárovány pomocí tool_call_id: vynechej některý z nich a agent ztratí vlákno, čímž bude v cyklu znovu a znovu volat stejné nástroje. Jediná odpověď může obsahovat více volání nástrojů, protože paralelní volání jsou ve výchozím nastavení povolena (parallel_tool_calls=False je zakazuje): zpracuj je všechna. Nakonec omez počet kol a nech člověka validovat příkazy shellu a zápisy do souborů: agent, který provede vše, co navrhne, je rizikem, nikoliv úsporou času.
Klíčové poznatky
- Agentic coding následuje cyklus: porozumět, naplánovat, provést, ověřit
- Agent působí na repozitář prostřednictvím volání nástrojů (
tools,tool_choice) - Vícenásobná smyčka umožňuje agentovi iterovat až do úplného vyřešení
- Agent konzistentně upravuje více souborů v rámci jednoho úkolu
- Fáze ověření (testy, build) je pro spolehlivost nezbytná