Eksplorowanie jądra semantycznego OpenAIResponsesAgent

Wkrótce pojawi się ten element OpenAIResponsesAgent .

Funkcja jest obecnie niedostępna w języku Java.

Wkrótce pojawi się ten element OpenAIResponsesAgent .

semantic-kernel Zainstaluj pakiet:

pip install semantic-kernel

Funkcja jest obecnie niedostępna w języku Java.

Wkrótce pojawi się ten element OpenAIResponsesAgent .

Aby skonfigurować model używany przez API odpowiedzi OpenAI lub Azure OpenAI, wprowadzono nowe zmienne środowiskowe.

OPENAI_RESPONSES_MODEL_ID=""
AZURE_OPENAI_RESPONSES_DEPLOYMENT_NAME=""

Ustaw odpowiednią zmienną w zależności od używanego dostawcy.

Aby utworzyć element AzureResponsesAgent do użycia z modelami usługi 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",
)

Alternatywnie, aby utworzyć element OpenAIResponsesAgent do użycia z modelami 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",
)

Funkcja jest obecnie niedostępna w języku Java.

Wkrótce pojawi się ten element OpenAIResponsesAgent .

API Odpowiedzi OpenAI obsługuje opcjonalne zdalne przechowywanie konwersacji. Domyślnie w przypadku używania ResponsesAgentThreadfunkcji odpowiedzi są przechowywane zdalnie. Dzięki temu można używać API previous_response_id odpowiedzi do utrzymywania kontekstu między wywołaniami.

Każda konwersacja jest traktowana jako wątek, identyfikowana przez unikatowy identyfikator ciągu. Wszystkie interakcje z Twoim OpenAIResponsesAgent są ograniczone do tego identyfikatora wątku.

Podstawowe mechanizmy wątku API odpowiedzi są abstrahowane przez klasę ResponsesAgentThread, która implementuje interfejs AgentThread.

Obecnie OpenAIResponsesAgent obsługuje tylko wątki typu ResponsesAgentThread.

Można wywołać element OpenAIResponsesAgent bez określenia elementu AgentThread, aby uruchomić nowy wątek, a nowy AgentThread zostanie zwrócony jako część odpowiedzi.

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

Funkcja jest obecnie niedostępna w języku Java.

Wkrótce pojawi się ten element OpenAIResponsesAgent .

Skonfigurowanie wywołania zwrotnego on_intermediate_message w agent.invoke(...) lub agent.invoke_stream(...) umożliwia inicjującemu odbieranie komunikatów pośrednich generowanych podczas procesu formułowania ostatecznej odpowiedzi 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())

Poniżej przedstawiono przykładowe dane wyjściowe z procesu wywołania 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!

Funkcja jest obecnie niedostępna w języku Java.

Dokumentacja dotycząca korzystania ze specyfikacji deklaratywnych jest dostępna wkrótce.

Funkcja OpenAIResponsesAgent obsługuje tworzenie wystąpień ze specyfikacji deklaratywnej YAML. Podejście deklaratywne umożliwia zdefiniowanie właściwości, instrukcji agenta, konfiguracji modelu, narzędzi i innych opcji w jednym dokumencie z możliwością inspekcji. Dzięki temu kompozycja agenta jest przenośna i łatwo zarządzana w różnych środowiskach.

Jak używać specyfikacji deklaratywnej

Zamiast wyliczać każdą możliwą konfigurację YAML, w tej sekcji opisano kluczowe zasady i podano linki do przykładów koncepcji, które pokazują pełny kod dla każdego typu narzędzia. Zapoznaj się z tymi wzorcowymi przykładami kompleksowych implementacji OpenAIResponsesAgent z deklaratywnymi specyfikacjami.

AzureResponsesAgent Próbki:

• wyszukiwanie plików
• Funkcja wtyczki z pliku
• Szablon monitu

OpenAIResponsesAgent Próbki:

• wyszukiwanie plików
• Funkcyjna wtyczka
• Funkcja wtyczki z pliku
• Szablon monitu
• Wyszukiwanie w Sieci Web

Przykład: tworzenie modułu AzureAIAgent z poziomu yaML

Minimalna specyfikacja deklaratywna YAML może wyglądać następująco:

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

Aby uzyskać szczegółowe informacje na temat sposobu podłącznia agenta, zapoznaj się z powyższymi pełnymi przykładami kodu.

Kwestie kluczowe

• Specyfikacje deklaratywne umożliwiają definiowanie struktury agenta, narzędzi i zachowania w języku YAML.
• Wszystkie przywoływalne narzędzia i wtyczki muszą być zarejestrowane lub dostępne w czasie wykonywania.
• Wbudowane narzędzia, takie jak Bing, wyszukiwanie plików i interpreter kodu, wymagają odpowiedniej konfiguracji i poświadczeń (często za pośrednictwem zmiennych środowiskowych lub jawnych argumentów).
• Aby zapoznać się z kompleksowymi przykładami, zapoznaj się z podanymi przykładowymi linkami, które przedstawiają praktyczne scenariusze, w tym rejestrację wtyczki, konfigurację tożsamości platformy Azure i zaawansowane użycie narzędzi.

Ta funkcja jest niedostępna.