Exploration du noyau sémantique `AzureAIAgent`

2025-05-28

Important

Cette fonctionnalité est à l’étape expérimentale. Les fonctionnalités à ce stade sont en cours de développement et soumises à des modifications avant de passer à la phase de préversion ou de version candidate.

Conseil / Astuce

La documentation détaillée de l’API relative à cette discussion est disponible à l’adresse suivante :

AzureAIAgent

Conseil / Astuce

La documentation détaillée de l’API relative à cette discussion est disponible à l’adresse suivante :

AzureAIAgent

Qu’est-ce qu’un `AzureAIAgent`?

Un AzureAIAgent est un agent spécialisé dans l’infrastructure de noyau sémantique, conçu pour fournir des fonctionnalités conversationnelles avancées avec une intégration transparente des outils. Il automatise l’appel d’outils, éliminant ainsi la nécessité d’analyser et d’appeler manuellement. L’agent gère également en toute sécurité l’historique des conversations à l’aide de threads, réduisant ainsi la charge de la gestion de l'état. En outre, le AzureAIAgent prend en charge un large éventail d’outils intégrés, notamment la récupération de fichiers, l’exécution du code et l’interaction des données via Bing, Azure AI Search, Azure Functions et OpenAPI.

Pour utiliser un AzureAIAgent, un projet Azure AI Foundry doit être utilisé. Les articles suivants fournissent une vue d’ensemble d’Azure AI Foundry, de la création et de la configuration d’un projet et du service d’agent :

Préparation de votre environnement de développement

Pour poursuivre le développement d’un AzureAIAgent, configurez votre environnement de développement avec les packages appropriés.

Ajoutez le package Microsoft.SemanticKernel.Agents.AzureAI à votre projet :

dotnet add package Microsoft.SemanticKernel.Agents.AzureAI --prerelease

Vous pouvez également inclure le package Azure.Identity :

dotnet add package Azure.Identity

Installez le package semantic-kernel :

pip install semantic-kernel

Configuration du client de projet IA

L'accès à un AzureAIAgent nécessite d'abord la création d'un client configuré pour un projet Foundry spécifique, le plus souvent en fournissant votre point de terminaison de projet (Kit de développement logiciel (SDK) Azure AI Foundry : Prise en main des projets).

PersistentAgentsClient client = AzureAIAgent.CreateAgentsClient("<your endpoint>", new AzureCliCredential());

Modifiez le fichier .env dans le répertoire racine pour inclure :

AZURE_AI_AGENT_ENDPOINT = "<example-endpoint>"
AZURE_AI_AGENT_MODEL_DEPLOYMENT_NAME = "<example-model-deployment-name>"

Une fois la configuration définie, le client peut être créé :

from semantic_kernel.agents import AzureAIAgent

async with (
    DefaultAzureCredential() as creds,
    AzureAIAgent.create_client(credential=creds) as client,
):
    # Your operational code here

Le sous-jacent endpoint sera récupéré par les paramètres Pydantic s’il est configuré. Sinon, vous pouvez le transmettre explicitement à la méthode create_client() :

from semantic_kernel.agents import AzureAIAgent

async with (
    DefaultAzureCredential() as creds,
    AzureAIAgent.create_client(credential=creds, endpoint="<your-endpoint>") as client,
):
    # Your operational code here

Création d’un `AzureAIAgent`

Pour créer un AzureAIAgentfichier , vous commencez par configurer et initialiser le projet Foundry via le service Azure Agent, puis l’intégrer au noyau sémantique :

PersistentAgentsClient client = AzureAIAgent.CreateAgentsClient("<your endpoint>", new AzureCliCredential());

// 1. Define an agent on the Azure AI agent service
PersistentAgent definition = await agentsClient.Administration.CreateAgentAsync(
    "<name of the the model used by the agent>",
    name: "<agent name>",
    description: "<agent description>",
    instructions: "<agent instructions>");

// 2. Create a Semantic Kernel agent based on the agent definition
AzureAIAgent agent = new(definition, agentsClient);

from azure.identity.aio import DefaultAzureCredential
from semantic_kernel.agents import AzureAIAgent, AzureAIAgentSettings

async with (
    DefaultAzureCredential() as creds,
    AzureAIAgent.create_client(credential=creds) as client,
):
    # 1. Define an agent on the Azure AI agent service
    agent_definition = await client.agents.create_agent(
        model=AzureAIAgentSettings().model_deployment_name,
        name="<name>",
        instructions="<instructions>",
    )

    # 2. Create a Semantic Kernel agent based on the agent definition
    agent = AzureAIAgent(
        client=client,
        definition=agent_definition,
    )

Interaction avec un `AzureAIAgent`

L’interaction avec le AzureAIAgent est simple. L’agent gère automatiquement l’historique des conversations à l’aide d’un thread.

Les spécificités du thread Azure AI Agent sont extraites par le biais de la Microsoft.SemanticKernel.Agents.AzureAI.AzureAIAgentThread classe, qui est une implémentation de Microsoft.SemanticKernel.Agents.AgentThread.

Important

Notez que le Kit de développement logiciel (SDK) Azure AI Agents a la PersistentAgentThread classe. Il ne doit pas être confondu avec Microsoft.SemanticKernel.Agents.AgentThreadl’abstraction commune des agents de noyau sémantique pour tous les types de threads.

Actuellement, le AzureAIAgent prend uniquement en charge les fils de type AzureAIAgentThread.

AzureAIAgentThread agentThread = new(agent.Client);
try
{
    ChatMessageContent message = new(AuthorRole.User, "<your user input>");
    await foreach (ChatMessageContent response in agent.InvokeAsync(message, agentThread))
    {
        Console.WriteLine(response.Content);
    }
}
finally
{
    await agentThread.DeleteAsync();
    await agent.Client.DeleteAgentAsync(agent.Id);
}

Les spécificités du thread Azure AI Agent sont extraites par le biais de la AzureAIAgentThread classe, qui est une implémentation de AgentThread.

USER_INPUTS = ["Hello", "What's your name?"]

thread: AzureAIAgentThread = AzureAIAgentThread()

try:
    for user_input in USER_INPUTS:
        response = await agent.get_response(messages=user_inputs, thread=thread)
        print(response)
        thread = response.thread
finally:
    await thread.delete() if thread else None

Si vous le souhaitez, un agent peut être appelé comme suit :

for user_input in USER_INPUTS:
    async for content in agent.invoke(messages=user_input, thread=thread):
        print(content.content)
        thread = response.thread

Vous pouvez également transmettre une liste de messages aux méthodes get_response(...), invoke(...) ou invoke_stream(...).

USER_INPUTS = ["Hello", "What's your name?"]

thread: AzureAIAgentThread = AzureAIAgentThread()

try:
    for user_input in USER_INPUTS:
        response = await agent.get_response(messages=USER_INPUTS, thread=thread)
        print(response)
        thread = response.thread
finally:
    await thread.delete() if thread else None

Un agent peut également produire une réponse diffusée en continu :

ChatMessageContent message = new(AuthorRole.User, "<your user input>");
await foreach (StreamingChatMessageContent response in agent.InvokeStreamingAsync(message, agentThread))
{
    Console.Write(response.Content);
}

for user_input in USER_INPUTS:
    await agent.add_chat_message(thread_id=thread.id, message=user_input)
    async for content in agent.invoke_stream(thread_id=thread.id):
        print(content.content, end="", flush=True)

Utilisation de plug-ins avec un `AzureAIAgent`

Le noyau sémantique prend en charge l’extension d’un AzureAIAgent avec des plug-ins personnalisés pour des fonctionnalités améliorées :

KernelPlugin plugin = KernelPluginFactory.CreateFromType<YourPlugin>();
PersistentAgentsClient client = AzureAIAgent.CreateAgentsClient("<your endpoint>", new AzureCliCredential());

PersistentAgent definition = await agentsClient.Administration.CreateAgentAsync(
    "<name of the the model used by the agent>",
    name: "<agent name>",
    description: "<agent description>",
    instructions: "<agent instructions>");

AzureAIAgent agent = new(definition, agentsClient, plugins: [plugin]);

from semantic_kernel.functions import kernel_function

class SamplePlugin:
    @kernel_function(description="Provides sample data.")
    def get_data(self) -> str:
        return "Sample data"

async with (
        DefaultAzureCredential() as creds,
        AzureAIAgent.create_client(credential=creds) as client,
    ):
        agent_definition = await client.agents.create_agent(
            model=AzureAIAgentSettings().model_deployment_name,
        )

        agent = AzureAIAgent(
            client=client,
            definition=agent_definition,
            plugins=[SamplePlugin()]
        )

Fonctionnalités avancées

Un AzureAIAgent peut tirer parti d’outils avancés tels que :

Interpréteur de code
Recherche de fichiers
Intégration OpenAPI
intégration d’Azure AI Search
Bing Grounding

Interpréteur de code

L’interpréteur de code permet aux agents d’écrire et d’exécuter du code Python dans un environnement d’exécution en bac à sable (interpréteur de code du service Azure AI Agent).

PersistentAgentsClient client = AzureAIAgent.CreateAgentsClient("<your endpoint>", new AzureCliCredential());

PersistentAgent definition = await agentsClient.CreateAgentAsync(
    "<name of the the model used by the agent>",
    name: "<agent name>",
    description: "<agent description>",
    instructions: "<agent instructions>",
    tools: [new CodeInterpreterToolDefinition()],
    toolResources:
        new()
        {
            CodeInterpreter = new()
            {
                FileIds = { ... },
            }
        }));

AzureAIAgent agent = new(definition, agentsClient);

from azure.ai.agents.models import CodeInterpreterTool

async with (
        DefaultAzureCredential() as creds,
        AzureAIAgent.create_client(credential=creds) as client,
    ):
        code_interpreter = CodeInterpreterTool()
        agent_definition = await client.agents.create_agent(
            model=ai_agent_settings.model_deployment_name,
            tools=code_interpreter.definitions,
            tool_resources=code_interpreter.resources,
        )

Recherche de fichiers

La recherche de fichiers enrichit les agents avec des connaissances extérieures à leur modèle (Outil de recherche de fichiers du service Azure AI Agent).

PersistentAgentsClient client = AzureAIAgent.CreateAgentsClient("<your endpoint>", new AzureCliCredential());

PersistentAgent definition = await agentsClient.CreateAgentAsync(
    "<name of the the model used by the agent>",
    name: "<agent name>",
    description: "<agent description>",
    instructions: "<agent instructions>",
    tools: [new FileSearchToolDefinition()],
    toolResources:
        new()
        {
            FileSearch = new()
            {
                VectorStoreIds = { ... },
            }
        });

AzureAIAgent agent = new(definition, agentsClient);

from azure.ai.agents.models import FileSearchTool

async with (
        DefaultAzureCredential() as creds,
        AzureAIAgent.create_client(credential=creds) as client,
    ):
        file_search = FileSearchTool(vector_store_ids=[vector_store.id])
        agent_definition = await client.agents.create_agent(
            model=ai_agent_settings.model_deployment_name,
            tools=file_search.definitions,
            tool_resources=file_search.resources,
        )

Intégration OpenAPI

Connecte votre agent à une API externe (How to use Azure AI Agent Service with OpenAPI Specified Tools).

PersistentAgentsClient client = AzureAIAgent.CreateAgentsClient("<your endpoint>", new AzureCliCredential());

string apiJsonSpecification = ...; // An Open API JSON specification

PersistentAgent definition = await agentsClient.CreateAgentAsync(
    "<name of the the model used by the agent>",
    name: "<agent name>",
    description: "<agent description>",
    instructions: "<agent instructions>",
    tools: [
        new OpenApiToolDefinition(
            "<api name>", 
            "<api description>", 
            BinaryData.FromString(apiJsonSpecification), 
            new OpenApiAnonymousAuthDetails())
    ]
);

AzureAIAgent agent = new(definition, agentsClient);

from azure.ai.agents.models import OpenApiTool, OpenApiAnonymousAuthDetails

async with (
    DefaultAzureCredential() as creds,
    AzureAIAgent.create_client(credential=creds) as client,
):
    openapi_spec_file_path = "sample/filepath/..."
    with open(os.path.join(openapi_spec_file_path, "spec_one.json")) as file_one:
        openapi_spec_one = json.loads(file_one.read())
    with open(os.path.join(openapi_spec_file_path, "spec_two.json")) as file_two:
        openapi_spec_two = json.loads(file_two.read())

    # Note that connection or managed identity auth setup requires additional setup in Azure
    auth = OpenApiAnonymousAuthDetails()
    openapi_tool_one = OpenApiTool(
        name="<name>",
        spec=openapi_spec_one,
        description="<description>",
        auth=auth,
    )
    openapi_tool_two = OpenApiTool(
        name="<name>",
        spec=openapi_spec_two,
        description="<description>",
        auth=auth,
    )

    agent_definition = await client.agents.create_agent(
        model=ai_agent_settings.model_deployment_name,
        tools=openapi_tool_one.definitions + openapi_tool_two.definitions,
    )

Intégration de la recherche Azure AI

Utiliser un index Azure AI Search existant avec votre agent (Utiliser un index Azure AI Search existant).

PersistentAgentsClient client = AzureAIAgent.CreateAgentsClient("<your endpoint>", new AzureCliCredential());

PersistentAgent definition = await agentsClient.CreateAgentAsync(
    "<name of the the model used by the agent>",
    name: "<agent name>",
    description: "<agent description>",
    instructions: "<agent instructions>",
    tools: [new AzureAISearchToolDefinition()],
    toolResources: new()
    {
        AzureAISearch = new()
        {
            IndexList = { new AISearchIndexResource("<your connection id>", "<your index name>") }
        }
    });

AzureAIAgent agent = new(definition, agentsClient);

from azure.ai.agents.models import AzureAISearchTool, ConnectionType

async with (
    DefaultAzureCredential() as creds,
    AzureAIAgent.create_client(credential=creds) as client,
):
    conn_list = await client.connections.list()

    ai_search_conn_id = ""
    for conn in conn_list:
        if conn.connection_type == ConnectionType.AZURE_AI_SEARCH:
            ai_search_conn_id = conn.id
            break

    ai_search = AzureAISearchTool(
        index_connection_id=ai_search_conn_id, 
        index_name=AZURE_AI_SEARCH_INDEX_NAME,
    )

    agent_definition = await client.agents.create_agent(
        model=ai_agent_settings.model_deployment_name,
        instructions="Answer questions using your index.",
        tools=ai_search.definitions,
        tool_resources=ai_search.resources,
        headers={"x-ms-enable-preview": "true"},
    )

Bing Grounding

from azure.ai.agents.models import BingGroundingTool
from azure.identity.aio import DefaultAzureCredential

from semantic_kernel.agents import AzureAIAgent, AzureAIAgentSettings

async with (
    DefaultAzureCredential() as creds,
    AzureAIAgent.create_client(credential=creds) as client,
):
    # 1. Enter your Bing Grounding Connection Name
    bing_connection = await client.connections.get(connection_name="<your-bing-grounding-connection-name>")
    conn_id = bing_connection.id

    # 2. Initialize agent bing tool and add the connection id
    bing_grounding = BingGroundingTool(connection_id=conn_id)

    # 3. Create an agent with Bing grounding on the Azure AI agent service
    agent_definition = await client.agents.create_agent(
        name="BingGroundingAgent",
        instructions="Use the Bing grounding tool to answer the user's question.",
        model=AzureAIAgentSettings().model_deployment_name,
        tools=bing_grounding.definitions,
    )

    # 4. Create a Semantic Kernel agent for the Azure AI agent
    agent = AzureAIAgent(
        client=client,
        definition=agent_definition,
    )

Lorsque vous utilisez l'outil Bing Grounding, le FunctionCallContent qui est passé au rappel on_intermediate_message aura son nom de fonction défini sur "bing_grounding". Une fois l’exécution terminée, la ChatMessageContent.items liste inclura soit AnnotationContent, soit StreamingAnnotationContent, selon que l’appel est standard ou en streaming. Ces éléments d’annotation contiennent des informations sur les liens visités par l’agent pendant la réponse, comme les informations présentes dans le FunctionCallContent.

Pour plus d’informations, consultez les exemples de concept suivants :

Récupération d’un `AzureAIAgent` existant

Un agent existant peut être récupéré et réutilisé en spécifiant son ID d’assistant :

PersistentAgent definition = await agentsClient.Administration.GetAgentAsync("<your agent id>");
AzureAIAgent agent = new(definition, agentsClient);

agent_definition = await client.agents.get_agent(assistant_id="your-agent-id")
agent = AzureAIAgent(client=client, definition=agent_definition)

Suppression d’un `AzureAIAgent`

Les agents et leurs threads associés peuvent être supprimés lorsqu'ils ne sont plus nécessaires.

await agentThread.DeleteAsync();
await agentsClient.Administration.DeleteAgentAsync(agent.Id);

await client.agents.delete_thread(thread.id)
await client.agents.delete_agent(agent.id)

Si vous utilisez un magasin de vecteurs ou des fichiers, ils peuvent également être supprimés :

await agentsClient.VectorStores.DeleteVectorStoreAsync("<your store id>");
await agentsClient.Files.DeleteFileAsync("<your file id>");

await client.agents.files.delete(file_id=file.id)
await client.agents.vector_stores.delete(vector_store_id=vector_store.id)

Comment faire

Pour obtenir des exemples pratiques d’utilisation d’un AzureAIAgent, consultez nos exemples de code sur GitHub :

bien démarrer avec les agents Azure AI
exemples de code d’agent Azure AI avancés

bien démarrer avec les agents Azure AI
exemples de code d’agent Azure AI avancés

Gérer les messages intermédiaires avec un `AzureAIAgent`

Le noyau AzureAIAgent sémantique est conçu pour appeler un agent qui répond aux requêtes utilisateur ou aux questions. Pendant l’appel, l’agent peut exécuter des outils pour dériver la réponse finale. Pour accéder aux messages intermédiaires générés pendant ce processus, les appelants peuvent fournir une fonction de rappel qui gère les instances de FunctionCallContent ou FunctionResultContent.

La configuration du on_intermediate_message rappel dans agent.invoke(...) ou agent.invoke_stream(...) permet à l’appelant de recevoir des messages intermédiaires générés pendant le processus de formulation de la réponse finale de l’agent.

import asyncio
from typing import Annotated

from azure.identity.aio import DefaultAzureCredential

from semantic_kernel.agents import AzureAIAgent, AzureAIAgentSettings, AzureAIAgentThread
from semantic_kernel.contents import FunctionCallContent, FunctionResultContent
from semantic_kernel.contents.chat_message_content import ChatMessageContent
from semantic_kernel.functions import kernel_function


# Define a sample plugin for the sample
class MenuPlugin:
    """A sample Menu Plugin used for the concept sample."""

    @kernel_function(description="Provides a list of specials from the menu.")
    def get_specials(self) -> Annotated[str, "Returns the specials from the menu."]:
        return """
        Special Soup: Clam Chowder
        Special Salad: Cobb Salad
        Special Drink: Chai Tea
        """

    @kernel_function(description="Provides the price of the requested menu item.")
    def get_item_price(
        self, menu_item: Annotated[str, "The name of the menu item."]
    ) -> Annotated[str, "Returns the price of the menu item."]:
        return "$9.99"


# This callback function will be called for each intermediate message,
# which will allow one to handle FunctionCallContent and FunctionResultContent.
# If the callback is not provided, the agent will return the final response
# with no intermediate tool call steps.
async def handle_intermediate_steps(message: ChatMessageContent) -> None:
    for item in message.items or []:
        if isinstance(item, FunctionResultContent):
            print(f"Function Result:> {item.result} for function: {item.name}")
        elif isinstance(item, FunctionCallContent):
            print(f"Function Call:> {item.name} with arguments: {item.arguments}")
        else:
            print(f"{item}")


async def main() -> None:
    ai_agent_settings = AzureAIAgentSettings()

    async with (
        DefaultAzureCredential() as creds,
        AzureAIAgent.create_client(credential=creds, endpoint=ai_agent_settings.endpoint) as client,
    ):
        AGENT_NAME = "Host"
        AGENT_INSTRUCTIONS = "Answer questions about the menu."

        # Create agent definition
        agent_definition = await client.agents.create_agent(
            model=ai_agent_settings.deployment_name,
            name=AGENT_NAME,
            instructions=AGENT_INSTRUCTIONS,
        )

        # Create the AzureAI Agent
        agent = AzureAIAgent(
            client=client,
            definition=agent_definition,
            plugins=[MenuPlugin()],  # add the sample plugin to the agent
        )

        # Create a thread for the agent
        # If no thread is provided, a new thread will be
        # created and returned with the initial response
        thread: AzureAIAgentThread = None

        user_inputs = [
            "Hello",
            "What is the special soup?",
            "How much does that cost?",
            "Thank you",
        ]

        try:
            for user_input in user_inputs:
                print(f"# User: '{user_input}'")
                async for response in agent.invoke(
                    messages=user_input,
                    thread=thread,
                    on_intermediate_message=handle_intermediate_steps,
                ):
                    print(f"# Agent: {response}")
                    thread = response.thread
        finally:
            # Cleanup: Delete the thread and agent
            await thread.delete() if thread else None
            await client.agents.delete_agent(agent.id)


if __name__ == "__main__":
    asyncio.run(main())

Voici un exemple de résultat du processus d'invocation de l'agent :

User: 'Hello'
Agent: Hi there! How can I assist you today?
User: 'What is the special soup?'
Function Call:> MenuPlugin-get_specials with arguments: {}
Function Result:> 
        Special Soup: Clam Chowder
        Special Salad: Cobb Salad
        Special Drink: Chai Tea
        for function: MenuPlugin-get_specials
Agent: The special soup is Clam Chowder. Would you like to know anything else about the menu?
User: 'How much does that cost?'
Function Call:> MenuPlugin-get_item_price with arguments: {"menu_item":"Clam Chowder"}
Function Result:> $9.99 for function: MenuPlugin-get_item_price
Agent: The Clam Chowder costs $9.99. Let me know if you would like assistance with anything else!
User: 'Thank you'
Agent: You're welcome! Enjoy your meal! 😊

Spécification déclarative

Important

AzureAIAgent prend en charge l'instanciation à partir d'une spécification déclarative YAML. L’approche déclarative vous permet de définir les propriétés, instructions, configuration du modèle, outils et autres options de l’agent dans un document unique et auditable. Cela rend la composition de l’agent portable et facilement gérée dans les environnements.

Remarque

Tous les outils, fonctions ou plug-ins répertoriés dans le YAML déclaratif doivent être disponibles pour l’agent au moment de la construction. Pour les plug-ins basés sur le noyau, cela signifie qu’ils doivent être inscrits dans le noyau. Pour les outils intégrés tels que Bing Grounding, La recherche de fichiers ou les outils OpenAPI, la configuration et les informations d’identification appropriées doivent être fournies. Le chargeur d’agent ne crée pas de fonctions à partir de zéro. Si un composant requis est manquant, la création de l’agent échoue.

Guide pratique pour utiliser la spécification déclarative

Au lieu d’énumérer toutes les configurations YAML possibles, cette section décrit les principes clés et fournit des liens vers des exemples de concept qui montrent le code complet pour chaque type d’outil. Reportez-vous à ces échantillons de concepts pour des implémentations de bout en bout d'un AzureAIAgent avec des spécifications déclaratives.

Exemple : création d’une instance AzureAIAgent à partir de YAML

Une spécification déclarative YAML minimale peut ressembler à ce qui suit :

type: foundry_agent
name: MyAgent
instructions: Respond politely to the user's questions.
model:
  id: ${AzureAI:ChatModelId}
tools:
  - id: MenuPlugin.get_specials
    type: function
  - id: MenuPlugin.get_item_price
    type: function

Pour plus d’informations sur la façon de connecter l’agent, reportez-vous aux exemples de code complets ci-dessus.

Points clés

Les spécifications déclaratives permettent de définir la structure, les outils et le comportement de l’agent dans YAML.
Tous les outils et plug-ins référencés doivent être inscrits ou accessibles au moment de l’exécution.
Les outils intégrés tels que Bing, Recherche de fichiers et Interpréteur de code nécessitent une configuration et des informations d’identification appropriées (souvent par le biais de variables d’environnement ou d’arguments explicites).
Pour obtenir des exemples complets, consultez les exemples de liens fournis qui illustrent des scénarios pratiques, notamment l’inscription de plug-in, la configuration des identités Azure et l’utilisation d’outils avancés.

Étapes suivantes

Explorer l’Agent Bedrock

Partager via

Exploration du noyau sémantique AzureAIAgent

Qu’est-ce qu’un AzureAIAgent?

Préparation de votre environnement de développement

Configuration du client de projet IA

Création d’un AzureAIAgent

Interaction avec un AzureAIAgent

Utilisation de plug-ins avec un AzureAIAgent

Fonctionnalités avancées

Interpréteur de code

Recherche de fichiers

Intégration OpenAPI

Intégration de la recherche Azure AI

Bing Grounding

Récupération d’un AzureAIAgent existant

Suppression d’un AzureAIAgent

Comment faire

Gérer les messages intermédiaires avec un AzureAIAgent

Spécification déclarative

Guide pratique pour utiliser la spécification déclarative

Exemple : création d’une instance AzureAIAgent à partir de YAML

Points clés

Étapes suivantes

Ressources supplémentaires

Exploration du noyau sémantique `AzureAIAgent`

Qu’est-ce qu’un `AzureAIAgent`?

Création d’un `AzureAIAgent`

Interaction avec un `AzureAIAgent`

Utilisation de plug-ins avec un `AzureAIAgent`

Récupération d’un `AzureAIAgent` existant

Suppression d’un `AzureAIAgent`

Gérer les messages intermédiaires avec un `AzureAIAgent`