Siirry pääsisältöön
Suomi— Valitse kieli
Valikko

Yhdistä työkalut yhteen puheluun

Oppitunti 19 / 20 Päivitetty 2. marraskuuta 2026 Kehittäjä
Tällä sivulla
  1. Yhdistä työkalut yhteen puheluun
  2. Yhdistämisen periaate
  3. Täydellinen esimerkki: analyyttinen avustaja
  4. Monityökalusilmukan hallinta
  5. Orkestrointistrategiat
  6. Malli: monitaitoinen agentti
  7. Keskeiset asiat

Päivitetty 2. marraskuuta 2026 OpenAI:n dokumentaation perusteella: Code Interpreter -työkalu vaatii nyt container-parametrin (lisätty kaikkiin esimerkkeihin), tekstisyötteet käyttävät tyyppiä input_text, ja verkkohaku käyttää web_search-työkalua (web_search_preview on nyt vanhentunut työkalu ilman verkkotunnussuodattimia). Generoidut tiedostot haetaan käyttämällä oppitunnin 10 funktioita fichiers_generes ja telecharger. Viestiin liitetyt tiedostot ladataan tarkoituksella user_data, jota OpenAI suosittelee mallisyötteiksi (File inputs). Lähteet: Code Interpreter · Web search.

Yhdistä työkalut yhteen puheluun

Tähän asti olemme tarkastelleet jokaista työkalua erillään. Tuotantoympäristössä kiinnostavat kysymykset harvoin ovat tällaisia. Kysymys “miten myyntimme vertautuu markkinoihin?” vaatii sisäisen luvun hakemista, ulkoisen luvun hakemista ja niiden vertaamista. Kolme työkalua, kolme lähdettä, yksi puhelu.

Muutos on siinä, kuka päättää järjestyksestä. Et ohjelmoi sekvenssiä: ilmoitat käytettävissä olevat työkalut ja kuvailet odotetun tuloksen, jolloin malli laatii oman suunnitelmansa. Tämä on kätevää, mutta samalla se on kohta, jota tulee varoa – implisiittinen suunnitelma on suunnitelma, jota et voi tarkistaa. Tämän oppitunnin viimeinen osa näyttää, miten saat kontrollin takaisin, kun järjestys on todella tärkeä.

Yhdistämisen periaate

Kaikki työkalut ilmoitetaan samassa tools-taulukossa, ja siinä on koko mekanismi: koostamisrajapintaa ei ole, vain luettelo käytettävissä olevista ominaisuuksista. Malli lukee pyyntösi, päättelee tarvittavat vaiheet ja kutsuu mitä tarvitsee siinä järjestyksessä, jonka se katsoo hyödylliseksi. Työkalua, joka on ilmoitettu mutta ei ole tarpeen tehtävälle, ei yksinkertaisesti kutsuta – se ei maksa mitään muutamaa tokenia sen kuvauksessa.

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

Malli tekee seuraavaa:

  1. Hakee sisäiset ennusteet File Searchin kautta
  2. Hakee markkinatrendit Web Searchin kautta
  3. Luo vertailukaavion Code Interpreterin avulla

Täydellinen esimerkki: analyyttinen avustaja

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

tools = [
    # Hae sisäisiä dokumentteja
    {
        "type": "file_search",
        "vector_store_ids": ["vs_rapports", "vs_objectifs"],
        "max_num_results": 10
    },
    # Verkkohaku markkinakontekstia varten
    {
        "type": "web_search",
        "search_context_size": "medium"
    },
    # Koodin suoritus analyysiä varten
    {"type": "code_interpreter", "container": {"type": "auto"}},
    # Funktio raportin tallentamiseen
    {
        "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."
    )
)

Monityökalusilmukan hallinta

Tässä on epäsymmetria, joka sinun on pidettävä mielessäsi, koska se määrittää koodisi rakenteen. Sisäänrakennetut työkalut – Web Search, File Search, Code Interpreter – suoritetaan OpenAI:n puolella: malli kutsuu niitä, saa tuloksen ja jatkaa, kaikki yhdessä kierroksessa. Omat funktiosi sen sijaan suoritetaan sinun puolellasi: malli voi vain pyytää niiden suorittamista, minkä jälkeen se luovuttaa kontrollin ja odottaa.

Tästä johtuu alla oleva silmukka. Niin kauan kuin vastaus sisältää funktiokutsuja, suoritat ne, palautat tulokset ja käynnistät uudelleen. Aseta enimmäiskierroslukumäärä: malli, joka kutsuu samaa työkalua loputtomiin, koska tulos ei tyydytä sitä, on harvinainen mutta todellinen tapaus, ja ilman turvaverkkoa se kuluttaa budjettisi loppuun.

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}

Orkestrointistrategiat

Ohjaa työkalujen järjestystä

Automaattinen orkestrointi toimii hyvin niin kauan kuin järjestyksellä ei ole väliä. Se lakkaa toimimasta, kun yhden vaiheen on informoitava seuraavaa: esimerkiksi dokumenttiesi hakeminen ennen verkkohakua, koska sisäinen sanasto määrittää ulkoisen kyselyn relevanssin. Järjestelmäkehotus on vipu – ei teknisenä rajoituksena, vaan metodologisena ohjeena, jota malli noudattaa sitä paremmin, mitä perustellumpi se on.

# Strategia 1: hae ensin, toimi myöhemmin
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."
)

# Strategia 2: data-analyysi sitten rikastus
instructions_analyse_dabord = (
    "Start by analyzing the data with Code Interpreter. "
    "Then enrich your conclusions with web searches. "
    "Finally, compare with internal documents."
)

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

Rajoita työkaluja vaiheittain

Vastakkainen lähestymistapa on poistaa valinnanvara. Yhden puhelun sijaan, jossa on koko työkalupakki käytössä, jaat työnkulun useaan puheluun, joista kukin ilmoittaa vain kyseiseen vaiheeseen tarkoitetun työkalun. Menetät automaattisen orkestroinnin, mutta saat kolme asiaa, jotka ovat tärkeitä tuotannossa: taatun järjestyksen, ennustettavat kustannukset ja eristettävät virheet. Kriittisessä virrassa tämä on lähes aina oikea kompromissi.

# Vaihe 1: tiedonkeruu (ei koodia)
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"}
    ]
)

# Vaihe 2: analyysi kerätyllä datalla
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"}}]
)

Malli: monitaitoinen agentti

Tämä viimeinen esimerkki yhdistää molemmat lähestymistavat: reititin valitsee työkalukonfiguraation pyynnön luonteen perusteella ja antaa sitten mallin orkestroida tämän rajoitetun scopeen sisällä. Se on kompromissi, joka kestää käytössä – tarpeeksi vapautta absorboida pyyntöjen vaihtelevuus, tarpeeksi rakennetta pitääkseen kustannukset ja käyttäytyminen ennustettavina.

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)

# Instantoi agentti
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
        }
    ]
)

# Agentti voi nyt:
# - Hakea dokumentteja
# - Hakea verkosta
# - Analysoida dataa
# - Lähettää sähköposteja
# - Luoda tehtäviä
resultat = agent.traiter(
    "Analyze Q1 sales, compare with goals, "
    "and create a task for the sales director if we are behind."
)

Keskeiset asiat

  • Kaikki työkalut coexist samassa tools-taulukossa
  • Sisäänrakennetut työkalut suoritetaan palvelinpuolella, omat funktiot asiakaspuolella
  • Malli orkestroi automaattisesti kutsujen järjestyksen
  • Ohjaa orkestrointistrategiaa järjestelmäkehotuksen avulla
  • Toteuta silmukka omien funktiokutsujen käsittelyyn