Lähe põhisisu juurde
Eesti— Vali keel
Menüü

Kombineeri tööriistu ühes päringus

Õppetund 19 / 20 Värskendatud 2. november 2026 Arendajatele
Sellel lehel
  1. Kombineeri tööriistu ühes päringus
  2. Kombineerimise põhimõte
  3. Täielik näide: analüütiabiassistent
  4. Mitme tööriistaga tsükli haldamine
  5. Orkestreerimisstrateegiad
  6. Muster: mitme oskusega agent
  7. Peamised punktid

Uuendatud 2. novembril 2026 OpenAI dokumentatsiooni põhjal: Code Interpreteri tööriist nõuab nüüd parameetrit container (lisatud kõigile näidetele), tekstisisendid kasutavad tüüpi input_text ja veebiotsing kasutab tööriista web_search (web_search_preview on nüüd aegunud tööriist ilma domeenifiltriteta). Genereeritud failid laaditakse alla funktsioonidega fichiers_generes ja telecharger, mida käsitleti 10. õppetükis. Sõnumile lisatud failid laaditakse üles eesmärgiga user_data, mida OpenAI soovitab mudeli sisendite jaoks (File inputs). Allikad: Code Interpreter · Web search.

Kombineeri tööriistu ühes päringus

Seni oleme vaadelnud iga tööriista eraldi. Tootmiskeskkonnas esineb harva nii lihtsaid küsimusi. Küsimus „kuidas meie müük turuga võrreldes?“ nõuab sisemise näitaja, välise näitaja hankimist ja seejärel nende võrdlemist. Kolm tööriista, kolm allikat, üks päring.

Muutub see, kes otsustab järjekorra. Sa ei programmeeri jada: sa deklareerid olemasolevad tööriistad ja kirjeldad oodatavat tulemust ning mudel koostab oma plaani. See on mugav, kuid samas ka koht, kus tuleb valvsaks jääda – kaudne plaan on plaan, mida sa ei saa üle vaadata. Selle õppetüki viimases osas näitame, kuidas taastada kontroll, kui järjekord on tõesti oluline.

Kombineerimise põhimõte

Kõik tööriistad deklareeritakse samas massiivis tools ja see on kogu mehhanism: kompositsiooni API-t ei ole, on vaid loetelu olemasolevatest võimalustest. Mudel loeb sinu päringu, tuletab vajalikud sammud ja kutsub välja need, mida ta vajab, selles järjekorras, mida ta peab kasulikuks. Tööriista, mis on deklareeritud, kuid ülesande jaoks mitte vajalik, lihtsalt ei kutsuta välja – see ei maksa midagi peale mõne tokeni selle kirjelduses.

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"}}
    ]
)

Mudel teeb järgmist:

  1. Hangib sisemised prognoosid File Searchi kaudu
  2. Hangib turusuundumused Web Searchi kaudu
  3. Genereerib võrdlusdiagrammi Code Interpreteri kaudu

Täielik näide: analüütiabiassistent

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

tools = [
    # Otsi sisemisi dokumente
    {
        "type": "file_search",
        "vector_store_ids": ["vs_rapports", "vs_objectifs"],
        "max_num_results": 10
    },
    # Veebiotsing turukonteksti jaoks
    {
        "type": "web_search",
        "search_context_size": "medium"
    },
    # Koodi käivitamine analüüsiks
    {"type": "code_interpreter", "container": {"type": "auto"}},
    # Funktsioon aruande salvestamiseks
    {
        "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."
    )
)

Mitme tööriistaga tsükli haldamine

Siin on asümmeetria, mida pead meeles pidama, sest see määrab sinu koodi struktuuri. Sisseehitatud tööriistad – Web Search, File Search, Code Interpreter – käivituvad OpenAI serveris: mudel kutsub need välja, saab tulemuse ja jätkab, kõik ühes voorus. Sinu kohandatud funktsioonid aga käivituvad sinu poolt: mudel saab ainult taotleda nende käivitamist, seejärel annab kontrolli üle ja ootab.

Seega allpool olev tsükkel. Niikaua kui vastus sisaldab funktsioonikutseid, täidad need, tagastad tulemused ja alustad uuesti. Määra iteratsioonide maksimaalne arv: mudel, mis kutub lõpmatult sama tööriista, kuna tulemus teda ei rahulda, on harv, kuid reaalne juhtum, ja ilma piiranguta kulutab see sinu eelarve tühjaks.

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}

Orkestreerimisstrateegiad

Juhenda tööriistade järjekorda

Automaatne orkestreerimine toimib hästi seni, kuni järjekord ei oma tähtsust. See lakkab töötamast, kui üks samm peab informeerima järgmist: näiteks oma dokumentide otsimine enne veebi, sest sisemine sõnavara tingib välise päringu asjakohasuse. Süsteemi prompt on hoob – mitte tehnilise piiranguna, vaid metoodilise juhisena, mida mudel seda paremini järgib, mida põhjendatum see on.

# Strateegia 1: otsi esmalt, tegutse hiljem
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."
)

# Strateegia 2: andmeanalüüs, seejärel rikastamine
instructions_analyse_dabord = (
    "Start by analyzing the data with Code Interpreter. "
    "Then enrich your conclusions with web searches. "
    "Finally, compare with internal documents."
)

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

Piira tööriistu kaupa

Vastupidine lähenemine on valida võimaluste asemel kindel tee. Ühe kõne asemel, mis kasutab kogu tööriistakomplekti, jagad töövoogu mitmeks kõneks, millest igaüks deklareerib ainult oma konkreetsele sammule vajaliku tööriista. Kaotad automaatse orkestreerimise, kuid võidad kolm asja, mis loevad tootmises: garanteeritud järjekord, ennustatavad kulud ja isoleeritavad vead. Kriitilise voogu puhul on see peaaegu alati õige kompromiss.

# Samm 1: andmete kogumine (koodi pole)
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"}
    ]
)

# Samm 2: analüüs kogutud andmetega
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"}}]
)

Muster: mitme oskusega agent

See viimane näide ühendab mõlemat lähenemist: ruuter valib tööriistakonfiguratsiooni vastavalt päringu olemusele ja seejärel laseb mudelil orkestreerida selles piiratud ulatuses. See on kompromiss, mis kasutuses vastu peab – piisavalt vabadust, et mahutada erinevaid päringuid, ja piisavalt struktuuri, et hoida kulud ja käitumine ennustatavana.

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)

# Loo agent
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 saab nüüd:
# - Otsida dokumente
# - Otsida veebist
# - Analüüsida andmeid
# - Saata e-kirju
# - Luua ülesandeid
resultat = agent.traiter(
    "Analyze Q1 sales, compare with goals, "
    "and create a task for the sales director if we are behind."
)

Peamised punktid

  • Kõik tööriistad eksisteerivad samas massiivis tools
  • Sisseehitatud tööriistad käivituvad serveripoolselt, kohandatud funktsioonid kliendipoolselt
  • Mudel orkestreerib automaatselt kõnede järjekorda
  • Juhenda orkestreerimisstrateegiat süsteemi prompti kaudu
  • Rakenda tsükkel kohandatud funktsioonikõnede haldamiseks