Erforschung des semantischen Kerns OpenAIAssistantAgent

Das Feature ist derzeit in Java nicht verfügbar.

Fügen Sie dem Projekt das Microsoft.SemanticKernel.Agents.OpenAI-Paket hinzu:

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

Möglicherweise möchten Sie auch das Azure.Identity Paket einschließen:

dotnet add package Azure.Identity

Installieren Sie das Paket semantic-kernel:

pip install semantic-kernel

Das Feature ist derzeit in Java nicht verfügbar.

AssistantClient client = OpenAIAssistantAgent.CreateAzureOpenAIClient(...).GetAssistantClient();
Assistant assistant =
    await client.CreateAssistantAsync(
        "<model name>",
        "<agent name>",
        instructions: "<agent instructions>");
OpenAIAssistantAgent agent = new(assistant, client);

from semantic_kernel.agents import AssistantAgentThread, AzureAssistantAgent, OpenAIAssistantAgent
from semantic_kernel.connectors.ai.open_ai import AzureOpenAISettings, OpenAISettings

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

# Define the assistant definition
definition = await client.beta.assistants.create(
    model=AzureOpenAISettings().chat_deployment_name,
    instructions="<instructions>",
    name="<agent name>",
)

# Create the AzureAssistantAgent instance using the client and the assistant definition
agent = AzureAssistantAgent(
    client=client,
    definition=definition,
)

# or

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

# Define the assistant definition
definition = await client.beta.assistants.create(
    model=OpenAISettings().chat_model_id,
    instructions="<instructions>",
    name="<agent name>",
)

# Create the OpenAIAssistantAgent instance using the client and the assistant definition
agent = OpenAIAssistantAgent(
    client=client,
    definition=definition,
)

Das Feature ist derzeit in Java nicht verfügbar.

Für .NET wird der Agentbezeichner als string über die von einem beliebigen Agenten definierte Eigenschaft verfügbar gemacht.

AssistantClient client = OpenAIAssistantAgent.CreateAzureOpenAIClient(...).GetAssistantClient();
Assistant assistant = await client.GetAssistantAsync("<assistant id>");
OpenAIAssistantAgent agent = new(assistant, client);

# Using Azure OpenAI Resources

# Create the client using Azure OpenAI resources and configuration
client = AzureAssistantAgent.create_client()

# Create the assistant definition
definition = await client.beta.assistants.create(
    model=AzureOpenAISettings().chat_deployment_name,
    name="<agent name>",
    instructions="<instructions>",
)

# Store the assistant ID
assistant_id = definition.id

# Retrieve the assistant definition from the server based on the assistant ID
new_asst_definition = await client.beta.assistants.retrieve(assistant_id)

# Create the AzureAssistantAgent instance using the client and the assistant definition
agent = AzureAssistantAgent(
    client=client,
    definition=new_asst_definition,
)

Das Feature ist derzeit in Java nicht verfügbar.

// Define agent
OpenAIAssistantAgent agent = ...;
AgentThread? agentThread = null;

// Generate the agent response(s)
await foreach (AgentResponseItem<ChatMessageContent> response in agent.InvokeAsync(new ChatMessageContent(AuthorRole.User, "<user input>")))
{
  // Process agent response(s)...
  agentThread = response.Thread;
}

// Delete the thread if no longer needed
if (agentThread is not null)
{
    await agentThread.DeleteAsync();
}

Sie können auch OpenAIAssistantAgent, das Sie erstellt haben, mit AgentThread aufrufen.

// Define agent
OpenAIAssistantAgent agent = ...;

// Create a thread with some custom metadata.
AgentThread agentThread = new OpenAIAssistantAgentThread(client, metadata: myMetadata);

// Generate the agent response(s)
await foreach (ChatMessageContent response in agent.InvokeAsync(new ChatMessageContent(AuthorRole.User, "<user input>"), agentThread))
{
  // Process agent response(s)...
}

// Delete the thread when it is no longer needed
await agentThread.DeleteAsync();

Sie können auch eine OpenAIAssistantAgentThread Unterhaltung erstellen, die eine frühere Unterhaltung über eine ID wiederaufnimmt.

// Create a thread with an existing thread id.
AgentThread agentThread = new OpenAIAssistantAgentThread(client, "existing-thread-id");

from semantic_kernel.agents import AssistantAgentThread, AzureAssistantAgent

# Define agent
openai_agent = await ...

# Create a thread for the agent conversation
thread: AssistantAgentThread = None

# Generate the agent response(s)
async for response in agent.invoke(messages="user input", thread=thread):
  # process agent response(s)...
  thread = response.thread

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

Das Feature ist derzeit in Java nicht verfügbar.

Für .NET wird der Agentbezeichner als string über die Agent.Id-Eigenschaft verfügbar gemacht, die von einem beliebigen Agenten definiert wurde.

AssistantClient client = OpenAIAssistantAgent.CreateAzureOpenAIClient(...).GetAssistantClient();
await client.DeleteAssistantAsync("<assistant id>");

await client.beta.assistants.delete(agent.id)

Das Feature ist derzeit in Java nicht verfügbar.

Die Rückrufdokumentation für das OpenAIAssistantAgent wird in Kürze verfügbar sein.

Konfigurieren des on_intermediate_message Rückrufs innerhalb agent.invoke(...) oder agent.invoke_stream(...) ermöglicht es dem Anrufer, Zwischennachrichten zu empfangen, die während des Prozesses der Erstellung der endgültigen Antwort des Agents generiert wurden.

import asyncio
from typing import Annotated

from semantic_kernel.agents import AssistantAgentThread, AzureAssistantAgent
from semantic_kernel.connectors.ai.open_ai import AzureOpenAISettings
from semantic_kernel.contents import AuthorRole, ChatMessageContent, FunctionCallContent, FunctionResultContent
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():
    # Create the client using Azure OpenAI resources and configuration
    client = AzureAssistantAgent.create_client()

    # Define the assistant definition
    definition = await client.beta.assistants.create(
        model=AzureOpenAISettings().chat_deployment_name,
        name="Host",
        instructions="Answer questions about the menu.",
    )

    # Create the AzureAssistantAgent instance using the client and the assistant definition and the defined plugin
    agent = AzureAssistantAgent(
        client=client,
        definition=definition,
        plugins=[MenuPlugin()],
    )

    # Create a new thread for use with the assistant
    # If no thread is provided, a new thread will be
    # created and returned with the initial response
    thread: AssistantAgentThread = 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,
            ):
                print(f"# {response.role}: {response}")
                thread = response.thread
    finally:
        await thread.delete() if thread else None
        await client.beta.assistants.delete(assistant_id=agent.id)


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

Das Folgende zeigt die Beispielausgabe des Agentenaufrufprozesses:

AuthorRole.USER: 'Hello'
AuthorRole.ASSISTANT: Hello! How can I assist you 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
AuthorRole.ASSISTANT: The special soup is Clam Chowder. Would you like to know more about the specials or 
    anything else?
AuthorRole.USER: 'What is the special drink?'
AuthorRole.ASSISTANT: The special drink is Chai Tea. If you have any more questions, feel free to ask!
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
AuthorRole.ASSISTANT: The Chai Tea is priced at $9.99. If there's anything else you'd like to know, 
    just let me know!
AuthorRole.USER: 'Thank you'
AuthorRole.ASSISTANT: You're welcome! If you have any more questions or need further assistance, feel free to 
    ask. Enjoy your day!

Das Feature ist derzeit in Java nicht verfügbar.

Die Dokumentation zur Verwendung deklarativer Spezifikationen wird in Kürze verfügbar sein.

OpenAIAssistantAgent unterstützt die Instanziierung aus einer YAML-deklarativen Spezifikation. Mit dem deklarativen Ansatz können Sie die Eigenschaften, Anweisungen, Modellkonfiguration, Tools und andere Optionen in einem einzigen, auditierbaren Dokument definieren. Dies macht die Agentkomposition übertragbar und einfach umgebungsübergreifend verwaltet.

Anleitung zur Verwendung der deklarativen Spezifikation

Anstatt jede mögliche YAML-Konfiguration aufzählen zu müssen, beschreibt dieser Abschnitt die wichtigsten Prinzipien und enthält Links zu Konzeptbeispielen, die vollständigen Code für jeden Tooltyp anzeigen. In den folgenden Konzeptbeispielen finden Sie End-to-End-Implementierungen einer OpenAIAssistantAgent mit deklarativen Spezifikationen:

AzureAssistantAgent proben:

• Codedolmetscher
• Dateisuche
• Funktions-Plug-In aus einer Datei
• Laden aus vorhandener Assistenten-ID
• Eingabeaufforderungsvorlage

OpenAIAssistantAgent proben:

• Codedolmetscher
• Dateisuche
• Funktionsplugin
• Funktions-Plug-In aus einer Datei
• Laden aus vorhandener Assistenten-ID
• Eingabeaufforderungsvorlage

Beispiel: Erstellen eines AzureAIAgent aus YAML

Eine minimale deklarative YAML-Spezifikation könnte wie folgt aussehen:

type: openai_assistant
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

Ausführliche Informationen zum Verbinden des Agents finden Sie in den oben aufgeführten vollständigen Codebeispielen.

Die wichtigsten Punkte

• Deklarative Spezifikationen ermöglichen das Definieren von Agentstruktur, Tools und Verhalten in YAML.
• Alle referenzierten Tools und Plug-Ins müssen zur Laufzeit registriert oder zugänglich sein.
• Integrierte Tools wie Bing, Dateisuche und Codedolmetscher erfordern eine ordnungsgemäße Konfiguration und Anmeldeinformationen (häufig über Umgebungsvariablen oder explizite Argumente).
• Umfassende Beispiele finden Sie in den bereitgestellten Beispiellinks, die praktische Szenarien veranschaulichen, einschließlich Plug-In-Registrierung, Azure-Identitätskonfiguration und erweiterter Toolverwendung.

Dieses Feature ist nicht verfügbar.