Exploración del kernel semántico OpenAIResponsesAgent

Muy pronto llegará el OpenAIResponsesAgent.

Característica actualmente no disponible en Java.

Muy pronto llegará el OpenAIResponsesAgent.

Instala el paquete semantic-kernel:

pip install semantic-kernel

Característica actualmente no disponible en Java.

Muy pronto llegará el OpenAIResponsesAgent.

Para configurar el modelo usado por OpenAI o Azure OpenAI Responses API, se presentan nuevas variables de entorno:

OPENAI_RESPONSES_MODEL_ID=""
AZURE_OPENAI_RESPONSES_DEPLOYMENT_NAME=""

Establezca la variable adecuada en función del proveedor que use.

Para crear un AzureResponsesAgent para usar con los modelos de 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",
)

Como alternativa, para crear un OpenAIResponsesAgent para usarlo con modelos 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",
)

Característica actualmente no disponible en Java.

Muy pronto llegará el OpenAIResponsesAgent.

OpenAI Responses API admite el almacenamiento remoto opcional de conversaciones. De forma predeterminada, cuando se usa un ResponsesAgentThread, las respuestas se almacenan de forma remota. Esto permite el uso de la API previous_response_id de respuestas para mantener el contexto entre invocaciones.

Cada conversación se trata como un subproceso, identificado por un identificador de cadena único. Todas las interacciones con su OpenAIResponsesAgent están delimitadas por este identificador de hilo.

La mecánica subyacente del subproceso de la API de respuestas está abstraída por la clase ResponsesAgentThread, que implementa la interfaz AgentThread.

Actualmente, el OpenAIResponsesAgent solo admite subprocesos de tipo ResponsesAgentThread.

Puede invocar el OpenAIResponsesAgent sin especificar un AgentThread, para iniciar un nuevo subproceso y se devolverá un nuevo AgentThread como parte de la respuesta.

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

Característica actualmente no disponible en Java.

Muy pronto llegará el OpenAIResponsesAgent.

La configuración de la devolución de llamada dentro de on_intermediate_message o agent.invoke(...) permite a la persona que llama recibir mensajes intermedios generados durante el proceso de formulación de la respuesta final del agente.

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())

A continuación se muestra la salida de ejemplo del proceso de invocación del agente:

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!

Característica actualmente no disponible en Java.

La documentación sobre el uso de especificaciones declarativas estará disponible próximamente.

OpenAIResponsesAgent permite la instanciación desde una especificación declarativa YAML. El enfoque declarativo permite definir las propiedades, instrucciones, configuración del modelo, herramientas y otras opciones del agente en un único documento auditable. Esto hace que la composición del agente sea portátil y fácil de administrar entre entornos.

Cómo usar la especificación declarativa

En lugar de enumerar todas las configuraciones de YAML posibles, en esta sección se describen los principios clave y se proporcionan vínculos a ejemplos de concepto que muestran código completo para cada tipo de herramienta. Consulte estos ejemplos de concepto para implementaciones de un extremo a otro de una OpenAIResponsesAgent clase con especificaciones declarativas:

AzureResponsesAgent Muestras:

• Búsqueda de archivos
• Plugin de función a partir de un archivo
• Plantilla de solicitud

OpenAIResponsesAgent Muestras:

• Búsqueda de archivos
• Plugin de Funciones
• Plugin de función a partir de un archivo
• Plantilla de solicitud
• Búsqueda web

Ejemplo: Creación de una instancia de AzureAIAgent a partir de YAML

Una especificación declarativa de YAML mínima podría ser similar a la siguiente:

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

Para obtener más información sobre cómo conectar el agente, consulte los ejemplos de código completos anteriores.

Puntos clave

• Las especificaciones declarativas permiten definir la estructura del agente, las herramientas y el comportamiento en YAML.
• Todas las herramientas y complementos a los que se hace referencia deben estar registradas o accesibles en tiempo de ejecución.
• Las herramientas integradas, como Bing, File Search y Code Interpreter, requieren una configuración y credenciales adecuadas (a menudo a través de variables de entorno o argumentos explícitos).
• Para obtener ejemplos completos, consulte los vínculos de ejemplo proporcionados que muestran escenarios prácticos, como el registro de complementos, la configuración de identidad de Azure y el uso avanzado de herramientas.

Esta característica no está disponible.