Kombinera verktyg i ett enda anrop
På denna sida
Uppdaterad 2 november 2026 baserat på OpenAI-dokumentation: Code Interpreter-verktyget kräver nu en
container-parameter (lagd till i alla exempel), textinmatningsdelar använder typeninput_text, och webbsökning använder verktygetweb_search(web_search_previewär nu ett föråldrat verktyg utan domänfilter). Genererade filer hämtas med funktionernafichiers_generesochtelechargerfrån lektion 10. Filer som bifogas ett meddelande laddas upp med syftetuser_data, vilket OpenAI rekommenderar för modellinmatningar (File inputs). Källor: Code Interpreter · Web search.
Kombinera verktyg i ett enda anrop
Hittills har vi tittat på varje verktyg isolerat. I produktion ställs sällan intressanta frågor på det sättet. Att fråga «hur står sig vår försäljning jämfört med marknaden?» kräver att du hämtar en intern siffra, en extern siffra och sedan jämför dem. Tre verktyg, tre källor, ett anrop.
Det som ändras är vem som bestämmer ordningen. Du programmerar inte sekvensen: du deklarerar vilka verktyg som finns tillgängliga och beskriver det önskade resultatet, så bygger modellen sin egen plan. Det är bekvämt, men det är också punkten du måste hålla koll på – en implicit plan är en plan du inte kan granska. Den sista delen av denna lektion visar hur du återtar kontrollen när ordningen verkligen spelar roll.
Principen för kombination
Alla verktyg deklareras i samma tools-array, och det är hela mekanismen: det finns inget compositions-API, bara en lista över tillgängliga funktioner. Modellen läser din begäran, härleder de nödvändiga stegen och anropar det den behöver, i den ordning den bedömer som användbar. Ett verktyg som är deklarerat men onödigt för uppgiften kommer helt enkelt inte att anropas – det kostar inget utöver de få token som beskrivningen tar.
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"}}
]
)
Modellen kommer att:
- Hämta interna prognoser via File Search
- Hämta marknadstrender via Web Search
- Generera ett jämförelse-diagram via Code Interpreter
Komplett exempel: analytisk assistent
with open("donnees_ventes.csv", "rb") as f:
fichier = client.files.create(file=f, purpose="user_data")
tools = [
# Sök i interna dokument
{
"type": "file_search",
"vector_store_ids": ["vs_rapports", "vs_objectifs"],
"max_num_results": 10
},
# Webbsökning för marknadskontext
{
"type": "web_search",
"search_context_size": "medium"
},
# Kodkörning för analys
{"type": "code_interpreter", "container": {"type": "auto"}},
# Funktion för att spara rapporten
{
"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."
)
)
Hantera flerverktygsloopen
Det finns en asymmetri här som du måste ha i åtanke, eftersom den avgör din kodstruktur. Inbyggda verktyg – Web Search, File Search, Code Interpreter – körs hos OpenAI: modellen anropar dem, får resultatet och fortsätter, allt i en enda tur och retur. Dina egna funktioner körs dock på din sida: modellen kan bara begära att de körs, sedan lämnar den över kontrollen och väntar.
Därför behövs loopen nedan. Så länge svaret innehåller funktionsanrop kör du dem, returnerar resultaten och startar om. Sätt en gräns för maximalt antal iterationer: en modell som i all oändlighet anropar samma verktyg eftersom resultatet inte tillfredsställer den är ett sällsynt men verkligt fall, och utan en säkerhetsgräns kommer den att förbruka din budget tills den är slut.
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}
Orkestreringsstrategier
Styra verktygsordningen
Automatisk orkestrering fungerar bra så länge ordningen inte spelar roll. Den slutar fungera när ett steg måste informera nästa: att söka i dina dokument innan webben, till exempel, eftersom det interna ordförrådet avgör relevansen i den externa frågan. Systemprompten är hävstången – inte som en teknisk begränsning, utan som en metodisk instruktion som modellen följer desto bättre när den är motiverad.
# Strategi 1: sök först, agera senare
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."
)
# Strategi 2: dataanalys sedan berikning
instructions_analyse_dabord = (
"Start by analyzing the data with Code Interpreter. "
"Then enrich your conclusions with web searches. "
"Finally, compare with internal documents."
)
# Strategi 3: korsverifiering
instructions_verification = (
"For each important piece of information, verify it in at least two sources: "
"internal documents AND web search. Report any contradictions."
)
Begränsa verktyg per steg
Den motsatta approachen är att ta bort valet. Istället för ett enda anrop med hela verktygslådan delar du upp arbetsflödet i flera anrop, där varje anrop endast deklarerar verktyget för sitt specifika steg. Du förlorar den automatiska orkestreringen men vinner tre saker som betyder något i produktion: garanterad ordning, förutsägbara kostnader och isolerbara fel. För ett kritiskt flöde är detta nästan alltid rätt avvägning.
# Steg 1: datainsamling (ingen kod)
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"}
]
)
# Steg 2: analys med insamlad data
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"}}]
)
Mönster: agent med flera kompetenser
Detta sista exempel kombinerar båda approacherna: en router väljer verktygskonfigurationen baserat på begärans natur, och låter sedan modellen orkestrera inom det begränsade omfånget. Det är kompromissen som håller i användning – tillräckligt med frihet för att absorbera variationen i begäranden, tillräckligt med struktur för att hålla kostnader och beteende förutsägbara.
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)
# Instansiera agenten
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
}
]
)
# Agenten kan nu:
# - Söka i dokument
# - Söka på webben
# - Analysera data
# - Skicka e-post
# - Skapa uppgifter
resultat = agent.traiter(
"Analyze Q1 sales, compare with goals, "
"and create a task for the sales director if we are behind."
)
Viktiga punkter
- Alla verktyg samexisterar i samma
tools-array - Inbyggda verktyg körs på serversidan, egna funktioner körs på clientsidan
- Modellen orkestrerar automatiskt ordningen på anropen
- Styr orkestreringsstrategin via systemprompten
- Implementera en loop för att hantera egna funktionsanrop