Ugrás a főtartalomra
Magyar— Nyelv kiválasztása
Menü

Agens alapú kódolás eszközhívásokkal

6. lecke 14 közül Frissítve 2026. november 2. Fejlesztő
Ezen az oldalon
  1. Mi az agens alapú kódolás?
  2. Az agens ciklus
  3. Kidolgozott példa: egy hiba javítása
  4. Eszközhasználat a gyakorlatban
  5. Több körös agens hurok
  6. Főbb megállapítások

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