Łączenie narzędzi w jednym wywołaniu
Na tej stronie
Zaktualizowano 2 listopada 2026 na podstawie dokumentacji OpenAI: narzędzie Code Interpreter wymaga teraz parametru
container(dodano do wszystkich przykładów), części wejściowe tekstowe używają typuinput_text, a wyszukiwanie w sieci korzysta z narzędziaweb_search(web_search_previewjest obecnie narzędziem przestarzałym bez filtrów domenowych). Wygenerowane pliki pobiera się za pomocą funkcjifichiers_generesitelechargerz Lekcji 10. Pliki dołączone do wiadomości są przesyłane z przeznaczeniemuser_data, co OpenAI rekomenduje dla danych wejściowych modelu (File inputs). Źródła: Code Interpreter · Wyszukiwanie w sieci.
Łączenie narzędzi w jednym wywołaniu
Do tej pory omawialiśmy każde narzędzie osobno. W środowisku produkcyjnym ciekawe pytania rzadko przybierają taką formę. Zapytanie „jak nasze wyniki sprzedaży wypadają na tle rynku?“ wymaga pobrania danych wewnętrznych, danych zewnętrznych, a następnie ich porównania. Trzy narzędzia, trzy źródła, jedno wywołanie.
Zmienia się to, kto decyduje o kolejności. Nie programujesz sekwencji: deklarujesz dostępne narzędzia i opisujesz oczekiwany rezultat, a model opracowuje własny plan. Jest to wygodne, ale stanowi też punkt newralgiczny – plan domyślny to plan, którego nie możesz zweryfikować. Ostatnia część tej lekcji pokazuje, jak odzyskać kontrolę, gdy kolejność ma kluczowe znaczenie.
Zasada łączenia
Wszystkie narzędzia są deklarowane w tej samej tablicy tools i to jest cały mechanizm: nie istnieje API kompozycji, jest tylko lista dostępnych możliwości. Model odczytuje Twoje żądanie, wnioskowane niezbędne kroki i wywołuje to, czego potrzebuje, w kolejności, którą uzna za użyteczną. Narzędzie zadeklarowane, ale niepotrzebne do zadania, po prostu nie zostanie wywołane – nie kosztuje nic poza kilkoma tokenami w jego opisie.
from openai import OpenAI
client = OpenAI()
response = client.responses.create(
model="gpt-5.6-terra",
input="Porównaj nasze prognozy sprzedaży z trendami rynkowymi, "
"następnie stwórz wykres porównawczy.",
tools=[
{"type": "file_search", "vector_store_ids": ["vs_previsions"]},
{"type": "web_search"},
{"type": "code_interpreter", "container": {"type": "auto"}}
]
)
Model wykona następujące kroki:
- Pobierze wewnętrzne prognozy poprzez File Search
- Pobierze trendy rynkowe poprzez Web Search
- Wygeneruje wykres porównawczy poprzez Code Interpreter
Pełny przykład: asystent analityczny
with open("donnees_ventes.csv", "rb") as f:
fichier = client.files.create(file=f, purpose="user_data")
tools = [
# Wyszukiwanie w dokumentach wewnętrznych
{
"type": "file_search",
"vector_store_ids": ["vs_rapports", "vs_objectifs"],
"max_num_results": 10
},
# Wyszukiwanie w sieci w celu uzyskania kontekstu rynkowego
{
"type": "web_search",
"search_context_size": "medium"
},
# Wykonanie kodu do analizy
{"type": "code_interpreter", "container": {"type": "auto"}},
# Funkcja do zapisania raportu
{
"type": "function",
"name": "sauvegarder_rapport",
"description": "Zapisz raport analityczny w systemie dokumentów",
"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": (
"Na podstawie tego pliku sprzedażowego: "
"1. Przeanalizuj trendy z ostatnich 12 miesięcy "
"2. Porównaj z naszymi celami rocznymi (przeszukaj dokumenty) "
"3. Wyszukaj w sieci trendy rynkowe "
"4. Wygeneruj wykres porównawczy "
"5. Napisz podsumowujący raport "
"6. Zapisz raport"
)},
{"type": "input_file", "file_id": fichier.id}
]
}],
tools=tools,
instructions=(
"Jesteś starszym analitykiem biznesowym. "
"Wykorzystaj wszystkie dostępne narzędzia, aby przygotować "
"kompletną, opartą na źródłach analizę."
)
)
Zarządzanie pętlą wielonarzędziową
Istnieje tu asymetria, o której musisz pamiętać, ponieważ determinuje ona strukturę Twojego kodu. Wbudowane narzędzia – Web Search, File Search, Code Interpreter – działają po stronie OpenAI: model je wywołuje, otrzymuje wynik i kontynuuje pracę, wszystko w ramach jednej rundy komunikacji. Twoje własne funkcje działają jednak po Twojej stronie: model może jedynie zażądać ich wykonania, po czym oddaje kontrolę i czeka.
Stąd poniższa pętla. Dopóki odpowiedź zawiera wywołania funkcji, wykonujesz je, zwracasz wyniki i restartujesz proces. Ustaw maksymalną liczbę iteracji: model, który w nieskończoność wywołuje to samo narzędzie, ponieważ wynik go nie satysfakcjonuje, to rzadki, ale realny przypadek, a bez zabezpieczenia wyczerpie Twój budżet.
import json
def boucle_multi_outils(prompt, tools, fichiers=None, max_tours=15):
"""Pętla wywoływania funkcji z obsługą wielu narzędzi."""
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="Użyj niezbędnych narzędzi, aby odpowiedzieć wyczerpująco."
)
# Wbudowane narzędzia (web_search, file_search, code_interpreter)
# są wykonywane automatycznie po stronie serwera.
# Obsługujemy tylko elementy function_call niestandardowe.
appels_custom = [
item for item in response.output
if item.type == "function_call"
]
if not appels_custom:
# Brak wywołania niestandardowego: model zakończył pracę
return {
"reponse": response.output_text,
"tours": tour + 1,
"tokens": response.usage.total_tokens
}
# Wykonanie funkcji niestandardowych
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)
})
# Przygotowanie następnej tury
messages = response.output + resultats
return {"reponse": "Osiągnięto limit tur", "tours": max_tours}
Strategie orkiestracji
Kierowanie kolejnością narzędzi
Automatyczna orkiestracja działa dobrze, dopóki kolejność nie ma znaczenia. Przestaje działać, gdy jeden krok musi informować następny: przeszukiwanie Twoich dokumentów przed siecią, na przykład, ponieważ wewnętrzne słownictwo warunkuje trafność zapytania zewnętrznego. Monit systemowy jest dźwignią – nie jako ograniczenie techniczne, ale jako instrukcja metodyczna, którą model tym chętniej przestrzega, im bardziej jest ona uzasadniona.
# Strategia 1: najpierw szukaj, potem działaj
instructions_recherche_dabord = (
"Przed podjęciem jakiegokolwiek działania najpierw wyszukaj niezbędnych informacji "
"w dokumentach wewnętrznych i w sieci. "
"Nie proponuj działań, dopóki nie zgromadzisz wszystkich danych."
)
# Strategia 2: analiza danych, potem wzbogacenie
instructions_analyse_dabord = (
"Rozpocznij od analizy danych za pomocą Code Interpreter. "
"Następnie wzbogać swoje wnioski wyszukiwaniem w sieci. "
"Na końcu porównaj z dokumentami wewnętrznymi."
)
# Strategia 3: weryfikacja krzyżowa
instructions_verification = (
"Dla każdej ważnej informacji zweryfikuj ją w co najmniej dwóch źródłach: "
"dokumentach wewnętrznych ORAZ wyszukiwaniu w sieci. Zgłaszaj wszelkie sprzeczności."
)
Ograniczanie narzędzi według etapu
Przeciwnym podejściem jest odebranie wyboru. Zamiast pojedynczego wywołania z pełnym zestawem narzędzi, dzielisz przepływ pracy na kilka wywołań, z których każde deklaruje tylko narzędzie dla konkretnego etapu. Tracisz automatyczną orkiestrację, ale zyskujesz trzy rzeczy istotne w produkcji: gwarantowaną kolejność, przewidywalny koszt i izolowalne błędy. Dla krytycznego przepływu jest to niemal zawsze właściwy kompromis.
# Krok 1: zbieranie danych (bez kodu)
response_collecte = client.responses.create(
model="gpt-5.6-terra",
input="Zbierz informacje o Projekcie Alfa",
tools=[
{"type": "file_search", "vector_store_ids": ["vs_projets"]},
{"type": "web_search"}
]
)
# Krok 2: analiza zebranymi danymi
response_analyse = client.responses.create(
model="gpt-5.6-terra",
input=f"Przeanalizuj te informacje i wygeneruj wykresy:\n"
f"{response_collecte.output_text}",
tools=[{"type": "code_interpreter", "container": {"type": "auto"}}]
)
Wzorzec: agent wielozadaniowy
Ten ostatni przykład łączy oba podejścia: router wybiera konfigurację narzędzi w zależności od charakteru żądania, a następnie pozwala modelowi na orkiestrację w ramach tego ograniczonego zakresu. Jest to kompromis, który sprawdza się w użyciu – wystarczająco dużo swobody, aby obsłużyć różnorodność żądań, i wystarczająco dużo struktury, aby utrzymać koszty i zachowanie na przewidywalnym poziomie.
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)
# Instancjonowanie agenta
agent = AgentMultiCompetences(
vector_stores=["vs_docs", "vs_contrats"],
fonctions=[
{
"type": "function",
"name": "envoyer_email",
"description": "Wyślij powiadomienie e-mail",
"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": "Utwórz zadanie w menedżerze projektów",
"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 może teraz:
# - Przeszukiwać dokumenty
# - Przeszukiwać sieć
# - Analizować dane
# - Wysyłać e-maile
# - Tworzyć zadania
resultat = agent.traiter(
"Przeanalizuj sprzedaż w I kwartale, porównaj z celami "
"i utwórz zadanie dla dyrektora sprzedaży, jeśli jesteśmy do tyłu."
)
Kluczowe wnioski
- Wszystkie narzędzia współistnieją w tej samej tablicy
tools - Wbudowane narzędzia działają po stronie serwera, funkcje niestandardowe po stronie klienta
- Model automatycznie orkiestruje kolejność wywołań
- Kieruj strategią orkiestracji za pomocą monitu systemowego
- Zaimplementuj pętlę do obsługi wywołań funkcji niestandardowych