Prejsť na hlavný obsah
Slovenčina— Vyberte jazyk
Menu

Kombinovanie nástrojov v jednom volaní

Lekcia 19 z 20 Aktualizované 2. novembra 2026 Vývojár
Na tejto strane
  1. Kombinovanie nástrojov v jednom volaní
  2. Princíp kombinácie
  3. Kompletný príklad: analytický asistent
  4. Riadenie slučky s viacerými nástrojmi
  5. Stratégie orchestrácie
  6. Vzorec: agent s viacerými zručnosťami
  7. Kľúčové poznatky

Aktualizované 2. novembra 2026 na základe dokumentácie OpenAI: nástroj Code Interpreter teraz vyžaduje parameter container (pridaný do všetkých príkladov), časti textového vstupu používajú typ input_text a webové vyhľadávanie používa nástroj web_search (web_search_preview je teraz zastaraný nástroj bez filtrov domén). Vygenerované súbory sa získavajú pomocou funkcií fichiers_generes a telecharger z Lekcie 10. Súbory pripojené k správe sa nahrávajú s účelom user_data, čo OpenAI odporúča pre vstupy modelu (File inputs). Zdroje: Code Interpreter · Web search.

Kombinovanie nástrojov v jednom volaní

Doteraz sme sa pozerali na každý nástroj izolovane. V produkcii majú zaujímavé otázky zriedka takúto formu. Otázka „ako sa predávajú naše produkty v porovnaní s trhom?“ si vyžaduje získanie interných údajov, externých údajov a následné ich porovnanie. Tri nástroje, tri zdroje, jedno volanie.

Zmena spočíva v tom, kto rozhoduje o poradí. Neprogramuješ postupnosť: deklaruješ dostupné nástroje a popíšeš očakávaný výsledok a model si vytvorí vlastný plán. Je to pohodlné, ale práve tu treba dávať pozor – implicitný plán je plán, ktorý nemôžeš skontrolovať. Posledná časť tejto lekcie ukazuje, ako získať späť kontrolu, keď na poradí skutočne záleží.

Princíp kombinácie

Všetky nástroje sú deklarované v rovnakom poli tools a to je celý mechanizmus: neexistuje žiadne API pre kompozíciu, iba zoznam dostupných schopností. Model prečíta tvoju požiadavku, odvodí potrebné kroky a zavolá to, čo potrebuje, v poradí, ktoré považuje za užitočné. Nástroj, ktorý je deklarovaný, ale pre úlohu nie je potrebný, sa jednoducho nezavolá – nestojí nič okrem niekoľkých tokenov v jeho popise.

from openai import OpenAI

client = OpenAI()

response = client.responses.create(
    model="gpt-5.6-terra",
    input="Porovnajte naše prognózy predaja s trhovými trendmi, "
          "potom vytvorte porovnávací graf.",
    tools=[
        {"type": "file_search", "vector_store_ids": ["vs_previsions"]},
        {"type": "web_search"},
        {"type": "code_interpreter", "container": {"type": "auto"}}
    ]
)

Model urobí nasledovné:

  1. Získa interné prognózy prostredníctvom File Search
  2. Získa trhové trendy prostredníctvom Web Search
  3. Vygeneruje porovnávací graf prostredníctvom Code Interpreter

Kompletný príklad: analytický asistent

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

tools = [
    # Vyhľadávanie v interných dokumentoch
    {
        "type": "file_search",
        "vector_store_ids": ["vs_rapports", "vs_objectifs"],
        "max_num_results": 10
    },
    # Webové vyhľadávanie pre trhový kontext
    {
        "type": "web_search",
        "search_context_size": "medium"
    },
    # Vykonávanie kódu pre analýzu
    {"type": "code_interpreter", "container": {"type": "auto"}},
    # Funkcia na uloženie správy
    {
        "type": "function",
        "name": "sauvegarder_rapport",
        "description": "Uložiť analytickú správu do systému dokumentov",
        "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": (
                "Na základe tohto súboru predajov: "
                "1. Analyzuj trendy za posledných 12 mesiacov "
                "2. Porovnaj s našimi ročnými cieľmi (vyhľadaj v dokumentoch) "
                "3. Vyhľadaj na webe trhové trendy "
                "4. Vygeneruj porovnávací graf "
                "5. Napíš súhrnnú správu "
                "6. Ulož správu"
            )},
            {"type": "input_file", "file_id": fichier.id}
        ]
    }],
    tools=tools,
    instructions=(
        "Si senior business analytik. "
        "Použi všetky dostupné nástroje na vytvorenie "
        "kompletnej, zdrojmi podloženej analýzy."
    )
)

Riadenie slučky s viacerými nástrojmi

Existuje tu asymetria, na ktorú musíš myslieť, pretože určuje štruktúru tvojho kódu. Vstavané nástroje – Web Search, File Search, Code Interpreter – bežia na strane OpenAI: model ich zavolá, získa výsledok a pokračuje, všetko v rámci jednej požiadavky. Tvoje vlastné funkcie však bežia na tvojej strane: model môže iba požiadať o ich vykonanie, potom odovzdá kontrolu a čaká.

Preto existuje nasledujúca slučka. Kým odpoveď obsahuje volania funkcií, vykonáš ich, vrátiš výsledky a reštartuješ proces. Nastav maximálny počet iterácií: model, ktorý donekonečna opakovane volá ten istý nástroj, pretože výsledok ho neuspokojuje, je síce zriedkavý, ale reálny prípad a bez ochrannej hranice spotrebuje tvoj rozpočet až do vyčerpania.

import json

def boucle_multi_outils(prompt, tools, fichiers=None, max_tours=15):
    """Slučka volania funkcií s podporou viacerých nástrojov."""
    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="Použi potrebné nástroje na úplnú odpoveď."
        )

        # Vstavané nástroje (web_search, file_search, code_interpreter)
        # sa vykonávajú automaticky na strane servera.
        # Spracovávame iba položky custom function_call.
        appels_custom = [
            item for item in response.output
            if item.type == "function_call"
        ]

        if not appels_custom:
            # Žiadne vlastné volanie: model skončil
            return {
                "reponse": response.output_text,
                "tours": tour + 1,
                "tokens": response.usage.total_tokens
            }

        # Vykonanie vlastných funkcií
        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)
            })

        # Príprava ďalšieho kola
        messages = response.output + resultats

    return {"reponse": "Dosiahnutý limit kôl", "tours": max_tours}

Stratégie orchestrácie

Usmerňovanie poradia nástrojov

Automatická orchestrácia funguje dobre, pokiaľ na poradí nezáleží. Prestane fungovať, keď jeden krok musí informovať ďalší: napríklad vyhľadanie v tvojich dokumentoch pred webom, pretože interná slovná zásoba podmieňuje relevantnosť externej požiadavky. Systémový prompt je pákou – nie ako technické obmedzenie, ale ako metodologická inštrukcia, ktorú model dodrží tým lepšie, čím viac je opodstatnená.

# Stratégia 1: najprv vyhľadaj, potom konaj
instructions_recherche_dabord = (
    "Pred akoukoľvek akciou najprv vyhľadaj potrebné informácie "
    "v interných dokumentoch a na webe. "
    "Nenavrhuj akcie, kým nezozbieraš všetky údaje."
)

# Stratégia 2: analýza dát a následné obohatenie
instructions_analyse_dabord = (
    "Začni analýzou dát pomocou Code Interpreter. "
    "Potom obohať svoje závery webovým vyhľadávaním. "
    "Nakoniec porovnaj s internými dokumentmi."
)

# Stratégia 3: krížová verifikácia
instructions_verification = (
    "Pre každú dôležitú informáciu ju over aspoň v dvoch zdrojoch: "
    "interné dokumenty A webové vyhľadávanie. Nahlás akékoľvek rozpory."
)

Obmedzenie nástrojov podľa kroku

Opačný prístup spočíva v odstránení výberu. Namiesto jedného volania s celou sadou nástrojov rozdelíš pracovný postup na niekoľko volaní, pričom každé deklaruje iba nástroj pre svoj konkrétny krok. Stratíš automatickú orchestráciu, ale získaš tri veci, ktoré sú v produkcii dôležité: zaručené poradie, predvídateľné náklady a izolovateľné chyby. Pre kritický tok je to takmer vždy správny kompromis.

# Krok 1: zber dát (bez kódu)
response_collecte = client.responses.create(
    model="gpt-5.6-terra",
    input="Zozbieraj informácie o Projekte Alpha",
    tools=[
        {"type": "file_search", "vector_store_ids": ["vs_projets"]},
        {"type": "web_search"}
    ]
)

# Krok 2: analýza so zozbieranými dátami
response_analyse = client.responses.create(
    model="gpt-5.6-terra",
    input=f"Analyzuj tieto informácie a vygeneruj grafy:\n"
          f"{response_collecte.output_text}",
    tools=[{"type": "code_interpreter", "container": {"type": "auto"}}]
)

Vzorec: agent s viacerými zručnosťami

Tento posledný príklad kombinuje oba prístupy: smerovač vyberie konfiguráciu nástrojov na základe povahy požiadavky a potom nechá model orchestráciu v rámci tohto obmedzeného rozsahu. Je to kompromis, ktorý sa v praxi osvedčuje – dostatok slobody na absorpciu variety požiadaviek a dostatok štruktúry na udržanie predvídateľných nákladov a správania.

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)

# Inicializácia agenta
agent = AgentMultiCompetences(
    vector_stores=["vs_docs", "vs_contrats"],
    fonctions=[
        {
            "type": "function",
            "name": "envoyer_email",
            "description": "Odoslať notifikačný e-mail",
            "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": "Vytvoriť úlohu v správcovi projektov",
            "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 teraz môže:
# - Vyhľadávať v dokumentoch
# - Vyhľadávať na webe
# - Analyzovať dáta
# - Odosielať e-maily
# - Vytvárať úlohy
resultat = agent.traiter(
    "Analyzuj predaj v 1. štvrťroku, porovnaj s cieľmi "
    "a vytvor úlohu pre riaditeľa predaja, ak zaostávame."
)

Kľúčové poznatky

  • Všetky nástroje koexistujú v rovnakom poli tools
  • Vstavané nástroje bežia na strane servera, vlastné funkcie na strane klienta
  • Model automaticky orchestruje poradie volaní
  • Usmerňuj stratégiu orchestrácie prostredníctvom systémového promptu
  • Implementuj slučku na spracovanie volaní vlastných funkcií