Премини към основното съдържание
Български— Изберете език
Меню

Комбиниране на инструменти в едно извикване

Урок 19 от 20 Обновен 2 ноември 2026 г. Програмист
На тази страница
  1. Комбиниране на инструменти в едно извикване
  2. Принцип на комбинирането
  3. Пълен пример: аналитичен асистент
  4. Управление на цикъла с множество инструменти
  5. Стратегии за оркестрация
  6. Шаблон: агент с много умения
  7. Ключови изводи

Обновено на 2 ноември 2026 г. въз основа на документацията на OpenAI: инструментът Code Interpreter вече изисква параметър container (добавен към всички примери), текстовите входове използват типа input_text, а уеб търсенето използва инструмента web_search (web_search_preview вече е остарял инструмент без филтри за домейни). Генерираните файлове се извличат чрез функциите fichiers_generes и telecharger от Урок 10. Файловете, прикачени към съобщение, се качват с цел user_data, което OpenAI препоръчва за входни данни на модела (File inputs). Източници: Code Interpreter · Web search.

Комбиниране на инструменти в едно извикване

Досега разглеждахме всеки инструмент поотделно. В производствена среда интересните въпроси рядко имат такава форма. Въпросът „как се представят нашите продажби спрямо пазара?“ изисква извличане на вътрешна цифра, външна цифра и след това тяхното сравнение. Три инструмента, три източника, едно извикване.

Промяната е в това кой решава реда. Вие не програмирате последователността: Вие декларирате наличните инструменти и описвате очаквания резултат, а моделът изгражда собствения си план. Това е удобно, но също така е моментът, който изисква внимание – имплицитният план е план, който не можете да прегледате. Последната част на този урок показва как да си върнете контрола, когато редът наистина има значение.

Принцип на комбинирането

Всички инструменти се декларират в един и същи масив tools и това е целият механизъм: няма API за композиция, има само списък с налични възможности. Моделът прочита Вашата заявка, извежда необходимите стъпки и извиква това, от което се нуждае, в реда, който счита за полезен. Инструмент, който е деклариран, но не е необходим за задачата, просто няма да бъде извикан – това не струва нищо освен няколко токена в неговото описание.

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

Моделът ще:

  1. Извлече вътрешните прогнози чрез File Search
  2. Извлече пазарните тенденции чрез Web Search
  3. Генерира сравнителна диаграма чрез Code Interpreter

Пълен пример: аналитичен асистент

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

tools = [
    # Търсене във вътрешни документи
    {
        "type": "file_search",
        "vector_store_ids": ["vs_rapports", "vs_objectifs"],
        "max_num_results": 10
    },
    # Уеб търсене за пазарен контекст
    {
        "type": "web_search",
        "search_context_size": "medium"
    },
    # Изпълнение на код за анализ
    {"type": "code_interpreter", "container": {"type": "auto"}},
    # Функция за запазване на доклада
    {
        "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."
    )
)

Управление на цикъла с множество инструменти

Тук съществува асиметрия, която трябва да имате предвид, защото тя определя структурата на Вашия код. Вградените инструменти – Web Search, File Search, Code Interpreter – се изпълняват при OpenAI: моделът ги извиква, получава резултата и продължава, всичко в един цикъл на заявка-отговор. Вашите персонализирани функции обаче се изпълняват от Ваша страна: моделът може само да поиска тяхното изпълнение, след което предава контрола и чака.

Оттук идва и цикълът по-долу. Докато отговорът съдържа извиквания на функции, Вие ги изпълнявате, връщате резултатите и рестартирате. Задайте максимален брой итерации: модел, който безкрайно извиква един и същи инструмент, защото резултатът не го удовлетворява, е рядък, но реален случай, и без предпазна мярка той ще изчерпи бюджета Ви.

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}

Стратегии за оркестрация

Насочване на реда на инструментите

Автоматичната оркестрация работи добре, стига редът да няма значение. Тя спира да работи, когато една стъпка трябва да информира следващата: търсенето във Вашите документи преди уеб търсенето, например, защото вътрешният речник обуславя релевантността на външната заявка. Системният промпт е лостът – не като техническо ограничение, а като методологическа инструкция, която моделът следва толкова по-добре, колкото по-обоснована е тя.

# Стратегия 1: първо търсене, после действие
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: анализ на данни, след това обогатяване
instructions_analyse_dabord = (
    "Start by analyzing the data with Code Interpreter. "
    "Then enrich your conclusions with web searches. "
    "Finally, compare with internal documents."
)

# Стратегия 3: кръстосана проверка
instructions_verification = (
    "For each important piece of information, verify it in at least two sources: "
    "internal documents AND web search. Report any contradictions."
)

Ограничаване на инструментите по стъпка

Противоположният подход е да премахнете избора. Вместо едно извикване с пълен набор от инструменти, Вие разделяте работния поток на няколко извиквания, като всяко декларира само инструмента за конкретната си стъпка. Губите автоматичната оркестрация, но печелите три неща, които имат значение в производствена среда: гарантиран ред, предвидима цена и изолируеми грешки. За критичен поток това е почти винаги правилният компромис.

# Стъпка 1: събиране на данни (без код)
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: анализ със събраните данни
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"}}]
)

Шаблон: агент с много умения

Този последен пример комбинира двата подхода: рутер избира конфигурацията на инструментите въз основа на естеството на заявката, след което оставя модела да оркестрира в рамките на този ограничен обхват. Това е компромисът, който се утвърждава в употреба – достатъчно свобода, за да поеме разнообразието от заявки, достатъчно структура, за да поддържа разходите и поведението предвидими.

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)

# Инстанциране на агента
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
        }
    ]
)

# Сега агентът може да:
# - Търси в документи
# - Търси в уеб
# - Анализира данни
# - Изпраща имейли
# - Създава задачи
resultat = agent.traiter(
    "Analyze Q1 sales, compare with goals, "
    "and create a task for the sales director if we are behind."
)

Ключови изводи

  • Всички инструменти съществуват заедно в един и същи масив tools
  • Вградените инструменти се изпълняват от страна на сървъра, персонализираните функции – от страна на клиента
  • Моделът автоматично оркестрира реда на извикванията
  • Насочвайте стратегията за оркестрация чрез системния промпт
  • Внедрете цикъл за обработка на извиквания на персонализирани функции