Přejít na hlavní obsah
Čeština— Vyberte jazyk
Menu

Kombinuj nástroje v jediném volání

Lekce 19 z 20 Aktualizováno 2. listopadu 2026 Vývojář
Na této stránce
  1. Kombinuj nástroje v jediném volání
  2. Princip kombinace
  3. Kompletní příklad: analytický asistent
  4. Správa smyčky s více nástroji
  5. Strategie orchestrace
  6. Vzor: agent s více dovednostmi
  7. Klíčové poznatky

Aktualizováno 2. listopadu 2026 na základě dokumentace OpenAI: nástroj Code Interpreter nyní vyžaduje parametr container (přidán do všech příkladů), části textového vstupu používají typ input_text a webové vyhledávání využívá nástroj web_search (web_search_preview je nyní zastaralý nástroj bez filtrů domén). Vygenerované soubory se získávají pomocí funkcí fichiers_generes a telecharger z Lekce 10. Soubory připojené ke zprávě se nahrávají s účelem user_data, což OpenAI doporučuje pro vstupy modelu (File inputs). Zdroje: Code Interpreter · Web search.

Kombinuj nástroje v jediném volání

Doposud jsme si každý nástroj prohlíželi izolovaně. V produkčním prostředí však zajímavé otázky takovou formu málokdy mají. Dotaz „jak si naše prodeje vedou ve srovnání s trhem?“ vyžaduje získání interního údaje, externího údaje a následné jejich porovnání. Tři nástroje, tři zdroje, jedno volání.

Mění se to, kdo rozhoduje o pořadí. Neprogramuješ sekvenci: deklaruješ dostupné nástroje a popíšeš očekávaný výsledek a model si vytvoří vlastní plán. To je pohodlné, ale je to také bod, na který si musíš dát pozor – implicitní plán je plán, který nemůžeš zkontrolovat. Poslední část této lekce ukazuje, jak znovu získat kontrolu, když na pořadí skutečně záleží.

Princip kombinace

Všechny nástroje jsou deklarovány ve stejném poli tools a to je celý mechanismus: neexistuje žádné API pro kompozici, pouze seznam dostupných schopností. Model přečte tvůj požadavek, odvodí nezbytné kroky a zavolá to, co potřebuje, v pořadí, které považuje za užitečné. Nástroj, který je deklarován, ale pro úkol není potřebný, jednoduše nebude zavolán – nestojí nic navíc kromě několika tokenů v jeho popisu.

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 provede:

  1. Získá interní prognózy prostřednictvím File Search
  2. Získá tržní trendy prostřednictvím Web Search
  3. Vygeneruje srovnávací graf prostřednictvím Code Interpreter

Kompletní příklad: analytický asistent

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

tools = [
    # Vyhledávání v interních dokumentech
    {
        "type": "file_search",
        "vector_store_ids": ["vs_rapports", "vs_objectifs"],
        "max_num_results": 10
    },
    # Webové vyhledávání pro kontext trhu
    {
        "type": "web_search",
        "search_context_size": "medium"
    },
    # Spuštění kódu pro analýzu
    {"type": "code_interpreter", "container": {"type": "auto"}},
    # Funkce pro uložení zprávy
    {
        "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."
    )
)

Správa smyčky s více nástroji

Je zde asymetrie, na kterou musíš pamatovat, protože určuje strukturu tvého kódu. Vestavěné nástroje – Web Search, File Search, Code Interpreter – běží na straně OpenAI: model je zavolá, získá výsledek a pokračuje, vše v rámci jedné cesty tam a zpět. Tvé vlastní funkce však běží na tvé straně: model může pouze požádat o jejich provedení, poté předá řízení a čeká.

Odtud plyne níže uvedená smyčka. Dokud odpověď obsahuje volání funkcí, provedeš je, vrátíš výsledky a restartuješ proces. Nastav maximální počet iterací: model, který donekonečna volá stejný nástroj, protože výsledek nesplňuje jeho očekávání, je sice vzácný, ale reálný případ, a bez ochranného mechanismu vyčerpá tvůj rozpočet.

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}

Strategie orchestrace

Veď pořadí nástrojů

Automatická orchestrace funguje dobře, dokud na pořadí nezáleží. Přestane fungovat, když jeden krok musí informovat ten další: například vyhledání ve tvých dokumentech před webem, protože interní slovník podmiňuje relevanci externího dotazu. System prompt je pákou – ne jako technické omezení, ale jako metodologický pokyn, který model dodržuje tím lépe, čím více je odůvodněn.

# Strategie 1: nejprve hledej, pak jednej
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."
)

# Strategie 2: analýza dat a poté obohacení
instructions_analyse_dabord = (
    "Start by analyzing the data with Code Interpreter. "
    "Then enrich your conclusions with web searches. "
    "Finally, compare with internal documents."
)

# Strategie 3: křížová verifikace
instructions_verification = (
    "For each important piece of information, verify it in at least two sources: "
    "internal documents AND web search. Report any contradictions."
)

Omez nástroje podle kroku

Opačný přístup spočívá v odstranění výběru. Místo jediného volání s úplnou sadou nástrojů rozdělíš pracovní postup do několika volání, přičemž každé deklaruje pouze nástroj pro svůj konkrétní krok. Ztratíš automatickou orchestraci, ale získáš tři věci, které jsou v produkci důležité: zaručené pořadí, předvídatelné náklady a izolovatelné chyby. Pro kritický tok je to téměř vždy ta správná kompromisní volba.

# Krok 1: sběr dat (žádný kód)
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"}
    ]
)

# Krok 2: analýza se získanými daty
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"}}]
)

Vzor: agent s více dovednostmi

Tento poslední příklad kombinuje oba přístupy: směrovač vybírá konfiguraci nástrojů na základě povahy požadavku a poté nechá model orchestraci v rámci tohoto omezeného rozsahu. Je to kompromis, který obstojí v praxi – dostatek svobody pro absorpci rozmanitosti požadavků a dostatek struktury pro udržení předvídatelnosti nákladů a chování.

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)

# Inicializace 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 nyní umí:
# - Vyhledávat v dokumentech
# - Vyhledávat na webu
# - Analyzovat data
# - Odesílat e-maily
# - Vytvářet úkoly
resultat = agent.traiter(
    "Analyze Q1 sales, compare with goals, "
    "and create a task for the sales director if we are behind."
)

Klíčové poznatky

  • Všechny nástroje koexistují ve stejném poli tools
  • Vestavěné nástroje běží na straně serveru, vlastní funkce na straně klienta
  • Model automaticky orchestruje pořadí volání
  • Veď strategii orchestrace prostřednictvím system promptu
  • Implementuj smyčku pro zpracování volání vlastních funkcí