Pāriet uz galveno saturu
Latviešu— Izvēlēties valodu
Izvēlne

Kombinēt rīkus vienā izsaukumā

Nodarbība 19 no 20 Atjaunota 2026. gada 2. novembris Programmētājs
Šajā lapā
  1. Kombinēt rīkus vienā izsaukumā
  2. Kombinācijas princips
  3. Pilns piemērs: analītiskais asistents
  4. Daudzrīku cikla pārvaldība
  5. Orķestrācijas stratēģijas
  6. Paraugs: daudzfunkcionāls aģents
  7. Galvenās atziņas

Atjaunināts 2026. gada 2. novembrī, pamatojoties uz OpenAI dokumentāciju: Code Interpreter rīkam tagad ir nepieciešams container parametrs (pievienots visiem piemēriem), teksta ievades daļas izmanto input_text tipu, un tīmekļa meklēšana izmanto web_search rīku (web_search_preview tagad ir novecojis rīks bez domēna filtriem). Ģenerētie faili tiek iegūti, izmantojot fichiers_generes un telecharger funkcijas no 10. nodarbības. Faili, kas pievienoti ziņojumam, tiek augšupielādēti ar user_data mērķi, ko OpenAI iesaka modeļa ievadēm (File inputs). Avoti: Code Interpreter · Web search.

Kombinēt rīkus vienā izsaukumā

Līdz šim esam aplūkojuši katru rīku atsevišķi. Reālā vidē interesanti jautājumi reti ir tik vienkārši. Jautājums „kā mūsu pārdošanas rezultāti salīdzināmi ar tirgu?” prasa iegūt iekšēju rādītāju, ārēju rādītāju un pēc tam tos salīdzināt. Trīs rīki, trīs avoti, viens izsaukums.

Mainās tas, kurš nosaka secību. Tu neprogrammē secību: tu deklarē pieejamos rīkus un apraksti sagaidāmo rezultātu, bet models pats izveido savu plānu. Tas ir ērti, taču tieši šeit jābūt uzmanīgam — implicīts plāns ir plāns, ko tu nevari pārskatīt. Šīs nodarbības noslēgumā parādīsim, kā atgūt kontroli, kad secībai ir izšķiroša nozīme.

Kombinācijas princips

Visi rīki tiek deklarēti vienā tools masīvā, un tas ir viss mehānisms: nav nekādas kompozīcijas API, tikai pieejamo iespēju saraksts. Models izlasa tavu pieprasījumu, secina nepieciešamos soļus un izsauc to, kas vajadzīgs, tādā secībā, kādu uzskata par lietderīgu. Rīks, kas ir deklarēts, bet uzdevumam nav nepieciešams, vienkārši netiks izsaukts — tas neko nemaksā, izņemot dažus tokenus tā aprakstā.

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

Models veiks šādas darbības:

  1. Iegūs iekšējās prognozes, izmantojot File Search
  2. Iegūs tirgus tendences, izmantojot Web Search
  3. Ģenerēs salīdzinājuma diagrammu, izmantojot Code Interpreter

Pilns piemērs: analītiskais asistents

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

tools = [
    # Meklēt iekšējos dokumentus
    {
        "type": "file_search",
        "vector_store_ids": ["vs_rapports", "vs_objectifs"],
        "max_num_results": 10
    },
    # Tīmekļa meklēšana tirgus kontekstam
    {
        "type": "web_search",
        "search_context_size": "medium"
    },
    # Koda izpilde analīzei
    {"type": "code_interpreter", "container": {"type": "auto"}},
    # Funkcija atskaites saglabāšanai
    {
        "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."
    )
)

Daudzrīku cikla pārvaldība

Šeit pastāv asimetrija, kas tev jāpatur prātā, jo tā nosaka koda struktūru. Iebūvētie rīki — Web Search, File Search, Code Interpreter — darbojas pie OpenAI: models tos izsauc, saņem rezultātu un turpina darbu, viss vienā aprites ciklā. Savukārt tavas pielāgotās funkcijas darbojas tavā pusē: models var tikai pieprasīt to izpildi, pēc tam tas nodod kontroli un gaida.

Tādēļ rodas zemāk redzamais cikls. Kamēr atbilde satur funkciju izsaukumus, tu tos izpildi, atgriez rezultātus un sāc no jauna. Noteic maksimālo iterāciju skaitu: gadījums, kad models bezgalīgi atkārtoti izsauc to pašu rīku, jo rezultāts to neapmierina, ir rets, bet reāls, un bez drošības mehānisma tas iztērēs tavu budžetu līdz galam.

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."
        )

        # Iebūvētie rīki (web_search, file_search, code_interpreter)
        # tiek automātiski izpildīti servera pusē.
        # Mēs apstrādājam tikai pielāgotus function_call vienumus.
        appels_custom = [
            item for item in response.output
            if item.type == "function_call"
        ]

        if not appels_custom:
            # Nav pielāgotu izsaukumu: models ir pabeidzis darbu
            return {
                "reponse": response.output_text,
                "tours": tour + 1,
                "tokens": response.usage.total_tokens
            }

        # Izpildīt pielāgotās funkcijas
        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)
            })

        # Sagatavot nākamo kārtu
        messages = response.output + resultats

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

Orķestrācijas stratēģijas

Virzīt rīku secību

Automātiskā orķestrācija darbojas labi, kamēr secībai nav nozīmes. Tā pārstāj darboties, kad vienam solim ir jāinformē nākamais: piemēram, vispirms meklēt savos dokumentos un tikai pēc tam tīmeklī, jo iekšējā terminoloģija nosaka ārējā vaicājuma atbilstību. Sistēmas prompts ir svira — nevis kā tehnisks ierobežojums, bet kā metodoloģiska instrukcija, ko models ievēros jo labprātāk, jo vairāk tā būs pamatota.

# 1. stratēģija: vispirms meklēt, pēc tam rīkoties
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."
)

# 2. stratēģija: datu analīze, pēc tam bagātināšana
instructions_analyse_dabord = (
    "Start by analyzing the data with Code Interpreter. "
    "Then enrich your conclusions with web searches. "
    "Finally, compare with internal documents."
)

# 3. stratēģija: krusteniskā pārbaude
instructions_verification = (
    "For each important piece of information, verify it in at least two sources: "
    "internal documents AND web search. Report any contradictions."
)

Ierobežot rīkus pa soļiem

Pretēja pieeja ir izslēgt izvēli. Vienā izsaukumā ar pilnu rīku komplektu vietā tu sadali darbplūsmu vairākos izsaukumos, katrā deklarējot tikai konkrētajam solim paredzēto rīku. Tu zaudē automātisko orķestrāciju, bet iegūsti trīs lietas, kas ražošanas vidē ir svarīgas: garantētu secību, paredzamas izmaksas un izolējamas kļūdas. Kritiskai plūsmai tas gandrīz vienmēr ir pareizais kompromiss.

# 1. solis: datu vākšana (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"}
    ]
)

# 2. solis: analīze ar savāktajiem datiem
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"}}]
)

Paraugs: daudzfunkcionāls aģents

Šis pēdējais piemērs apvieno abas pieejas: maršrutētājs izvēlas rīku konfigurāciju atkarībā no pieprasījuma rakstura, pēc tam ļauj modelim orķestrēt darbības šajā ierobežotajā darbības jomā. Tas ir kompromiss, kas iztur lietošanu — pietiekami daudz brīvības, lai absorbētu pieprasījumu dažādību, un pietiekami daudz struktūras, lai uzturētu izmaksas un uzvedību paredzamu.

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ēt aģentu
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
        }
    ]
)

# Aģents tagad var:
# - Meklēt dokumentus
# - Meklēt tīmeklī
# - Analizēt datus
# - Sūtīt e-pastus
# - Izveidot uzdevumus
resultat = agent.traiter(
    "Analyze Q1 sales, compare with goals, "
    "and create a task for the sales director if we are behind."
)

Galvenās atziņas

  • Visi rīki līdzās pastāv vienā tools masīvā
  • Iebūvētie rīki darbojas servera pusē, pielāgotās funkcijas — klienta pusē
  • Models automātiski orķestrē izsaukumu secību
  • Virzi orķestrācijas stratēģiju, izmantojot sistēmas promptu
  • Implementē ciklu, lai apstrādātu pielāgotu funkciju izsaukumus