Preskok na glavno vsebino
Slovenščina— Izberite jezik
Meni

Programiranje z agenti in klicanjem orodij

Lekcija 6 od 14 Posodobljeno 2. november 2026 Razvijalec
Na tej strani
  1. Kaj je programiranje z agenti?
  2. Agentski cikel
  3. Primer iz prakse: odpravljanje napake
  4. Uporaba orodij v praksi
  5. Večkratna agentska zanka
  6. Ključne ugotovitve

Lekcija posodobljena 2. novembra 2026. Prvotni primeri so uporabljali Devstral, ki je bil 31. julija 2026 odstranjen iz API-ja. Zdaj uporabljajo Mistral Small 4 (mistral-small-2603), agentska zanka pa sledi modelu dokumentacije Mistral (vsa klicanja orodij v odgovoru se obdelajo do končnega odgovora). Vir: Function calling.

Kaj je programiranje z agenti?

Programiranje z agenti spremeni naravo tega, kar od modela zahtevaš. Namesto da bi zahteval en izsek kode, nato drugega, nato tretjega in jih sam združil, dodeliš celotno nalogo. Model jo reši tako, da sam poveže korake: raziskovanje, načrtovanje, implementacijo in preverjanje. Ti ostaneš odločalec glede tega, kaj je treba storiti, prenehaš pa mikroupravljati vsak premik.

Modeli Devstral so bili zgrajeni za ta potek dela; trenutni modeli splošne namembnosti, ki jim vodi Mistral Small 4, to obvladajo prek klicanja orodij. Agent ne le odgovori na vprašanje; v repozitoriju deluje.

Agentski cikel

Faza 1 — Razumevanje

Agent se vedno začne z orientacijo. Prebere strukturo map in datotek, identificira datoteke, pomembne za zahtevano nalogo, izsledi odvisnosti med moduli, da vidi, kaj bi sprememba lahko vplivala, in zabeleži obstoječe konvencije – poimenovanje, organizacijo testov in ponavljajoče se vzorce. Ta faza videti neproduktivna, ker ne napiše nobene kode, vendar določa, ali bo nastala koda videti kot tvoja ali kot tujčeva.

Faza 2 — Načrtovanje

Preden napiše prvo vrstico, agent oblikuje načrt. Nalogo razčleni na urejene podnaloge, loči datoteke za spremembo od tistih za ustvarjanje, predvidi stranske učinke in tveganja za regresijo ter se odloči za tehnični pristop. To je trenutek, ko je tvoj poseg najcenejši: popravek načrta traja trideset sekund; popravek desetih datotek, ki si jih že napisal, traja veliko dlje.

Faza 3 — Izvedba

Implementacija korak za korakom razvije načrt. Agent ureja obstoječe datoteke, ustvarja nove, kadar to zahteva struktura, posodablja uvoze in odvisnosti, ki so se zaradi njegovih sprememb premaknile, ter sproti prilagaja konfiguracijske datoteke. Doslednost pri teh spremembah je ravno tisto, česar model za dopolnjevanje kode ne more zagotoviti.

Faza 4 — Preverjanje

Na koncu pride dokaz, da delo drži. Agent zažene obstoječi nabor testov, napiše nove teste za kodo, ki jo je pravkar dodal, zagotovi, da gradnja uspe, in pregleda svojo razliko (diff) glede napak ali neželenih sprememb. Agent, ki to fazo preskoči, proizvede verjetno kodo, ne pa pravilne kode.

Primer iz prakse: odpravljanje napake

Recimo, da agentu rečeš: „Uporabniki dobijo napako 500, ko oddajo obrazec z e-poštnim naslovom, ki vsebuje ’+’.” Cikel nato prevzame to obliko:

1. RAZUMEVANJE
   -> Iskanje datotek, povezanih z obrazcem (iskanje "email" v kodi)
   -> Branje krmilnika, ki obravnava oddajo
   -> Branje funkcije za validacijo e-pošte
   -> Identifikacija regularnega izraza, ki zavrača '+'

2. NAČRTOVANJE
   -> Sprememba regularnega izraza za validacijo, da sprejme '+'
   -> Dodajanje enotskega testa za e-poštne naslove z '+'
   -> Preverjanje, ali kateri drug del kode filtrira '+'

3. IZVEDBA
   -> Sprememba src/validators/email.py: popravi vzorec regularnega izraza
   -> Ustvarjanje tests/test_email_validation.py: dodaj primere z '+'
   -> Sprememba src/controllers/form.py: dodaj beleženje za odpravljanje napak

4. PREVERJANJE
   -> Zagon pytest -> vsi testi uspejo
   -> Preverjanje razlike (diff) -> spremembe so dosledne in minimalne

Opazi tretjo vrstico načrta: agent ne popravi le mesta, kjer se napaka kaže; preveri, ali kateri drug filter drugje ne zavrača tega znaka. To iskanje vzroka, ne le simptoma, je tisto, kar loči agentski popravek od hitrega obliža.

Uporaba orodij v praksi

Agent deluje na svoje okolje prek klicev funkcij. V zahtevku deklariraš razpoložljiva orodja, vključno z njihovim imenom, opisom in shemo parametrov; model izbere, katera poklicati in s katerimi argumenti.

# Primer agentskega pogovora
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",   # default value: the model decides whether to call a tool
)

Za to zahtevo se tipično zaporedje začne z read_file("src/auth/validators.py"), da se razume obstoječa koda, nadaljuje z read_file("tests/test_auth.py"), da se vidi format trenutnih testov, nato pa preide na pisanje: write_file("src/auth/validators.py", ...) z dodanim pravilom za validacijo, write_file("tests/test_auth.py", ...) z novimi primeri in nazadnje run_command("pytest tests/test_auth.py") za preverjanje. Vrstni red je pomemben: tako da odpre obe datoteki, preden se dotakne katerega koli znaka, agent prevzame tvoje konvencije in jih reproducira, namesto da bi uvažal tiste, ki jih je videl drugje.

Večkratna agentska zanka

Nič od tega se ne zgodi v enem samem klicu. Srce programiranja z agenti je večkratna zanka: model predlaga dejanje, tvoja koda ga izvede in ti pošlješ rezultat nazaj, da se lahko odloči za naslednji korak. Obdržiš nadzor nad dejansko izvedbo, kar služi tudi kot tvoje varnostno ogrodje.

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):   # guardrail: an agent must never loop indefinitely
    tool_calls = response.choices[0].message.tool_calls
    if not tool_calls:
        break         # no more tool calls: the final answer has arrived
    for tool_call in tool_calls:   # a response can contain multiple calls
        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)

Pomembne so tri podrobnosti. Sporočilo agenta in vsak rezultat orodja se ponovno vbrizgata v zgodovino, povezana z tool_call_id: če izpustiš enega ali drugega, agent izgubi nit in v zanki znova in znova kliče ista orodja. En odgovor lahko vsebuje več klicev orodij, saj so vzporedni klici privzeto dovoljeni (parallel_tool_calls=False jih prepoveduje): obdelaj jih vse. Nazadnje, omeji število obratov in naj človek potrdi ukaze lupine in pisanje datotek: agent, ki izvrši vse, kar predlaga, je tveganje, ne prihranek časa.

Ključne ugotovitve

  • Programiranje z agenti sledi ciklu: razumevanje, načrtovanje, izvedba, preverjanje
  • Agent deluje na repozitorij prek klicanja orodij (tools, tool_choice)
  • Večkratna zanka omogoča agentu iteracijo do popolne rešitve
  • Agent dosledno spreminja več datotek v okviru ene same naloge
  • Faza preverjanja (testi, gradnja) je bistvena za zanesljivost