Exploration du noyau sémantique OpenAIResponsesAgent

Le OpenAIResponsesAgent arrive bientôt.

Fonctionnalité actuellement indisponible en Java.

Le OpenAIResponsesAgent arrive bientôt.

Installez le package semantic-kernel :

pip install semantic-kernel

Fonctionnalité actuellement indisponible en Java.

Le OpenAIResponsesAgent arrive bientôt.

Pour configurer le modèle utilisé par l’API Réponses OpenAI ou Azure OpenAI, de nouvelles variables d’environnement sont introduites :

OPENAI_RESPONSES_MODEL_ID=""
AZURE_OPENAI_RESPONSES_DEPLOYMENT_NAME=""

Définissez la variable appropriée en fonction du fournisseur que vous utilisez.

Pour créer un AzureResponsesAgent modèle à utiliser avec des modèles Azure OpenAI :

from semantic_kernel.agents import AzureResponsesAgent
from semantic_kernel.connectors.ai.open_ai import AzureOpenAISettings, OpenAISettings


# Set up the client and model using Azure OpenAI Resources
client = AzureResponsesAgent.create_client()

# Create the AzureResponsesAgent instance using the client and the model
agent = AzureResponsesAgent(
    ai_model_id=AzureOpenAISettings().responses_deployment_name,
    client=client,
    instructions="your instructions",
    name="name",
)

Vous pouvez également créer un OpenAIResponsesAgent à utiliser avec les modèles OpenAI :

from semantic_kernel.agents import OpenAIResponsesAgent

# Set up the client and model using OpenAI Resources
client = OpenAIResponsesAgent.create_client()

# Create the OpenAIResponsesAgent instance using the client and the model
agent = OpenAIResponsesAgent(
    ai_model_id=OpenAISettings().responses_model_id,
    client=client,
    instructions="your instructions",
    name="name",
)

Fonctionnalité actuellement indisponible en Java.

Le OpenAIResponsesAgent arrive bientôt.

L’API Réponses OpenAI prend en charge le stockage distant facultatif des conversations. Par défaut, lors de l’utilisation d’un ResponsesAgentThread, les réponses sont stockées à distance. Cela permet d’utiliser l’API des Réponses previous_response_id pour maintenir le contexte entre les appels.

Chaque conversation est traitée comme un thread, identifié par un ID de chaîne unique. Toutes les interactions avec votre OpenAIResponsesAgent sont limitées à cet identificateur de fil.

Les mécanismes sous-jacents du thread d’API Réponses sont extraits par la ResponsesAgentThread classe, qui implémente l’interface AgentThread .

Actuellement, le OpenAIResponsesAgent prend uniquement en charge les fils de type ResponsesAgentThread.

Vous pouvez invoquer le OpenAIResponsesAgent sans spécifier de AgentThread, pour démarrer un nouveau fil d'exécution, et un nouveau AgentThread sera retourné dans le cadre de la réponse.

from semantic_kernel.agents import AzureResponsesAgent

# Set up the client and model using Azure OpenAI Resources
client = AzureResponsesAgent.create_client()

# Create the AzureResponsesAgent instance using the client and the model
agent = AzureResponsesAgent(
    ai_model_id=AzureOpenAISettings().responses_deployment_name,
    client=client,
    instructions="your instructions",
    name="name",
)

USER_INPUTS = [
    "My name is John Doe.",
    "Tell me a joke",
    "Explain why this is funny.",
    "What have we been talking about?",
]

thread = None

# Generate the agent response(s)
for user_input in USER_INPUTS:
    print(f"# User: '{user_input}'")
    # Invoke the agent for the current message and print the response
    response = await agent.get_response(messages=user_input, thread=thread)
    print(f"# {response.name}: {response.content}")
    # Update the thread so the previous response id is used
    thread = response.thread

# Delete the thread when it is no longer needed
await thread.delete() if thread else None

Fonctionnalité actuellement indisponible en Java.

Le OpenAIResponsesAgent arrive bientôt.

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 semantic_kernel.agents import AzureResponsesAgent
from semantic_kernel.contents import AuthorRole, 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():
    # 1. Create the client using Azure OpenAI resources and configuration
    client = AzureResponsesAgent.create_client()

    # 2. Create a Semantic Kernel agent for the OpenAI Responses API
    agent = AzureResponsesAgent(
        ai_model_id=AzureOpenAISettings().responses_deployment_name,
        client=client,
        name="Host",
        instructions="Answer questions about the menu.",
        plugins=[MenuPlugin()],
    )

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

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

    try:
        for user_input in user_inputs:
            print(f"# {AuthorRole.USER}: '{user_input}'")
            async for response in agent.invoke(
                messages=user_input,
                thread=thread,
                on_intermediate_message=handle_intermediate_steps,
            ):
                thread = response.thread
                print(f"# {response.name}: {response.content}")
    finally:
        await thread.delete() if thread else None


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

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

AuthorRole.USER: 'Hello'
Host: Hi there! How can I assist you with the menu today?
AuthorRole.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
Host: The special soup is Clam Chowder. Would you like to know more about any other specials?
AuthorRole.USER: 'What is the special drink?'
Host: The special drink is Chai Tea. Would you like any more information?
AuthorRole.USER: 'How much is that?'
Function Call:> MenuPlugin-get_item_price with arguments: {"menu_item":"Chai Tea"}
Function Result:> $9.99 for function: MenuPlugin-get_item_price
Host: The Chai Tea is $9.99. Is there anything else you would like to know?
AuthorRole.USER: 'Thank you'
Host: You're welcome! If you have any more questions, feel free to ask. Enjoy your day!

Fonctionnalité actuellement indisponible en Java.

La documentation sur l’utilisation de spécifications déclaratives sera bientôt disponible.

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

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 OpenAIResponsesAgent avec des spécifications déclaratives.

AzureResponsesAgent Échantillons:

• Recherche de fichiers
• Plug-in de fonction à partir d’un fichier
• Modèle de requête

OpenAIResponsesAgent Échantillons:

• Recherche de fichiers
• Plug-in de fonction
• Plug-in de fonction à partir d’un fichier
• Modèle de requête
• Recherche web

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

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

type: openai_responses
name: Host
instructions: Respond politely to the user's questions.
model:
  id: ${OpenAI: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.

Cette fonctionnalité n’est pas disponible.