Preskoči na glavni sadržaj
Hrvatski— Odaberite jezik
Izbornik

Kombiniraj alate u jednom pozivu

Lekcija 19 od 20 Ažurirano 2. studenoga 2026. Programer
Na ovoj stranici
  1. Kombiniraj alate u jednom pozivu
  2. Načelo kombinacije
  3. Potpuni primjer: analitički asistent
  4. Upravljanje petljom s više alata
  5. Strategije orkestracije
  6. Uzorak: agent s više vještina
  7. Ključne točke

Ažurirano 2. studenoga 2026. na temelju OpenAI dokumentacije: alat Code Interpreter sada zahtijeva parametar container (dodan svim primjerima), dijelovi tekstualnog unosa koriste vrstu input_text, a web pretraživanje koristi alat web_search (web_search_preview je sada zastarjeli alat bez filtara domene). Generirane datoteke dohvaćaju se pomoću funkcija fichiers_generes i telecharger iz Lekcije 10. Datoteke priložene poruci učitavaju se s namjenom user_data, što OpenAI preporučuje za ulaze modela (File inputs). Izvori: Code Interpreter · Web search.

Kombiniraj alate u jednom pozivu

Do sada smo svaki alat promatrali izolirano. U proizvodnji zanimljiva pitanja rijetko imaju takav oblik. Pitanje „kako se naša prodaja uspoređuje s tržištem?“ zahtijeva dohvaćanje internog podatka, vanjskog podatka, a zatim njihovu usporedbu. Tri alata, tri izvora, jedan poziv.

Ono što se mijenja jest tko odlučuje o redoslijedu. Ti ne programiraš slijed: ti deklariraš dostupne alate i opisuješ očekivani rezultat, a model uspostavlja vlastiti plan. To je zgodno, ali to je i točka na koju moraš paziti—implicitni plan je plan koji ne možeš pregledati. Posljednji dio ove lekcije pokazuje kako povratiti kontrolu kada redoslijed doista ima važnost.

Načelo kombinacije

Svi alati deklariraju se u istom polju tools, i to je cijeli mehanizam: ne postoji API za kompoziciju, već samo popis dostupnih mogućnosti. Model čita tvoj zahtjev, zaključuje potrebne korake i poziva ono što mu treba, onim redoslijedom koji smatra korisnim. Alat koji je deklariran, ali nije potreban za zadatak, jednostavno neće biti pozvan—ne košta ništa osim nekoliko tokena u svom opisu.

from openai import OpenAI

client = OpenAI()

response = client.responses.create(
    model="gpt-5.6-terra",
    input="Compare our sales forecasts with market trends, "
          "then create a comparison chart.",
    tools=[
        {"type": "file_search", "vector_store_ids": ["vs_previsions"]},
        {"type": "web_search"},
        {"type": "code_interpreter", "container": {"type": "auto"}}
    ]
)

Model će:

  1. Dohvatiti interne prognoze putem File Searcha
  2. Dohvatiti tržišne trendove putem Web Searcha
  3. Generirati grafikon usporedbe putem Code Interpretera

Potpuni primjer: analitički asistent

with open("donnees_ventes.csv", "rb") as f:
    fichier = client.files.create(file=f, purpose="user_data")

tools = [
    # Pretraživanje internih dokumenata
    {
        "type": "file_search",
        "vector_store_ids": ["vs_rapports", "vs_objectifs"],
        "max_num_results": 10
    },
    # Web pretraživanje za tržišni kontekst
    {
        "type": "web_search",
        "search_context_size": "medium"
    },
    # Izvršavanje koda za analizu
    {"type": "code_interpreter", "container": {"type": "auto"}},
    # Funkcija za spremanje izvješća
    {
        "type": "function",
        "name": "sauvegarder_rapport",
        "description": "Save an analysis report to the document system",
        "parameters": {
            "type": "object",
            "properties": {
                "titre": {"type": "string"},
                "contenu": {"type": "string"},
                "categorie": {
                    "type": "string",
                    "enum": ["analyse", "prevision", "audit", "comparaison"]
                },
                "tags": {
                    "type": "array",
                    "items": {"type": "string"}
                }
            },
            "required": ["titre", "contenu", "categorie", "tags"],
            "additionalProperties": False
        },
        "strict": True
    }
]

response = client.responses.create(
    model="gpt-5.6-terra",
    input=[{
        "role": "user",
        "content": [
            {"type": "input_text", "text": (
                "Based on this sales file: "
                "1. Analyze trends over the last 12 months "
                "2. Compare with our annual goals (search the docs) "
                "3. Search the web for market trends "
                "4. Generate a comparison chart "
                "5. Write a summary report "
                "6. Save the report"
            )},
            {"type": "input_file", "file_id": fichier.id}
        ]
    }],
    tools=tools,
    instructions=(
        "You are a senior business analyst. "
        "Use all tools at your disposal to produce "
        "a complete, sourced analysis."
    )
)

Upravljanje petljom s više alata

Ovdje postoji asimetrija koje se moraš držati na umu jer ona određuje strukturu tvog koda. Ugrađeni alati—Web Search, File Search, Code Interpreter—izvršavaju se na strani OpenAIja: model ih poziva, dobiva rezultat i nastavlja, sve u jednom krugu komunikacije. Tvoje prilagođene funkcije, međutim, izvršavaju se na tvojoj strani: model može samo zatražiti njihovo izvršenje, zatim predaje kontrolu i čeka.

Otuda donja petlja. Sve dok odgovor sadrži pozive funkcija, ti ih izvršavaš, vraćaš rezultate i ponovno pokrećeš proces. Postavi maksimalan broj iteracija: model koji beskonačno iznova poziva isti alat jer ga rezultat ne zadovoljava rijedak je, ali stvaran slučaj, a bez zaštitne mjere potrošit će tvoj budžet do iscrpljenosti.

import json

def boucle_multi_outils(prompt, tools, fichiers=None, max_tours=15):
    """Function calling loop with multi-tool support."""
    content = [{"type": "input_text", "text": prompt}]
    if fichiers:
        for fid in fichiers:
            content.append({"type": "input_file", "file_id": fid})

    messages = [{"role": "user", "content": content}]

    for tour in range(max_tours):
        response = client.responses.create(
            model="gpt-5.6-terra",
            input=messages,
            tools=tools,
            instructions="Use the necessary tools to answer completely."
        )

        # Built-in tools (web_search, file_search, code_interpreter)
        # are executed automatically on the server side.
        # We only handle custom function_call items.
        appels_custom = [
            item for item in response.output
            if item.type == "function_call"
        ]

        if not appels_custom:
            # No custom call: the model is finished
            return {
                "reponse": response.output_text,
                "tours": tour + 1,
                "tokens": response.usage.total_tokens
            }

        # Execute custom functions
        resultats = []
        for appel in appels_custom:
            resultat = dispatcher_fonctions(appel.name, appel.arguments)
            resultats.append({
                "type": "function_call_output",
                "call_id": appel.call_id,
                "output": json.dumps(resultat)
            })

        # Prepare the next turn
        messages = response.output + resultats

    return {"reponse": "Turn limit reached", "tours": max_tours}

Strategije orkestracije

Usmeri redoslijed alata

Automatska orkestracija dobro funkcionira sve dok redoslijed nije bitan. Prestaje raditi kada jedan korak mora informirati sljedeći: pretraživanje tvojih dokumenata prije weba, na primjer, jer interni rječnik uvjetuje relevantnost vanjskog upita. Sistemski prompt je poluga—ne kao tehničko ograničenje, već kao metodološka uputa koju model slijedi utoliko bolje quanto je opravdanija.

# Strategija 1: prvo pretraži, zatim djeluj
instructions_recherche_dabord = (
    "Before any action, first search for the necessary information "
    "in internal documents and on the web. "
    "Do not propose actions until you have gathered all data."
)

# Strategija 2: analiza podataka pa obogaćivanje
instructions_analyse_dabord = (
    "Start by analyzing the data with Code Interpreter. "
    "Then enrich your conclusions with web searches. "
    "Finally, compare with internal documents."
)

# Strategija 3: unakrsna provjera
instructions_verification = (
    "For each important piece of information, verify it in at least two sources: "
    "internal documents AND web search. Report any contradictions."
)

Ograniči alate po koraku

Suprotan pristup je ukloniti izbor. Umjesto jednog poziva s punim skupom alata, tijek rada dijeliš na nekoliko poziva, od kojih svaki deklarira samo alat za svoj specifični korak. Gubiš automatsku orkestraciju, ali dobivaš tri stvari koje su važne u proizvodnji: zajamčeni redoslijed, predvidive troškove i izolirane pogreške. Za kritičan tijek ovo je gotovo uvijek ispravan kompromis.

# Korak 1: prikupljanje podataka (bez koda)
response_collecte = client.responses.create(
    model="gpt-5.6-terra",
    input="Gather information on Project Alpha",
    tools=[
        {"type": "file_search", "vector_store_ids": ["vs_projets"]},
        {"type": "web_search"}
    ]
)

# Korak 2: analiza s prikupljenim podacima
response_analyse = client.responses.create(
    model="gpt-5.6-terra",
    input=f"Analyze this information and generate charts:\n"
          f"{response_collecte.output_text}",
    tools=[{"type": "code_interpreter", "container": {"type": "auto"}}]
)

Uzorak: agent s više vještina

Ovaj posljednji primjer kombinira oba pristupa: usmjerivač odabire konfiguraciju alata na temelju prirode zahtjeva, a zatim dopušta modelu da orkestrira unutar tog ograničenog opsega. To je kompromis koji se održava u upotrebi—dovoljno slobode da apsorbira raznolikost zahtjeva, dovoljno strukture da troškovi i ponašanje ostanu predvidivi.

class AgentMultiCompetences:
    def __init__(self, vector_stores: list[str], fonctions: list[dict]):
        self.client = OpenAI()
        self.tools = [
            {"type": "file_search", "vector_store_ids": vector_stores},
            {"type": "web_search", "search_context_size": "medium"},
            {"type": "code_interpreter", "container": {"type": "auto"}},
        ] + fonctions

    def traiter(self, requete: str, fichiers: list[str] = None) -> dict:
        return boucle_multi_outils(requete, self.tools, fichiers)

# Instanciraj agenta
agent = AgentMultiCompetences(
    vector_stores=["vs_docs", "vs_contrats"],
    fonctions=[
        {
            "type": "function",
            "name": "envoyer_email",
            "description": "Send a notification email",
            "parameters": {
                "type": "object",
                "properties": {
                    "destinataire": {"type": "string"},
                    "sujet": {"type": "string"},
                    "corps": {"type": "string"}
                },
                "required": ["destinataire", "sujet", "corps"],
                "additionalProperties": False
            },
            "strict": True
        },
        {
            "type": "function",
            "name": "creer_tache",
            "description": "Create a task in the project manager",
            "parameters": {
                "type": "object",
                "properties": {
                    "titre": {"type": "string"},
                    "assignee": {"type": "string"},
                    "priorite": {"type": "string", "enum": ["basse", "moyenne", "haute"]},
                    "echeance": {"type": "string"}
                },
                "required": ["titre", "assignee", "priorite"],
                "additionalProperties": False
            },
            "strict": True
        }
    ]
)

# Agent sada može:
# - Pretraživati dokumente
# - Pretraživati web
# - Analizirati podatke
# - Slati e-poštu
# - Stvarati zadatke
resultat = agent.traiter(
    "Analyze Q1 sales, compare with goals, "
    "and create a task for the sales director if we are behind."
)

Ključne točke

  • Svi alati sužive u istom polju tools
  • Ugrađeni alati izvršavaju se na strani poslužitelja, prilagođene funkcije na strani klijenta
  • Model automatski orkestrira redoslijed poziva
  • Usmjeri strategiju orkestracije putem sistemskog prompta
  • Implementiraj petlju za rukovanje pozivima prilagođenih funkcija