Sdílet prostřednictvím

Zkoumání sémantického jádra OpenAIResponsesAgent

Důležité

Tato funkce je v experimentální fázi. Funkce v této fázi jsou ve vývoji a před přechodem na fázi Preview nebo release candidate se můžou změnit.

Brzy přijde OpenAIResponsesAgent.

Návod

Podrobná dokumentace k rozhraní API související s touto diskuzí je k dispozici na adrese:

Funkce aktuálně není dostupná v Javě.

Co je agent odpovědí?

Rozhraní API pro odpovědi OpenAI je nejpokročilejší rozhraní OpenAI pro generování odpovědí modelu. Podporuje vstupy textu a obrázků a textové výstupy. Pomocí výstupu předchozích odpovědí jako vstupu můžete vytvořit stavové interakce s modelem. Možnosti modelu je také možné rozšířit pomocí integrovaných nástrojů pro vyhledávání souborů, vyhledávání na webu, používání počítače a další.

Příprava vývojového prostředí

Pokud chcete pokračovat v vývoji OpenAIResponsesAgent, nakonfigurujte vývojové prostředí s příslušnými balíčky.

Brzy přijde OpenAIResponsesAgent.

Nainstalujte balíček semantic-kernel:

pip install semantic-kernel

Důležité

Podporuje se OpenAIResponsesAgent v balíčcích Pythonu se sémantickým jádrem 1.27.0 a novějším.

Funkce aktuálně není dostupná v Javě.

Vytvoření OpenAIResponsesAgent

Vytvoření OpenAIResponsesAgent vyžaduje nejprve vytvoření klienta, aby bylo možné komunikovat se vzdálenou službou.

Brzy přijde OpenAIResponsesAgent.

Pro konfiguraci modelu používaného rozhraním API pro odpovědi OpenAI nebo Azure OpenAI se zavádějí nové proměnné prostředí:

OPENAI_RESPONSES_MODEL_ID=""
AZURE_OPENAI_RESPONSES_DEPLOYMENT_NAME=""

Nastavte příslušnou proměnnou podle toho, kterého zprostředkovatele používáte.

Návod

Minimální povolená verze rozhraní API Azure OpenAI je 2025-03-01-preview. Pokud chcete zobrazit dostupnost oblastí, podporu modelů a další podrobnosti, navštivte následující odkaz .

Vytvoření AzureResponsesAgent k použití s modely 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",
)

Případně pro použití s modely OpenAI vytvořte OpenAIResponsesAgent.

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

Funkce aktuálně není dostupná v Javě.

Použití OpenAIResponsesAgent

Brzy přijde OpenAIResponsesAgent.

Rozhraní API odpovědí OpenAI podporuje volitelné vzdálené ukládání konverzací. Ve výchozím nastavení se odpovědi při použití ResponsesAgentThread ukládají vzdáleně. To umožňuje použití rozhraní API odpovědí previous_response_id k udržení kontextu napříč vyvoláními.

Každá konverzace je považována za vlákno identifikované jedinečným řetězcem ID. Všechny interakce s vaším OpenAIResponsesAgent jsou omezeny na tento identifikátor vlákna.

Základní mechanika vlákna API pro odpovědi jsou abstrahována třídou ResponsesAgentThread, která implementuje rozhraní AgentThread.

OpenAIResponsesAgent aktuálně podporuje pouze vlákna typu ResponsesAgentThread.

Můžete vyvolat OpenAIResponsesAgent bez zadání AgentThreadke spuštění nového vlákna, a nový AgentThread bude vrácen jako součást odpovědi.

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

Funkce aktuálně není dostupná v Javě.

Zpracování přechodných zpráv pomocí OpenAIResponsesAgent

Sémantické jádro OpenAIResponsesAgent je navrženo tak, aby použilo agenta, který zodpovídá dotazy nebo otázky uživatelů. Během vyvolání může agent spouštět nástroje, které odvozují konečnou odpověď. Pro přístup k přechodným zprávám vytvořeným během tohoto procesu mohou volající poskytnout funkci zpětného volání, která zpracovává instance FunctionCallContent nebo FunctionResultContent.

Brzy přijde OpenAIResponsesAgent.

Konfigurace zpětného on_intermediate_message volání uvnitř agent.invoke(...) nebo agent.invoke_stream(...) umožňuje volajícímu přijímat přechodné zprávy generované během procesu formulace konečné odpovědi agenta.

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

Následující příklad ukazuje ukázkový výstup z procesu vyvolání agenta:

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!

Funkce aktuálně není dostupná v Javě.

Deklarativní specifikace

Dokumentace k používání deklarativních specifikací bude brzy k dispozici.

Důležité

Tato funkce je v experimentální fázi. Funkce v této fázi jsou ve vývoji a před přechodem na fázi Preview nebo release candidate se můžou změnit.

Podporování instancí z deklarativní specifikace YAML pomocí OpenAIResponsesAgent. Deklarativní přístup umožňuje definovat vlastnosti, pokyny, konfiguraci modelu, nástroje a další možnosti v jednom auditovatelném dokumentu. Díky tomu je složení agentů přenosné a snadno spravované napříč prostředími.

Poznámka:

Všechny nástroje, funkce nebo moduly plug-in uvedené v deklarativním jazyce YAML musí být k dispozici agentovi v době výstavby. U modulů plug-in založených na jádru to znamená, že musí být zaregistrované v jádru. Pro integrované nástroje, jako je interpret kódu nebo vyhledávání souborů, musí být zadána správná konfigurace a přihlašovací údaje. Zavaděč agenta nebude vytvářet funkce z ničeho. Pokud chybí požadovaná komponenta, vytvoření agenta selže.

Jak používat deklarativní specifikaci

Místo vytvoření výčtu všech možných konfigurací YAML tato část popisuje klíčové principy a poskytuje odkazy na ukázky konceptů, které zobrazují kompletní kód pro každý typ nástroje. Projděte si tyto ukázky konceptů OpenAIResponsesAgent pro komplexní implementace deklarativních specifikací:

AzureResponsesAgent vzorky:

OpenAIResponsesAgent vzorky:

Příklad: Vytvoření agenta AzureAIAgent z YAML

Minimální deklarativní specifikace YAML může vypadat takto:

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

Podrobnosti o tom, jak připojit agenta, najdete v kompletních ukázkách kódu výše.

Klíčové body

  • Deklarativní specifikace umožňují definovat strukturu agenta, nástroje a chování v YAML.
  • Všechny odkazované nástroje a moduly plug-in musí být zaregistrované nebo přístupné za běhu.
  • Integrované nástroje, jako je Bing, Vyhledávání souborů a interpret kódu, vyžadují správnou konfiguraci a přihlašovací údaje (často prostřednictvím proměnných prostředí nebo explicitních argumentů).
  • Komplexní příklady najdete na uvedených ukázkových odkazech, které demonstrují praktické scénáře, včetně registrace modulu plug-in, konfigurace identity Azure a pokročilého použití nástrojů.

Tato funkce není k dispozici.

Další kroky

Prozkoumání orchestrace agentů

  • Last updated on