Agens alapú kódolás eszközhívásokkal
Ezen az oldalon
Lecke frissítve: 2026. november 2. Az eredeti példák a Devstral modellt használták, amelyet 2026. július 31-én eltávolítottak az API-ból. Most a Mistral Small 4 (
mistral-small-2603) modellt használják, és az agens hurok a Mistral dokumentációjának modelljét követi (a válaszban szereplő összes eszközhívást feldolgozzák a végső válaszig). Forrás: Function calling.
Mi az agens alapú kódolás?
Az agens alapú kódolás megváltoztatja annak a természetét, amit a modelltől kérsz. Ahelyett, hogy egyesével kérnél egy kódrészletet, majd egy másikat, aztán egy harmadikat, és te illesztenéd őket össze, egy teljes feladatot bízol rá. A modell úgy oldja meg, hogy egymás után láncolja a lépéseket: felderítés, tervezés, implementáció és ellenőrzés. Te maradsz a döntéshozó abban, hogy mit kell csinálni, de abbahagyod minden egyes lépés mikro-menedzselését.
A Devstral modelleket erre a munkafolyamatra építették; a jelenlegi általános célú modellek, élükön a Mistral Small 4-gyel, eszközhívásokon keresztül kezelik ezt. Egy ágens nem csupán válaszol egy kérdésre; cselekszik a tárházban (repository).
Az agens ciklus
1. fázis — Megértés
Az ágens mindig azzal kezdi, hogy tájékozódik. Elolvassa a mappa- és fájlstruktúrát, azonosítja a kért feladathoz releváns fájlokat, feltérképezi a modulok közötti függőségeket, hogy lássa, egy változtatást mi érinthet, és feljegyzi a meglévő konvenciókat – elnevezési szokások, tesztek szervezése és ismétlődő mintázatok. Ez a fázis terméketlennek tűnhet, mert nem ír kódot, mégis ez határozza meg, hogy a resulting kód a tiédre fog-e hasonlítani, vagy egy idegenére.
2. fázis — Tervezés
Mielőtt egyetlen sort is írna, az ágens kidolgoz egy tervet. A feladatot rendezett alfeladatokra bontja, megkülönbözteti a módosítandó fájlokat a létrehozandóktól, előre látja a mellékhatásokat és a regressziós kockázatokat, valamint rögzíti a technikai megközelítést. Itt a legolcsóbb a beavatkozásod: egy terv kijavítása harminc másodperc; tíz már megírt fájl kijavítása sokkal tovább tart.
3. fázis — Végrehajtás
Az implementáció lépésről lépésre bontja ki a tervet. Az ágens szerkeszti a meglévő fájlokat, újakat hoz létre, ha a struktúra megköveteli, frissíti a változtatásai miatt eltolódó importokat és függőségeket, valamint útközben igazítja a konfigurációs fájlokat. E változtatások konzisztenciája pontosan az, amit egy kiegészítő modell (completion model) nem tud garantálni.
4. fázis — Ellenőrzés
Végül jön a bizonyíték, hogy a munka megállja a helyét. Az ágens lefuttatja a meglévő tesztsorozatot, új teszteket ír az imént hozzáadott kódhoz, biztosítja, hogy a build sikeres legyen, és átnézi a saját diffjét hibák vagy idegen módosítások után. Egy ágens, amely kihagyja ezt a fázist, hihető kódot produkál, nem pedig helyeset.
Kidolgozott példa: egy hiba javítása
Tegyük fel, hogy azt mondod az ágensnek: „A felhasználók 500-as hibát kapnak, amikor olyan űrlapot küldenek be, amelynek az e-mail címe ’+’ jelet tartalmaz.“ A ciklus ekkor ezt az alakot ölti:
1. MEGÉRTÉS
-> Fájlok keresése az űrlappal kapcsolatban (keresés az „email“ szóra a kódban)
-> A beküldést kezelő vezérlő (controller) elolvasása
-> Az e-mail érvényesítő függvény elolvasása
-> A '+' jelet elutasító regex azonosítása
2. TERVEZÉS
-> Az érvényesítő regex módosítása a '+' jel elfogadására
-> Egységteszt hozzáadása a '+' jelet tartalmazó e-mailekhez
-> Annak ellenőrzése, hogy a kód más része nem szűri-e ki a '+' jelet
3. VÉGREHAJTÁS
-> A src/validators/email.py módosítása: a regex minta javítása
-> A tests/test_email_validation.py létrehozása: '+' jeles esetek hozzáadása
-> A src/controllers/form.py módosítása: naplózási bejegyzés hozzáadása hibakereséshez
4. ELLENŐRZÉS
-> A pytest futtatása -> minden teszt sikeres
-> A diff ellenőrzése -> a változtatások konzisztensek és minimálisak
Figyeld meg a terv harmadik sorát: az ágens nemcsak ott javít, ahol a hiba megnyilvánul; ellenőrzi, hogy máshol nincs-e olyan szűrő, amely elutasítaná a karaktert. Ez a kiváltó ok keresése, nem csupán a tüneté, ami megkülönbözteti az agens alapú javítást a foltszerű javítástól.
Eszközhasználat a gyakorlatban
Az ágens függvényhívásokon keresztül cselekszik a környezetében. A kérésben deklarálod a rendelkezésre álló eszközöket, beleértve a nevüket, leírásukat és paramétersémájukat; a modell választja ki, melyiket hívja meg és milyen argumentumokkal.
# Példa egy agens alapú beszélgetésre
messages = [
{
"role": "user",
"content": "Adj hozzá erős jelszó érvényesítést a hitelesítési modulhoz."
}
]
tools = [
{
"type": "function",
"function": {
"name": "read_file",
"description": "Egy projektfájl tartalmának beolvasása",
"parameters": {
"type": "object",
"properties": {
"path": {"type": "string", "description": "Fájl elérési útja"}
},
"required": ["path"]
}
}
},
{
"type": "function",
"function": {
"name": "write_file",
"description": "Egy projektfájl írása vagy módosítása",
"parameters": {
"type": "object",
"properties": {
"path": {"type": "string"},
"content": {"type": "string"}
},
"required": ["path", "content"]
}
}
},
{
"type": "function",
"function": {
"name": "run_command",
"description": "Egy shell parancs végrehajtása",
"parameters": {
"type": "object",
"properties": {
"command": {"type": "string"}
},
"required": ["command"]
}
}
}
]
response = client.chat.complete(
model="mistral-small-2603",
messages=messages,
tools=tools,
tool_choice="auto", # alapértelmezett érték: a modell dönti el, hívjon-e eszközt
)
Ennél a kérésnél a tipikus sorozat a read_file("src/auth/validators.py") hívással kezdődik a meglévő kód megértéséhez, folytatódik a read_file("tests/test_auth.py") hívással, hogy lássa a jelenlegi tesztek formátumát, majd az írási szakasz következik: write_file("src/auth/validators.py", ...) a hozzáadott érvényesítési szabállyal, write_file("tests/test_auth.py", ...) az új esetekkel, és végül a run_command("pytest tests/test_auth.py") az ellenőrzéshez. A sorrend számít: azzal, hogy mindkét fájlt megnyitja, mielőtt egyetlen karaktert is érintene, az ágens felveszi a te konvencióidat és reprodukálja azokat, ahelyett, hogy máshonnan látottakat importálna.
Több körös agens hurok
Ebből semmi sem történik egyetlen hívás alatt. Az agens alapú kódolás szíve a több körös hurok: a modell javasol egy műveletet, a te kódod végrehajtja azt, és te visszaküldöd az eredményt, hogy az dönthessen a következő lépésről. Te tartod kézben a tényleges végrehajtást, ami egyben a biztonsági korlátként is szolgál.
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): # biztonsági korlát: egy ágens soha nem loopolhat végtelenül
tool_calls = response.choices[0].message.tool_calls
if not tool_calls:
break # nincs több eszközhívás: megérkezett a végső válasz
for tool_call in tool_calls: # egy válasz több hívást is tartalmazhat
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)
Három részlet számít. Az ágens üzenete és minden egyes eszköz eredménye visszakerül a történetbe, párosítva a tool_call_id alapján: ha bármelyiket kihagyod, az ágens elveszíti a fonalat, és ugyanazokat az eszközöket hívja meg ismétlődően. Egyetlen válasz több eszközhívást is tartalmazhat, mivel a párhuzamos hívások alapértelmezetten engedélyezettek (a parallel_tool_calls=False tiltja őket): mindet dolgozd fel. Végül pedig korlátozd a körök számát, és egy ember hagyja jóvá a shell parancsokat és a fájlírásokat: egy ágens, amely mindent végrehajt, amit javasol, kockázatot jelent, nem időmegtakarítást.
Főbb megállapítások
- Az agens alapú kódolás egy ciklust követ: megértés, tervezés, végrehajtás, ellenőrzés
- Az ágens eszközhívásokon keresztül (
tools,tool_choice) cselekszik a tárházban - A több körös hurok lehetővé teszi az ágens számára, hogy iteráljon a teljes megoldásig
- Az ágens konzisztensen módosít több fájlt egyetlen feladat keretében
- Az ellenőrzési fázis (tesztek, build) elengedhetetlen a megbízhatósághoz