Partager via

Utiliser l’appel de fonction avec des agents de Microsoft Foundry

Les agents Microsoft Foundry prennent en charge l’appel de fonction, ce qui vous permet d’étendre des agents avec des fonctionnalités personnalisées. Définissez une fonction avec son nom, ses paramètres et sa description, et l’agent peut demander à votre application de l’appeler. Votre application exécute la fonction et retourne la sortie. L’agent utilise ensuite le résultat pour poursuivre la conversation avec des données précises et en temps réel de vos systèmes.

Important

Les sessions d'exécution expirent 10 minutes après leur création. Envoyez vos sorties d’outil avant leur expiration.

Vous pouvez exécuter des agents avec des outils de fonction dans le portail Microsoft Foundry. Toutefois, le portail ne prend pas en charge l’ajout, la suppression ou la mise à jour des définitions de fonction sur un agent. Utilisez le Kit de développement logiciel (SDK) ou l’API REST pour configurer les outils de fonction.

Assistance à l'utilisation

✔️ (GA) indique une disponibilité générale, ✔️ (préversion) indique un aperçu public et un tiret (-) indique que la fonctionnalité n’est pas disponible.

Support de Microsoft Foundry SDK Python Kit de développement logiciel (SDK) C# Kit de développement logiciel (SDK) JavaScript Kit de développement logiciel (SDK) Java API REST Configuration d’agent de base Configuration d’agent standard
✔️ ✔️ (GA) ✔️ (Préversion) ✔️ (GA) ✔️ (Préversion) ✔️ (GA) ✔️ ✔️

Prerequisites

Avant de commencer, vérifiez que vous disposez des points suivants :

  • Environnement d’agent de base ou standard.

  • Un projet Foundry et un modèle déployé.

  • Package sdk pour votre langue :

    • Python : azure-ai-projects (dernière version)
    • .NET : Azure.AI.Extensions.OpenAI (préversion)
    • TypeScript : @azure/ai-projects (dernière version)
    • Java : azure-ai-agents (préversion)

    Pour connaître les étapes d’installation et d’authentification, consultez le guide de démarrage rapide.

Conseil / Astuce

Si vous utilisez DefaultAzureCredential, connectez-vous à l’aide de az login avant d’exécuter les exemples.

Créer un agent avec des outils de fonction

L’appel de fonction suit ce modèle :

  1. Définir des outils de fonction : décrivez le nom, les paramètres et l’objectif de chaque fonction.
  2. Créez un agent : inscrivez l’agent avec vos définitions de fonction.
  3. Envoyer une invite : l’agent analyse l’invite et demande des appels de fonction si nécessaire.
  4. Exécuter et retourner : votre application exécute la fonction et renvoie la sortie à l’agent.
  5. Obtenez la réponse finale : l’agent utilise votre sortie de fonction pour terminer sa réponse.

Utilisez l’exemple de code suivant pour créer un agent, gérer un appel de fonction et retourner la sortie de l’outil à l’agent.

import json
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

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."

# Format: "https://resource_name.ai.azure.com/api/projects/project_name"
PROJECT_ENDPOINT = "your_project_endpoint"

project = AIProjectClient(
    endpoint=PROJECT_ENDPOINT,
    credential=DefaultAzureCredential(),
)
openai = project.get_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.agents.create_version(
    agent_name="MyAgent",
    definition=PromptAgentDefinition(
        model="gpt-5-mini",
        instructions="You are a helpful assistant that can use function tools.",
        tools=tools,
    ),
)

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

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}),
                )
            )

# Submit function results and get the final response
response = openai.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}")

# Clean up resources
project.agents.delete_version(agent_name=agent.name, agent_version=agent.version)

Sortie attendue

L’exemple suivant illustre la sortie attendue :

Agent response: Your horoscope for Aquarius: Next Tuesday you will befriend a baby otter.

Utiliser des agents avec l’exemple de fonctions

Dans cet exemple, vous utilisez des fonctions locales avec des agents. Utilisez les fonctions pour fournir aux agents des informations spécifiques en réponse à une question utilisateur. Le code de cet exemple est synchrone. Pour obtenir un exemple asynchrone, consultez l’exemple de code sample dans le Azure SDK pour .NET référentiel sur GitHub.

using System;
using Azure.AI.Projects;
using Azure.AI.Extensions.OpenAI;
using Azure.Identity;

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;
    }

    // Format: "https://resource_name.ai.azure.com/api/projects/project_name"
    private const string ProjectEndpoint = "your_project_endpoint";

    public static void Main() 
    {
        AIProjectClient projectClient = new(endpoint: new Uri(ProjectEndpoint), tokenProvider: new DefaultAzureCredential());
        // Create an agent version with the defined functions as tools.
        PromptAgentDefinition agentDefinition = new(model: "gpt-5-mini")
        {
            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);
    }
}

Sortie attendue

L’exemple suivant illustre la sortie attendue :

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

Il existe deux façons d’utiliser l’appel de fonction dans le service agent Foundry.

  1. Créer un response. Lorsque vous avez besoin que l’agent appelle à nouveau des fonctions, créez un autre response.
  2. Créez un conversation, puis créez plusieurs éléments de conversation. Chaque élément de conversation correspond à un response.

Définissez les variables d’environnement suivantes avant d’exécuter les exemples :

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

Définir une fonction que votre agent va appeler

Commencez par définir une fonction que votre agent doit appeler. Lorsque vous créez une fonction pour qu’un agent appelle, décrivez sa structure et tous les paramètres requis dans une documentation. Pour obtenir des exemples de fonctions, consultez les autres langages du Kit de développement logiciel (SDK).

Créer un agent

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

Créer une conversation

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?"
          }
        ]
      }
    ]
  }'

Enregistrez l’ID de conversation retourné (conv_xyz...) pour l’étape suivante.

Créer une réponse

Remplacez <CONVERSATION_ID> par l’ID de l’étape précédente.

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": []
  }'

Sortie attendue

La réponse contient un élément d’appel de fonction que vous devez traiter :

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

Après avoir traité l’appel de fonction et fourni la sortie à l’agent, la réponse finale inclut les informations météorologiques en langage naturel.

Envoyer la sortie de l’appel de fonction

Après avoir traité l’appel de fonction localement, envoyez le résultat à l’agent :

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": [
      {
        "type": "function_call_output",
        "call_id": "<CALL_ID>",
        "output": "{\"temperature\": \"30\", \"unit\": \"c\", \"description\": \"Sunny\"}"
      }
    ]
  }'

Remplacez <CALL_ID> par la call_id valeur de l’appel de fonction dans la réponse précédente. L’agent utilise la sortie de la fonction pour générer une réponse en langage naturel.

Utilisez l’exemple de code suivant pour créer un agent avec des outils de fonction, gérer les appels de fonction à partir du modèle et fournir des résultats de fonction pour obtenir la réponse finale.

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

// Format: "https://resource_name.ai.azure.com/api/projects/project_name"
const projectEndpoint = "your_project_endpoint";

/**
 * 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 openai = project.getOpenAIClient();

  // Create agent with function tools
  const agent = await project.agents.createVersion("function-tool-agent", {
    kind: "prompt",
    model: "gpt-5-mini",
    instructions: "You are a helpful assistant that can use function tools.",
    tools: [funcTool],
  });

  // Prompt the model with tools defined
  const response = await openai.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 }),
        });
      }
    }
  }

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

  // Print the final response
  console.log(finalResponse.output_text);

  // Clean up
  await project.agents.deleteVersion(agent.name, agent.version);
}

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

Sortie attendue

L’exemple suivant illustre la sortie attendue :

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

Utiliser l’appel de fonction dans un agent Java

Configurer

Ajoutez la dépendance à votre pom.xml:

<dependency>
    <groupId>com.azure</groupId>
    <artifactId>azure-ai-agents</artifactId>
    <version>2.0.0-beta.1</version>
</dependency>

Créer un agent avec des outils de fonction

import com.azure.ai.agents.AgentsClient;
import com.azure.ai.agents.AgentsClientBuilder;
import com.azure.ai.agents.ResponsesClient;
import com.azure.ai.agents.models.AgentReference;
import com.azure.ai.agents.models.AgentVersionDetails;
import com.azure.ai.agents.models.FunctionTool;
import com.azure.ai.agents.models.PromptAgentDefinition;
import com.azure.core.util.BinaryData;
import com.azure.identity.DefaultAzureCredentialBuilder;
import com.openai.models.responses.Response;
import com.openai.models.responses.ResponseCreateParams;

import java.util.Arrays;
import java.util.HashMap;
import java.util.Map;

public class FunctionCallingExample {
    // Format: "https://resource_name.ai.azure.com/api/projects/project_name"
    private static final String PROJECT_ENDPOINT = "your_project_endpoint";

    public static void main(String[] args) {
        AgentsClientBuilder builder = new AgentsClientBuilder()
            .credential(new DefaultAzureCredentialBuilder().build())
            .endpoint(PROJECT_ENDPOINT);

        AgentsClient agentsClient = builder.buildAgentsClient();
        ResponsesClient responsesClient = builder.buildResponsesClient();

        // Define function parameters
        Map<String, BinaryData> parameters = new HashMap<>();
        parameters.put("type", BinaryData.fromString("\"object\""));
        parameters.put("properties", BinaryData.fromString(
            "{\"location\":{\"type\":\"string\",\"description\":\"The city and state, e.g. Seattle, WA\"},"
            + "\"unit\":{\"type\":\"string\",\"enum\":[\"celsius\",\"fahrenheit\"]}}"));
        parameters.put("required", BinaryData.fromString("[\"location\"]"));

        FunctionTool weatherFunction = new FunctionTool("get_weather", parameters, true);

        // Create agent with function tool
        PromptAgentDefinition agentDefinition = new PromptAgentDefinition("gpt-5-mini")
            .setInstructions("You are a weather assistant. Use the get_weather function to retrieve weather information.")
            .setTools(Arrays.asList(weatherFunction));

        AgentVersionDetails agent = agentsClient.createAgentVersion("function-calling-agent", agentDefinition);
        System.out.printf("Agent created: %s (version %s)%n", agent.getName(), agent.getVersion());

        // Create a response - the agent will call the function
        AgentReference agentReference = new AgentReference(agent.getName())
            .setVersion(agent.getVersion());

        Response response = responsesClient.createWithAgent(
            agentReference,
            ResponseCreateParams.builder()
                .input("What is the weather in Seattle?"));

        System.out.println("Response: " + response.output());

        // Clean up
        agentsClient.deleteAgentVersion(agent.getName(), agent.getVersion());
    }
}

Pour obtenir la boucle d’appel de fonction complète qui gère l’appel de l’outil et renvoie les résultats à l’agent, veuillez consulter les exemples du SDK Java Azure AI Agents..

Vérifier que l’appel de fonction fonctionne

Utilisez ces vérifications pour confirmer que l’appel de fonction fonctionne :

  1. Votre première réponse contient un élément de sortie avec type défini sur function_call.
  2. Votre application exécute la fonction demandée à l’aide des arguments retournés.
  3. Votre application envoie une réponse de suivi qui inclut un function_call_output élément et fait référence à la réponse précédente, et l’agent retourne une réponse en langage naturel.

Si vous utilisez le suivi dans Microsoft Foundry, vérifiez que l’appel de l’outil s’est produit. Pour obtenir des conseils sur la validation de l’appel d’outils et le contrôle de l’utilisation des outils, consultez les meilleures pratiques pour l’utilisation d’outils dans le service Microsoft Foundry Agent.

Considérations relatives à la sécurité et aux données

  • Traitez les arguments de l’outil et les sorties de l’outil comme une entrée non approuvée. Validez et désinfectez les valeurs avant de les utiliser.
  • Ne transmettez pas de secrets (clés API, jetons, chaînes de connexion) dans la sortie de l’outil. Retournez uniquement les données dont le modèle a besoin.
  • Appliquez le privilège minimum à l’identité utilisée par DefaultAzureCredential.
  • Évitez les effets secondaires, sauf si vous les prévoyez explicitement. Par exemple, limitez les outils de fonction aux opérations sécurisées ou exigez une confirmation explicite de l’utilisateur pour les actions qui modifient les données.
  • Pour les opérations de longue durée, retournez immédiatement un état et implémentez la technique de sondage. La limite d'expiration de 10 minutes s'applique au temps écoulé total, mais pas à l'exécution de chaque fonction individuellement.

Résolution des problèmes

Problème Cause probable Résolution
L’agent retourne l’appel de fonction, mais aucune réponse finale. La sortie de l’outil n’est pas renvoyée au modèle. Exécutez la fonction, puis appelez responses.create avec la sortie de l’outil et previous_response_id pour continuer.
Aucun appel de fonction n’a lieu. Fonction absente de la définition de l’agent ou nomenclature médiocre. Vérifiez que l’outil de fonction est ajouté à l’agent. Utilisez des noms clairs, descriptifs et des descriptions de paramètres.
Les arguments ne sont pas valides JSON. Incompatibilité de schéma ou hallucination de modèle. Vérifiez que le schéma JSON utilise des types corrects et des propriétés requises. Gérez les erreurs d’analyse correctement dans votre application.
Les champs obligatoires sont manquants. Le schéma n’applique pas les propriétés requises. Ajoutez un tableau "required": [...] à votre schéma de paramètre. Définir strict: true pour une validation plus stricte.
Les résultats de l'outil échouent en raison de l'expiration. Exécution expirée (limite de 10 minutes). Retournez rapidement les résultats de l’Outil. Pour les opérations lentes, renvoyez un statut et effectuez un sondage séparément.
Fonction appelée avec des paramètres incorrects. Description de la fonction ambiguë. Améliorez le champ de fonction description . Ajoutez des descriptions détaillées des paramètres avec des exemples.
Appels de fonction multiples en une seule réponse. Le modèle a déterminé plusieurs fonctions nécessaires. Gérez chaque appel de fonction dans le tableau de sortie. Retourne tous les résultats dans un seul responses.create appel.
Fonction non visible dans le portail Foundry. Le portail n’exécute pas d’appels de fonction. Testez l’appel de fonction via le Kit de développement logiciel (SDK) ou l’API REST. Le portail affiche les agents, mais n’appelle pas de fonctions.

Nettoyer les ressources

Lorsque vous avez terminé le test, supprimez les ressources que vous avez créées pour éviter les coûts continus.

Supprimez l’agent :

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

Supprimez la conversation :

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

Contenu connexe

  • Last updated on