Przejdź do głównej treści
Polski— Wybierz język
Menu

Łączenie narzędzi w jednym wywołaniu

Lekcja 19 z 20 Zaktualizowano 2 listopada 2026 Programista
Na tej stronie
  1. Łączenie narzędzi w jednym wywołaniu
  2. Zasada łączenia
  3. Pełny przykład: asystent analityczny
  4. Zarządzanie pętlą wielonarzędziową
  5. Strategie orkiestracji
  6. Wzorzec: agent wielozadaniowy
  7. Kluczowe wnioski

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ą typu input_text, a wyszukiwanie w sieci korzysta z narzędzia web_search (web_search_preview jest obecnie narzędziem przestarzałym bez filtrów domenowych). Wygenerowane pliki pobiera się za pomocą funkcji fichiers_generes i telecharger z Lekcji 10. Pliki dołączone do wiadomości są przesyłane z przeznaczeniem user_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:

  1. Pobierze wewnętrzne prognozy poprzez File Search
  2. Pobierze trendy rynkowe poprzez Web Search
  3. 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