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

Arhitektura agenta: zanka orodje-razmišljanje

Lekcija 2 od 25 Posodobljeno 3. november 2026 Razvijalec
Na tej strani
  1. Arhitektura agenta: zanka orodje-razmišljanje
  2. Življenjski cikel agenta
  3. Notranja struktura: elementi in sporočila
  4. Vzporedni proti zaporednim klicem
  5. Parameter max_turns
  6. Ključne ugotovitve

Posodobljeno 3. novembra 2026: V funkciji rechercher_produit sta ključa prix in stock manjkala narekovaje, kar je ob prvem klicu orodja povzročilo napako NameError.

Arhitektura agenta: zanka orodje-razmišljanje

Za gradnjo učinkovitih agentov moraš razumeti njihovo notranjo arhitekturo. Agent OpenAI deluje na podlagi zanke razmišljanja: prejme nalogo, razmisli, uporabi orodje, opazuje rezultat in se nato odloči, ali je končal ali mora nadaljevati. Vse, kar narediš naprej – deklariranje orodij, nastavitev varoval, orkestracija več agentov – temelji na tej zanki.

Življenjski cikel agenta

Vsako izvajanje sledi šestim korakom:

  1. Sprejem: Agent prejme uporabniško sporočilo in sistemska navodila.
  2. Razmišljanje: Model analizira zahtevo in se odloči za naslednje dejanje.
  3. Klic orodja: Po potrebi agent pokliče eno ali več orodij.
  4. Opazovanje: Agent prejme rezultate orodij.
  5. Odločitev: Agent se odloči, ali bo nadaljeval (nazaj na korak 2) ali odgovoril.
  6. Odgovor: Agent poda svoj končni odgovor.

Ključna je zanka med korakoma 2 in 5, ki se lahko izvede večkrat. Agent lahko zaporedoma izvede 5, 10 ali celo 20 klicev orodij, preden poda končni odgovor, ne da bi ti napisal vrstico kode za orkestracijo. Spodnji primer to prikazuje: deklarirani sta dve neodvisni orodji, model pa se sam odloči, kako ju povezati.

from agents import Agent, Runner, function_tool

@function_tool
def rechercher_produit(nom: str) -> str:
    """Searches for a product in the catalog."""
    # Simulation - in production, call your database
    catalogue = {
        "laptop-pro": {"prix": 1299, "stock": 45},
        "tablet-air": {"prix": 599, "stock": 120},
    }
    produit = catalogue.get(nom)
    if produit:
        return f"Produit {nom}: {produit['prix']}€, stock: {produit['stock']}"
    return f"Produit {nom} non trouvé"

@function_tool
def calculer_remise(prix: float, pourcentage: float) -> str:
    """Calculates the price after discount."""
    prix_final = prix * (1 - pourcentage / 100)
    return f"Prix après {pourcentage}% de remise : {prix_final:.2f}€"

agent = Agent(
    name="Sales Agent",
    instructions="You help customers find products and calculate discounts.",
    tools=[rechercher_produit, calculer_remise],
    model="gpt-5.6-terra",
)

# The agent will: 1) find the product, 2) calculate the discount, 3) respond
result = Runner.run_sync(
    agent,
    "What is the price of the laptop-pro with a 15% discount?"
)
print(result.final_output)

Vprašanje zahteva dve operaciji, ki v kodi nista eksplicitno povezani. Agent samodejno izvede dva zaporedna klica orodij: najprej rechercher_produit, nato calculer_remise s pridobljeno ceno. To veriženje je odločitev modela, ne tvoje navodilo.

Notranja struktura: elementi in sporočila

API Responses vsako interakcijo strukturira kot elemente (items). Njihovo branje ti razkrije, kaj je tvoj agent dejansko storil. V pogovoru se pojavijo tri vrste:

  • message: besedilno sporočilo (od uporabnika ali agenta)
  • function_call: klic orodja, ki ga je sklenil agent
  • function_call_output: rezultat, ki ga vrne orodje
result = Runner.run_sync(agent, "Find the tablet-air")

# Inspect the reasoning steps
for item in result.raw_responses:
    print(f"Type: {type(item).__name__}")
    # You'll see: message input → function_call → function_call_output → message output

Naj ti bo v navado, da to zanko slediš vsakič, ko agent proizvede presenetljiv odgovor. Devetkrat od desetih se anomalija pokaže v klicu function_call z nepričakovanimi argumenti.

Vzporedni proti zaporednim klicem

Niso vsi koraki med seboj odvisni. Ko sta dva klica neodvisna, se lahko agent odloči, da ju izvede vzporedno.

@function_tool
def obtenir_meteo(ville: str) -> str:
    """Gets the current weather for a city."""
    meteos = {"Paris": "18°C, sunny", "Lyon": "16°C, cloudy"}
    return meteos.get(ville, "Data unavailable")

agent = Agent(
    name="Travel Agent",
    instructions="You help plan trips.",
    tools=[obtenir_meteo, rechercher_produit],
    model="gpt-5.6-terra",
)

# The agent will call obtenir_meteo("Paris") and obtenir_meteo("Lyon") in parallel
result = Runner.run_sync(
    agent,
    "What's the weather in Paris and Lyon?"
)

Vreme v Lyonu ni odvisno od vremena v Parizu: SDK samodejno upravlja vzporednost in oba klica sproži hkrati, kar zmanjša zakasnitev. To primerjaj s prejšnjim primerom prodaje, kjer je moral izračun popusta počakati na ceno: tam se zaporedje vsili samo.

Parameter max_turns

Avtonomna zanka lahko v najslabšem primeru nikoli ne preneha: agent pokliče orodje, rezultat ga spodbudi k klicu drugega in tako naprej. Varovalka je en sam parameter.

result = Runner.run_sync(
    agent,
    "Full catalog analysis",
    max_turns=10  # Maximum 10 loop iterations
)

Če agent doseže omejitev, se ustavi z doslej pridobljenimi rezultati. V produkcijskem okolju je to bistvena varnost: omejuje tako čas odziva kot stroške.

Ključne ugotovitve

  • Agent deluje v zanki: razmišljanje → orodje → opazovanje → odločitev
  • Ta zanka se lahko pred podajo odgovora izvede večkrat
  • Model samodejno odloči, katera orodja poklicati in v kakšnem vrstnem redu
  • Neodvisni klici orodij se izvajajo vzporedno
  • max_turns omejuje število iteracij zaradi varnosti