Pereiti prie pagrindinio turinio
Lietuvių— Pasirinkite kalbą
Meniu

Programavimas su agentais ir įrankių iškvietimais

Paskaita 6 iš 14 Atnaujinta 2026 m. lapkričio 2 d. Kūrėjas
Šiame puslapyje
  1. Kas yra programavimas su agentais?
  2. Agentinis ciklas
  3. Pavyzdys: klaidos taisymas
  4. Įrankių naudojimas praktikoje
  5. Daugkartinis agentinis ciklas
  6. Svarbiausi punktai

Pamoka atnaujinta 2026 m. lapkričio 2 d. Originaliuose pavyzdžiuose naudotas Devstral, kuris buvo pašalintas iš API 2026 m. liepos 31 d. Dabar naudojami Mistral Small 4 (mistral-small-2603), o agentinė kilpa laikosi Mistral dokumentacijos modelio (visi atsakyme esantys įrankių iškvietimai apdorojami iki galutinio atsakymo). Šaltinis: Function calling.

Kas yra programavimas su agentais?

Programavimas su agentais keičia tai, ko prašai modelio. Užuot prašęs vieno kodo fragmento, tada kito, tada trečio ir pats juos sujungęs, tu priskiri visą užduotį. Modelis ją išsprendžia pats nuosekliai atlikdamas veiksmus: tyrinėjimą, planavimą, įgyvendinimą ir patikrinimą. Tu lieki sprendimų priėmėjas dėl to, ką reikia padaryti, bet nustoji kontroliuoti kiekvieną žingsnį.

Devstral modeliai buvo sukurti būtent šiam darbo eigai; dabartiniai bendrosios paskirties modeliai, kuriems vadovauja Mistral Small 4, tai valdo naudodami įrankių iškvietimus. Agentas ne tik atsako į klausimą; jis veikia saugykloje.

Agentinis ciklas

1 etapas — Supratimas

Agentas visada pradeda nuo orientacijos įsitvirtinimo. Jis nuskaitysa aplankų ir failų struktūrą, identifikuoja su prašoma užduotimi susijusius failus, atseka priklausomybes tarp modulių, kad pamatytų, ką gali paveikti pakeitimas, ir pastebi esamas konvencijas – pavadinimų skyrimą, testų organizavimą ir pasikartojančius šablonus. Šis etapas atrodo neproduktyvus, nes jame nerašomas joks kodas, tačiau jis lemia, ar gautas kodas atrodys kaip tavo, ar kaip svetimo žmogaus.

2 etapas — Planavimas

Prieš rašydamas bent vieną eilutę, agentas suformuluoja planą. Jis suskaido užduotį į tvarkingus potikslius, atskiria failus, kuriuos reikia modifikuoti, nuo tų, kuriuos reikia sukurti, numato šalutinius poveikius ir regresijos rizikas bei pasirenka techninį požiūrį. Būtent čia tavo įsikišimas kainuoja mažiausiai: plano taisymas trunka trisdešimt sekundžių; dešimties jau parašytų failų taisymas užtrunka daug ilgiau.

3 etapas — Vykdymas

Įgyvendinimas žingsnis po žingsnio atskleidžia planą. Agentas redaguoja esamus failus, kuria naujus, kai to reikalauja struktūra, atnaujina importus ir priklausomybes, pasislinkusias dėl jo pakeitimų, ir pakeliui koreguoja konfigūracijos failus. Nuoseklumas šiuose pakeitimuose yra būtent tai, ko papildymo modelis negali garantuoti.

4 etapas — Patikrinimas

Galiausiai ateina įrodymas, kad darbas atlaiko apkrovą. Agentas paleidžia esamą testų rinkinį, rašo naujus testus ką tik pridėtam kodui, užtikrina, kad surinkimas (build) pavyktų, ir peržiūri savo skirtumus (diff), ieškodamas klaidų ar atsitiktinių pakeitimų. Agentas, praleidžiantis šį etapą, sukuria tikėtiną kodą, o ne teisingą kodą.

Pavyzdys: klaidos taisymas

Tarkime, sakai agentui: „Vartotojai gauna 500 klaidą, kai pateikia formą su el. pašto adresu, kuriame yra ’+’.“ Tuomet ciklas įgauna šią formą:

1. SUPRATIMAS
   -> Ieškoti su forma susijusių failų (ieškoti „email“ kode)
   -> Nuskaityti valdiklį, apdorojantį pateikimą
   -> Nuskaityti el. pašto validavimo funkciją
   -> Identifikuoti reguliarųjį reiškinį, atmetantį '+'

2. PLANAVIMAS
   -> Modifikuoti validavimo reguliarųjį reiškinį, kad priimtų '+'
   -> Pridėti vienetinį testą el. pašto adresams su '+'
   -> Patikrinti, ar jokia kita kodo dalis nefiltruoja '+'

3. VYKDYMAS
   -> Modifikuoti src/validators/email.py: pataisyti reguliarųjį reiškinį
   -> Sukurti tests/test_email_validation.py: pridėti atvejus su '+'
   -> Modifikuoti src/controllers/form.py: pridėti žurnalą derinimui

4. PATIKRINIMAS
   -> Paleisti pytest -> visi testai sėkmingi
   -> Patikrinti diff -> pakeitimai nuoseklūs ir minimalūs

Atkreipk dėmesį į trečią plano eilutę: agentas ne tik taiso vietą, kur pasireiškia klaida; jis patikrina, ar joks kitas filtras neatmeta šio simbolio kitur. Būtent šis priežasties, o ne tik simptomo, ieškojimas skiria agentinį taisymą nuo laikino lopato.

Įrankių naudojimas praktikoje

Agentas veikia savo aplinką naudodamas funkcijų iškvietimus. Užklausoje nurodai turimus įrankius, įskaitant jų pavadinimą, aprašymą ir parametrų schemą; modelis pasirenka, kuriuos iškvieti ir su kokiais argumentais.

# Agentinio pokalbio pavyzdys
messages = [
    {
        "role": "user",
        "content": "Add strong password validation to the auth module."
    }
]

tools = [
    {
        "type": "function",
        "function": {
            "name": "read_file",
            "description": "Read the content of a project file",
            "parameters": {
                "type": "object",
                "properties": {
                    "path": {"type": "string", "description": "File path"}
                },
                "required": ["path"]
            }
        }
    },
    {
        "type": "function",
        "function": {
            "name": "write_file",
            "description": "Write or modify a project file",
            "parameters": {
                "type": "object",
                "properties": {
                    "path": {"type": "string"},
                    "content": {"type": "string"}
                },
                "required": ["path", "content"]
            }
        }
    },
    {
        "type": "function",
        "function": {
            "name": "run_command",
            "description": "Execute a shell command",
            "parameters": {
                "type": "object",
                "properties": {
                    "command": {"type": "string"}
                },
                "required": ["command"]
            }
        }
    }
]

response = client.chat.complete(
    model="mistral-small-2603",
    messages=messages,
    tools=tools,
    tool_choice="auto",   # numatytoji reikšmė: modelis pats sprendžia, ar kviesti įrankį
)

Šiam prašymui tipinė seka prasideda nuo read_file("src/auth/validators.py"), kad suprastų esamą kodą, tęsiasi su read_file("tests/test_auth.py"), kad pamatytų dabartinių testų formatą, tada pereina prie rašymo: write_file("src/auth/validators.py", ...) su pridėta validavimo taisykle, write_file("tests/test_auth.py", ...) su naujais atvejais ir galiausiai run_command("pytest tests/test_auth.py") patikrinimui. Tvarka svarbi: atidaręs abu failus prieš liesdamas bent vieną simbolį, agentas perima tavo konvencijas ir jas atkuria, užuot importavęs tas, kurias matė kitur.

Daugkartinis agentinis ciklas

Nieko iš šio neįvyksta vienu iškvietimu. Programavimo su agentais širdis yra daugkartinis ciklas: modelis siūlo veiksmą, tavo kodas jį įvykdo, ir tu siunti rezultatą atgal, kad jis galėtų nuspręsti dėl kito žingsnio. Tu išlaikai kontrolę над faktiniu vykdymu, kas taip pat tarnauja kaip tavo saugos ribotuvas.

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):   # ribotuvas: agentas niekada neturi sukasi begalinėje kilpoje
    tool_calls = response.choices[0].message.tool_calls
    if not tool_calls:
        break         # daugiau nėra įrankių iškvietimų: galutinis atsakymas gautas
    for tool_call in tool_calls:   # atsakyme gali būti keli iškvietimai
        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)

Svarbūs trys detalės. Agento žinutė ir kiekvienas įrankio rezultas yra vėl įterpiami į istoriją, susieti pagal tool_call_id: praleidus kurį nors iš jų, agentas praranda siūlą ir kartojančiai kviečia tuos pačius įrankius. Viename atsakyme gali būti keli įrankių iškvietimai, nes lygiagretūs iškvietimai pagal nutylėjimą leidžiami (parallel_tool_calls=False juos draudžia): apdorok juos visus. Galiausiai, apribok ėjimų skaičių ir leisk žmogui patvirtinti shell komandas bei failų rašymą: agentas, vykdantis viską, ką siūlo, yra rizika, o ne laiko taupymo priemonė.

Svarbiausi punktai

  • Programavimas su agentais laikosi ciklo: suprasti, planuoti, vykdyti, patikrinti
  • Agentas veikia saugykloje naudodamas įrankių iškvietimus (tools, tool_choice)
  • Daugkartinis ciklas leidžia agentui iteruoti iki pilno išsprendimo
  • Agentas vienos užduoties metu nuosekliai modifikuoja kelis failus
  • Patikrinimo etapas (testai, surinkimas) yra būtinas patikimumui užtikrinti