Udostępnij przez

Używanie wywoływania funkcji z agentami usługi Microsoft Foundry

Agenci microsoft Foundry obsługują wywoływanie funkcji, co umożliwia rozszerzanie agentów o możliwości niestandardowe. Zdefiniuj funkcję z jej nazwą, parametrami i opisem, a agent może poprosić aplikację o jej wywołanie. Aplikacja wykonuje funkcję i zwraca dane wyjściowe. Następnie agent używa wyniku, aby kontynuować konwersację z dokładnymi danymi w czasie rzeczywistym z twoich systemów.

Ważna

Przebiegi wygasają 10 minut po utworzeniu. Prześlij dane wyjściowe narzędzia przed ich wygaśnięciem.

Agentów można uruchamiać za pomocą narzędzi funkcji w portalu Microsoft Foundry. Jednak portal nie obsługuje dodawania, usuwania ani aktualizowania definicji funkcji na agencie. Konfigurowanie narzędzi funkcji przy użyciu zestawu SDK lub interfejsu API REST.

Wsparcie użytkowania

✔️ (GA) wskazuje ogólną dostępność, ✔️ (wersja zapoznawcza) wskazuje publiczną wersję zapoznawcza, a kreska (-) wskazuje, że funkcja nie jest dostępna.

Pomoc techniczna firmy Microsoft Foundry Zestaw SDK dla języka Python Zestaw SDK języka C# Zestaw SDK dla języka JavaScript Java SDK interfejs API REST Konfiguracja agenta podstawowego Konfiguracja agenta standardowego
✔️ ✔️ (Podgląd) ✔️ (Podgląd) ✔️ (Podgląd) - ✔️ (GA - ogólna dostępność) ✔️ ✔️

Uwaga / Notatka

Aktualnie Java SDK nie obsługuje wywoływania funkcji za pomocą nowych agentowych interfejsów API (azure-ai-projects pakiet). Obsługa języka Java jest dostępna tylko dla interfejsów API agenta klasycznego. Aby zapoznać się z przykładami wywoływania funkcji Języka Java przy użyciu agentów klasycznych, zobacz dokumentację agenta klasycznego.

Wymagania wstępne

Przed rozpoczęciem upewnij się, że masz następujące elementy:

  • Podstawowe lub standardowe środowisko agenta.

  • Projekt Foundry i wdrożony model.

  • Najnowszy pakiet zestawu SDK wersji wstępnej dla twojego języka:

    • Pyton: azure-ai-projects>=2.0.0b4
    • .NET: Azure.AI.Projects.OpenAI (wersja wstępna)
    • TypeScript: @azure/ai-projects (najnowsza wersja beta)

    Aby uzyskać instrukcje instalacji i uwierzytelniania, zobacz przewodnik Szybki start.

Zmienne środowiskowe

Każdy język używa różnych nazw zmiennych środowiskowych. Spójnie używaj jednego kompletu.

Język Punkt końcowy projektu Nazwa wdrożenia modelu
Python FOUNDRY_PROJECT_ENDPOINT FOUNDRY_MODEL_DEPLOYMENT_NAME
C# FOUNDRY_PROJECT_ENDPOINT FOUNDRY_MODEL_DEPLOYMENT_NAME
TypeScript FOUNDRY_PROJECT_ENDPOINT FOUNDRY_MODEL_DEPLOYMENT_NAME
interfejs API REST FOUNDRY_PROJECT_ENDPOINT (użyj pola treści żądania)

Wskazówka

Jeśli używasz metody DefaultAzureCredential, zaloguj się przy użyciu polecenia az login przed uruchomieniem przykładów.

Szybka weryfikacja

Jeśli nie masz pewności, że uwierzytelnianie i punkt końcowy są poprawnie skonfigurowane, uruchom najpierw poniższy fragment kodu.

import os

from azure.ai.projects import AIProjectClient
from azure.identity import DefaultAzureCredential
from dotenv import load_dotenv

load_dotenv()

with (
    DefaultAzureCredential() as credential,
    AIProjectClient(endpoint=os.environ["FOUNDRY_PROJECT_ENDPOINT"], credential=credential) as project_client,
):
    print("Connected to project.")

Tworzenie agenta przy użyciu narzędzi funkcyjnych

Wywołanie funkcji jest zgodne z tym wzorcem:

  1. Definiowanie narzędzi funkcji — opis nazwy, parametrów i przeznaczenia każdej funkcji.
  2. Tworzenie agenta — rejestrowanie agenta przy użyciu definicji funkcji.
  3. Wyślij monit — agent analizuje monit i żąda wywołań funkcji w razie potrzeby.
  4. Wykonywanie i zwracanie — aplikacja uruchamia funkcję i przesyła dane wyjściowe z powrotem do agenta.
  5. Pobierz ostateczną odpowiedź — agent używa danych wyjściowych funkcji do ukończenia odpowiedzi.

Uwaga / Notatka

Potrzebujesz najnowszego pakietu wersji wstępnej. Aby uzyskać więcej informacji, zobacz przewodnik Szybki start.

Skorzystaj z poniższego przykładu kodu, aby utworzyć agenta, obsłużyć wywołanie funkcji i zwrócić dane wyjściowe narzędzia z powrotem do agenta.

import os
import json
from dotenv import load_dotenv
from azure.ai.projects import AIProjectClient
from azure.ai.projects.models import PromptAgentDefinition, Tool, FunctionTool
from azure.identity import DefaultAzureCredential
from openai.types.responses.response_input_param import FunctionCallOutput, ResponseInputParam

load_dotenv()

def get_horoscope(sign: str) -> str:
    """Generate a horoscope for the given astrological sign."""
    return f"{sign}: Next Tuesday you will befriend a baby otter."

endpoint = os.environ["FOUNDRY_PROJECT_ENDPOINT"]

with (
    DefaultAzureCredential() as credential,
    AIProjectClient(endpoint=endpoint, credential=credential) as project_client,
    project_client.get_openai_client() as openai_client,
):

    # Define a function tool for the model to use
    func_tool = FunctionTool(
        name="get_horoscope",
        parameters={
            "type": "object",
            "properties": {
                "sign": {
                    "type": "string",
                    "description": "An astrological sign like Taurus or Aquarius",
                },
            },
            "required": ["sign"],
            "additionalProperties": False,
        },
        description="Get today's horoscope for an astrological sign.",
        strict=True,
    )

    tools: list[Tool] = [func_tool]

    agent = project_client.agents.create_version(
        agent_name="MyAgent",
        definition=PromptAgentDefinition(
            model=os.environ["FOUNDRY_MODEL_DEPLOYMENT_NAME"],
            instructions="You are a helpful assistant that can use function tools.",
            tools=tools,
        ),
    )

    # Prompt the model with tools defined
    response = openai_client.responses.create(
        input="What is my horoscope? I am an Aquarius.",
        extra_body={"agent_reference": {"name": agent.name, "type": "agent_reference"}},
    )
    print(f"Response output: {response.output_text}")

    input_list: ResponseInputParam = []
    # Process function calls
    for item in response.output:
        if item.type == "function_call":
            if item.name == "get_horoscope":
                # Execute the function logic for get_horoscope
                horoscope = get_horoscope(**json.loads(item.arguments))

                # Provide function call results to the model
                input_list.append(
                    FunctionCallOutput(
                        type="function_call_output",
                        call_id=item.call_id,
                        output=json.dumps({"horoscope": horoscope}),
                    )
                )

    print("Final input:")
    print(input_list)

    response = openai_client.responses.create(
        input=input_list,
        previous_response_id=response.id,
        extra_body={"agent_reference": {"name": agent.name, "type": "agent_reference"}},
    )

    print(f"Agent response: {response.output_text}")

    print("\nCleaning up...")
    project_client.agents.delete_version(agent_name=agent.name, agent_version=agent.version)
    print("Agent deleted")

Oczekiwane dane wyjściowe

W poniższym przykładzie przedstawiono oczekiwane dane wyjściowe:

Response output: 
Final input:
[FunctionCallOutput(type='function_call_output', call_id='call_abc123', output='{"horoscope": "Aquarius: Next Tuesday you will befriend a baby otter."}')]

Przykład użycia agentów z funkcjami

W tym przykładzie używasz funkcji lokalnych z agentami. Użyj funkcji , aby przekazać informacje specyficzne dla agenta w odpowiedzi na pytanie użytkownika. Kod w tym przykładzie jest synchroniczny. Aby zapoznać się z przykładem asynchronicznym, zobacz przykładowy kod w repozytorium zestawu Azure SDK dla platformy .NET w witrynie GitHub.

class FunctionCallingDemo
{
    // Define three functions:
    //   1. GetUserFavoriteCity always returns "Seattle, WA".
    //   2. GetCityNickname handles only "Seattle, WA"
    //      and throws an exception for other city names.
    //   3. GetWeatherAtLocation returns the weather in Seattle, WA.

    /// Example of a function that defines no parameters but
    /// returns the user's favorite city.
    private static string GetUserFavoriteCity() => "Seattle, WA";

    /// <summary>
    /// Example of a function with a single required parameter
    /// </summary>
    /// <param name="location">The location to get nickname for.</param>
    /// <returns>The city nickname.</returns>
    /// <exception cref="NotImplementedException"></exception>
    private static string GetCityNickname(string location) => location switch
    {
        "Seattle, WA" => "The Emerald City",
        _ => throw new NotImplementedException(),
    };

    /// <summary>
    /// Example of a function with one required and one optional, enum parameter
    /// </summary>
    /// <param name="location">Get weather for location.</param>
    /// <param name="temperatureUnit">"c" or "f"</param>
    /// <returns>The weather in selected location.</returns>
    /// <exception cref="NotImplementedException"></exception>
    public static string GetWeatherAtLocation(string location, string temperatureUnit = "f") => location switch
    {
        "Seattle, WA" => temperatureUnit == "f" ? "70f" : "21c",
        _ => throw new NotImplementedException()
    };

    // For each function, create FunctionTool, which defines the function name, description, and parameters.
    public static readonly FunctionTool getUserFavoriteCityTool = ResponseTool.CreateFunctionTool(
        functionName: "getUserFavoriteCity",
        functionDescription: "Gets the user's favorite city.",
        functionParameters: BinaryData.FromString("{}"),
        strictModeEnabled: false
    );

    public static readonly FunctionTool getCityNicknameTool = ResponseTool.CreateFunctionTool(
        functionName: "getCityNickname",
        functionDescription: "Gets the nickname of a city, e.g. 'LA' for 'Los Angeles, CA'.",
        functionParameters: BinaryData.FromObjectAsJson(
            new
            {
                Type = "object",
                Properties = new
                {
                    Location = new
                    {
                        Type = "string",
                        Description = "The city and state, e.g. San Francisco, CA",
                    },
                },
                Required = new[] { "location" },
            },
            new JsonSerializerOptions() { PropertyNamingPolicy = JsonNamingPolicy.CamelCase }
        ),
        strictModeEnabled: false
    );

    private static readonly FunctionTool getCurrentWeatherAtLocationTool = ResponseTool.CreateFunctionTool(
        functionName: "getCurrentWeatherAtLocation",
        functionDescription: "Gets the current weather at a provided location.",
        functionParameters: BinaryData.FromObjectAsJson(
             new
             {
                 Type = "object",
                 Properties = new
                 {
                     Location = new
                     {
                         Type = "string",
                         Description = "The city and state, e.g. San Francisco, CA",
                     },
                     Unit = new
                     {
                         Type = "string",
                         Enum = new[] { "c", "f" },
                     },
                 },
                 Required = new[] { "location" },
             },
            new JsonSerializerOptions() { PropertyNamingPolicy = JsonNamingPolicy.CamelCase }
        ),
        strictModeEnabled: false
    );

    // Create the method GetResolvedToolOutput.
    // It runs the preceding functions and wraps the output in a ResponseItem object.
    private static FunctionCallOutputResponseItem GetResolvedToolOutput(FunctionCallResponseItem item)
    {
        if (item.FunctionName == getUserFavoriteCityTool.FunctionName)
        {
            return ResponseItem.CreateFunctionCallOutputItem(item.CallId, GetUserFavoriteCity());
        }
        using JsonDocument argumentsJson = JsonDocument.Parse(item.FunctionArguments);
        if (item.FunctionName == getCityNicknameTool.FunctionName)
        {
            string locationArgument = argumentsJson.RootElement.GetProperty("location").GetString();
            return ResponseItem.CreateFunctionCallOutputItem(item.CallId, GetCityNickname(locationArgument));
        }
        if (item.FunctionName == getCurrentWeatherAtLocationTool.FunctionName)
        {
            string locationArgument = argumentsJson.RootElement.GetProperty("location").GetString();
            if (argumentsJson.RootElement.TryGetProperty("unit", out JsonElement unitElement))
            {
                string unitArgument = unitElement.GetString();
                return ResponseItem.CreateFunctionCallOutputItem(item.CallId, GetWeatherAtLocation(locationArgument, unitArgument));
            }
            return ResponseItem.CreateFunctionCallOutputItem(item.CallId, GetWeatherAtLocation(locationArgument));
        }
        return null;
    }

    public static void Main() 
    {
        // Create project client and read the environment variables that will be used in the next steps.
        var projectEndpoint = System.Environment.GetEnvironmentVariable("FOUNDRY_PROJECT_ENDPOINT");
        var modelDeploymentName = System.Environment.GetEnvironmentVariable("FOUNDRY_MODEL_DEPLOYMENT_NAME");
        AIProjectClient projectClient = new(endpoint: new Uri(projectEndpoint), tokenProvider: new DefaultAzureCredential());
        // Create an agent version with the defined functions as tools.
        PromptAgentDefinition agentDefinition = new(model: modelDeploymentName)
        {
            Instructions = "You are a weather bot. Use the provided functions to help answer questions. "
                    + "Customize your responses to the user's preferences as much as possible and use friendly "
                    + "nicknames for cities whenever possible.",
            Tools = { getUserFavoriteCityTool, getCityNicknameTool, getCurrentWeatherAtLocationTool }
        };
        AgentVersion agentVersion = projectClient.Agents.CreateAgentVersion(
            agentName: "myAgent",
            options: new(agentDefinition));

        // If the local function call is required, the response item is of type FunctionCallResponseItem.
        // It contains the function name needed by the Agent. In this case, use the helper method
        // GetResolvedToolOutput to get the FunctionCallOutputResponseItem with the function call result.
        // To provide the right answer, supply all the response items to the CreateResponse call.
        // At the end, output the function's response.
        ResponsesClient responseClient = projectClient.OpenAI.GetProjectResponsesClientForAgent(agentVersion.Name);

        ResponseItem request = ResponseItem.CreateUserMessageItem("What's the weather like in my favorite city?");
        var inputItems = new List<ResponseItem> { request };
        string previousResponseId = null;
        bool functionCalled = false;
        ResponseResult response;
        do
        {
            response = responseClient.CreateResponse(
                previousResponseId: previousResponseId,
                inputItems: inputItems);
            previousResponseId = response.Id;
            inputItems.Clear();
            functionCalled = false;
            foreach (ResponseItem responseItem in response.OutputItems)
            {
                inputItems.Add(responseItem);
                if (responseItem is FunctionCallResponseItem functionToolCall)
                {
                    Console.WriteLine($"Calling {functionToolCall.FunctionName}...");
                    inputItems.Add(GetResolvedToolOutput(functionToolCall));
                    functionCalled = true;
                }
            }
        } while (functionCalled);
        Console.WriteLine(response.GetOutputText());

        // Remove all the resources created in this sample.
        projectClient.Agents.DeleteAgentVersion(agentName: agentVersion.Name, agentVersion: agentVersion.Version);
    }
}

Oczekiwane dane wyjściowe

W poniższym przykładzie przedstawiono oczekiwane dane wyjściowe:

Calling getUserFavoriteCity...
Calling getCityNickname...
Calling getCurrentWeatherAtLocation...
Your favorite city, Seattle, WA, is also known as The Emerald City. The current weather there is 70f.

Istnieją dwa sposoby wykorzystywania wywoływania funkcji w usłudze Foundry Agent.

  1. Utwórz element response. Gdy konieczne jest ponowne wywołanie funkcji przez agenta, utwórz kolejny element response.
  2. Utwórz element conversation, a następnie utwórz wiele elementów konwersacji. Każdy element konwersacji odpowiada jednemu responseelementowi .

Przed uruchomieniem przykładów ustaw następujące zmienne środowiskowe:

export AGENT_TOKEN=$(az account get-access-token --scope "https://ai.azure.com/.default" --query accessToken -o tsv)

Definiowanie funkcji, która ma być wywoływana przez agenta

Zacznij od zdefiniowania funkcji, która ma być wywoływana przez agenta. Podczas tworzenia funkcji, którą agent ma wywołać, opisz jej strukturę i wszystkie wymagane parametry w docstringu. Na przykład funkcje można znaleźć w innych językach zestawu SDK.

Utwórz agenta

curl -X POST "$FOUNDRY_PROJECT_ENDPOINT/agents?api-version=v1" \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer $AGENT_TOKEN" \
  -d '{
    "name": "<AGENT_NAME>-function-calling",
    "description": "Agent with function calling",
    "definition": {
      "kind": "prompt",
      "model": "<MODEL_DEPLOYMENT>",
      "instructions": "You are a helpful agent.",
      "tools": [
        {
          "type": "function",
          "name": "getCurrentWeather",
          "description": "Get the current weather in a location",
          "parameters": {
            "type": "object",
            "properties": {
              "location": {"type": "string", "description": "The city and state e.g. San Francisco, CA"},
              "unit": {"type": "string", "enum": ["c", "f"]}
            },
            "required": ["location"]
          }
        }
      ]
    }
  }'

Tworzenie konwersacji

curl -X POST "$FOUNDRY_PROJECT_ENDPOINT/openai/v1/conversations" \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer $AGENT_TOKEN" \
  -d '{
    "items": [
      {
        "type": "message",
        "role": "user",
        "content": [
          {
            "type": "input_text",
            "text": "What'\''s the weather in Dar es Salaam, Tanzania?"
          }
        ]
      }
    ]
  }'

Zapisz zwrócony identyfikator konwersacji (conv_xyz...) dla następnego kroku.

Tworzenie odpowiedzi

Zastąp <CONVERSATION_ID> element identyfikatorem z poprzedniego kroku.

curl -X POST "$FOUNDRY_PROJECT_ENDPOINT/openai/v1/responses" \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer $AGENT_TOKEN" \
  -d '{
    "agent": {"type": "agent_reference", "name": "<AGENT_NAME>-function-calling"},
    "conversation": "<CONVERSATION_ID>",
    "input": []
  }'

Oczekiwane dane wyjściowe

Odpowiedź zawiera element wywołania funkcji, który należy przetworzyć:

{
  "output": [
    {
      "type": "function_call",
      "call_id": "call_xyz789",
      "name": "getCurrentWeather",
      "arguments": "{\"location\": \"Dar es Salaam, Tanzania\", \"unit\": \"c\"}"
    }
  ]
}

Po przetworzeniu wywołania funkcji i przekazaniu wyników agentowi ostateczna odpowiedź zawiera informacje o pogodzie w języku naturalnym.

Skorzystaj z poniższego przykładu kodu, aby utworzyć agenta z narzędziami funkcji, obsługiwać wywołania funkcji z modelu i udostępniać wyniki funkcji, aby uzyskać ostateczną odpowiedź.

import { DefaultAzureCredential } from "@azure/identity";
import { AIProjectClient } from "@azure/ai-projects";
import "dotenv/config";

const projectEndpoint = process.env["FOUNDRY_PROJECT_ENDPOINT"] || "<project endpoint>";
const deploymentName = process.env["FOUNDRY_MODEL_DEPLOYMENT_NAME"] || "<model deployment name>";

/**
 * Define a function tool for the model to use
 */
const funcTool = {
  type: "function" as const,
  name: "get_horoscope",
  description: "Get today's horoscope for an astrological sign.",
  strict: true,
  parameters: {
    type: "object",
    properties: {
      sign: {
        type: "string",
        description: "An astrological sign like Taurus or Aquarius",
      },
    },
    required: ["sign"],
    additionalProperties: false,
  },
};

/**
 * Generate a horoscope for the given astrological sign.
 */
function getHoroscope(sign: string): string {
  return `${sign}: Next Tuesday you will befriend a baby otter.`;
}

export async function main(): Promise<void> {
  // Create AI Project client
  const project = new AIProjectClient(projectEndpoint, new DefaultAzureCredential());
  const openAIClient = await project.getOpenAIClient();

  // Create agent with function tools
  console.log("Creating agent with function tools...");
  const agent = await project.agents.createVersion("function-tool-agent", {
    kind: "prompt",
    model: deploymentName,
    instructions: "You are a helpful assistant that can use function tools.",
    tools: [funcTool],
  });
  console.log(`Agent created (id: ${agent.id}, name: ${agent.name}, version: ${agent.version})`);

  // Prompt the model with tools defined
  console.log("\nGenerating initial response...");
  const response = await openAIClient.responses.create(
    {
      input: [
        {
          type: "message",
          role: "user",
          content: "What is my horoscope? I am an Aquarius.",
        },
      ],
    },
    {
      body: { agent: { name: agent.name, type: "agent_reference" } },
    },
  );
  console.log(`Response output: ${response.output_text}`);

  // Process function calls
  const inputList: Array<{
    type: "function_call_output";
    call_id: string;
    output: string;
  }> = [];

  for (const item of response.output) {
    if (item.type === "function_call") {
      if (item.name === "get_horoscope") {
        // Parse the function arguments
        const args = JSON.parse(item.arguments);

        // Execute the function logic for get_horoscope
        const horoscope = getHoroscope(args.sign);

        // Provide function call results to the model
        inputList.push({
          type: "function_call_output",
          call_id: item.call_id,
          output: JSON.stringify({ horoscope }),
        });
      }
    }
  }

  console.log("\nFinal input:");
  console.log(JSON.stringify(inputList, null, 2));

  // Submit function results to get final response
  const finalResponse = await openAIClient.responses.create(
    {
      input: inputList,
      previous_response_id: response.id,
    },
    {
      body: { agent: { name: agent.name, type: "agent_reference" } },
    },
  );

  // The model should be able to give a response!
  console.log("\nFinal output:");
  console.log(finalResponse.output_text);

  // Clean up
  console.log("\nCleaning up resources...");
  await project.agents.deleteVersion(agent.name, agent.version);
  console.log("Agent deleted");
}

main().catch((err) => {
  console.error("The sample encountered an error:", err);
});

Oczekiwane dane wyjściowe

W poniższym przykładzie przedstawiono oczekiwane dane wyjściowe:

Creating agent with function tools...
Agent created (id: <agent-id>, name: function-tool-agent, version: <version>)

Generating initial response...
Response output: 

Final input:
[
  {
    "type": "function_call_output",
    "call_id": "call_abc123",
    "output": "{\"horoscope\":\"Aquarius: Next Tuesday you will befriend a baby otter.\"}"
  }
]

Final output:
Your horoscope for Aquarius: Next Tuesday you will befriend a baby otter.

Cleaning up resources...
Agent deleted

Sprawdzanie, czy wywołanie funkcji działa

Użyj tych testów, aby potwierdzić, że wywołanie funkcji działa:

  1. Pierwsza odpowiedź zawiera element wyjściowy z type ustawionym do function_call.
  2. Aplikacja wykonuje żądaną funkcję przy użyciu zwracanych argumentów.
  3. Aplikacja przesyła odpowiedź, która zawiera function_call_output element i odwołuje się do poprzedniej odpowiedzi, a agent zwraca odpowiedź w języku naturalnym.

Jeśli używasz śledzenia w narzędziu Microsoft Foundry, potwierdź, że wystąpiło wywołanie narzędzia. Aby uzyskać wskazówki dotyczące walidacji wywołania narzędzia i kontrolowania użycia narzędzi, zobacz Najlepsze rozwiązania dotyczące używania narzędzi w usłudze Microsoft Foundry Agent.

Zagadnienia dotyczące zabezpieczeń i danych

  • Traktuj argumenty narzędzi i dane wyjściowe narzędzia jako niezaufane dane wejściowe. Przed ich użyciem zweryfikuj i oczyść wartości.
  • Nie przekazuj danych poufnych (kluczy interfejsu API, tokenów, parametrów połączenia) w danych wyjściowych narzędzia. Zwracanie tylko danych, których potrzebuje model.
  • Zastosuj zasadę najmniejszych uprawnień do tożsamości używanej przez DefaultAzureCredential.
  • Unikaj skutków ubocznych, chyba że jawnie je zamierzasz. Na przykład ogranicz narzędzia funkcji do bezpiecznych operacji lub wymagają jawnego potwierdzenia użytkownika dla akcji, które zmieniają dane.
  • W przypadku długotrwałych operacji zwróć stan natychmiast i zaimplementuj sondowanie. Wygaśnięcie 10-minutowego przebiegu dotyczy całkowitego czasu upłynięcia, a nie pojedynczego wykonania funkcji.

Rozwiązywanie problemów

Problematyka Prawdopodobna przyczyna Rezolucja
Agent zwraca wywołanie funkcji, ale nie ma ostatecznej odpowiedzi. Dane wyjściowe narzędzia nie są zwracane do modelu. Wykonaj funkcję, a następnie wywołaj responses.create z danymi wyjściowymi narzędzia i previous_response_id aby kontynuować.
Nie ma wywołania funkcji. Funkcja nie jest w definicji agenta lub ma słabe nazewnictwo. Zweryfikuj, czy narzędzie funkcyjne zostało dodane do agenta. Użyj jasnych, opisowych nazw i opisów parametrów.
Argumenty nie są prawidłowym kodem JSON. Niezgodność schematu lub halucynacja modelu. Sprawdź, czy schemat JSON używa poprawnych typów i wymaganych właściwości. Radzenie sobie z błędami podczas analizowania w aplikacji.
Brak wymaganych pól. Schemat nie wymusza wymaganych właściwości. Dodaj "required": [...] tablicę do schematu parametrów. Ustaw strict: true dla bardziej rygorystycznej weryfikacji.
Dane wyjściowe narzędzia nie działają z powodu wygaśnięcia. Przebieg wygasł (limit 10 minut). Szybko zwracaj wyniki narzędzia. W przypadku wolnych operacji zwróć stan i sprawdzaj okresowo oddzielnie.
Funkcja wywoływana z nieprawidłowymi parametrami. Niejednoznaczny opis funkcji. Popraw pole funkcji description . Dodaj szczegółowe opisy parametrów z przykładami.
Wiele wywołań funkcji w jednej odpowiedzi. Model określił wiele potrzebnych funkcji. Obsłuż każde wywołanie funkcji w tablicy wyjściowej. Zwróć wszystkie wyniki w jednym responses.create wywołaniu.
Funkcja nie jest widoczna w portalu Foundry. Portal nie wykonuje wywołań funkcji. Przetestuj wywołanie funkcji za pomocą zestawu SDK lub interfejsu API REST. Portal pokazuje agentów, ale nie wywołuje funkcji.

Uprzątnij zasoby

Po zakończeniu testowania usuń utworzone zasoby, aby uniknąć bieżących kosztów.

Usuń agenta:

curl -X DELETE "$FOUNDRY_PROJECT_ENDPOINT/agents/<AGENT_NAME>-function-calling?api-version=v1" \
  -H "Authorization: Bearer $AGENT_TOKEN"

Usuń konwersację:

curl -X DELETE "$FOUNDRY_PROJECT_ENDPOINT/openai/v1/conversations/<CONVERSATION_ID>" \
  -H "Authorization: Bearer $AGENT_TOKEN"

Treści powiązane

  • Last updated on