Delen via

De semantische kernel OpenAIAssistantAgent verkennen

  • Artikel

Belangrijk

Deze functie bevindt zich in de release kandidaat fase. Functies in deze fase zijn bijna volledig en over het algemeen stabiel, hoewel ze kleine verfijningen of optimalisaties kunnen ondergaan voordat volledige algemene beschikbaarheid wordt bereikt.

Gedetailleerde API-documentatie met betrekking tot deze discussie is beschikbaar op:

Agents zijn momenteel niet beschikbaar in Java.

Wat is een assistent?

De OpenAI Assistant-API is een gespecialiseerde interface die is ontworpen voor geavanceerdere en interactieve AI-mogelijkheden, zodat ontwikkelaars persoonlijke en taakgerichte agents met meerdere stappen kunnen maken. In tegenstelling tot de CHAT-voltooiings-API, die zich richt op eenvoudige gesprekken, biedt de Assistent-API dynamische, doelgestuurde interacties met aanvullende functies, zoals code-interpreter en file-search.

Uw ontwikkelomgeving voorbereiden

Als u wilt doorgaan met het ontwikkelen van een OpenAIAIAssistantAgent, configureert u uw ontwikkelomgeving met de juiste pakketten.

Voeg het Microsoft.SemanticKernel.Agents.OpenAI-pakket toe aan uw project:

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

U kunt ook het Azure.Identity-pakket opnemen:

dotnet add package Azure.Identity

Installeer het semantic-kernel-pakket met de optionele Azure-afhankelijkheden:

pip install semantic-kernel[azure]

Agents zijn momenteel niet beschikbaar in Java.

Een OpenAIAssistantAgent aanmaken

Voor het maken van een OpenAIAssistant moet een externe service worden aangeroepen, die asynchroon wordt afgehandeld. Om dit te beheren, wordt de OpenAIAssistantAgent geïnstantieerd via een statische factory-methode, zodat het proces op een niet-blokkerende manier plaatsvindt. Deze methode abstraheert de complexiteit van de asynchrone aanroep, retourneert een belofte of toekomst zodra de assistent volledig is geïnitialiseerd en klaar voor gebruik.

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

from semantic_kernel.agents.open_ai import AzureAssistantAgent, OpenAIAssistantAgent

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

# Define the assistant definition
definition = await client.beta.assistants.create(
    model=model,
    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, model = OpenAIAssistantAgent.setup_resources()

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

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

Agents zijn momenteel niet beschikbaar in Java.

Een OpenAIAssistantAgent ophalen

Zodra de assistent is gemaakt, kan de id van de assistent toegankelijk zijn via de id. Deze identificatie kan worden gebruikt om een OpenAIAssistantAgent te maken op basis van een bestaande definitie van een assistent.

Voor .NET wordt de agent-id weergegeven als een string via de eigenschap die door een agent is gedefinieerd.

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

# Using Azure OpenAI Resources

# Create the client using Azure OpenAI resources and configuration
client, model = AzureAssistantAgent.setup_resources()

# Create the assistant definition
definition = await client.beta.assistants.create(
    model=model,
    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,
)

Agents zijn momenteel niet beschikbaar in Java.

Een OpenAIAssistantAgent gebruiken

Net als bij alle aspecten van de Assistent-API worden gesprekken extern opgeslagen. Elk gesprek wordt een thread genoemd en geïdentificeerd door een unieke string id. Interacties met uw OpenAIAssistantAgent zijn gekoppeld aan deze specifieke thread-id die moet worden opgegeven bij het aanroepen van de agent/

// Define agent
OpenAIAssistantAgent agent = ...;

// Create a thread for the agent conversation.
string threadId = await agent.CreateThreadAsync();

// Add a user message to the conversation
chat.Add(threadId, new ChatMessageContent(AuthorRole.User, "<user input>"));

// Generate the agent response(s)
await foreach (ChatMessageContent response in agent.InvokeAsync(threadId))
{
  // Process agent response(s)...
}

// Delete the thread when it is no longer needed
await agent.DeleteThreadAsync(threadId);

# Define agent
openai_agent = await ...

# Create a thread for the agent conversation
thread_id = await agent.create_thread()

# Add a user message to the conversation
await agent.add_chat_message(
  thread_id=thread_id, 
  message=ChatMessageContent(role=AuthorRole.USER, content="<user input>"),
)

# Generate the agent response(s)
async for response in agent.invoke(thread_id=thread_id):
  # process agent response(s)...

# Delete the thread when it is no longer needed
await agent.delete_thread(thread_id)

Agents zijn momenteel niet beschikbaar in Java.

Een OpenAIAssistantAgent verwijderen

Omdat de definitie van de assistent extern wordt opgeslagen, blijft deze behouden als deze niet wordt verwijderd.
Het verwijderen van een assistentdefinitie kan rechtstreeks met de AssistantClientworden uitgevoerd.

Opmerking: Als u probeert een agentexemplaar te gebruiken nadat deze is verwijderd, zal dit resulteren in een servicefout.

Voor .NET wordt de agent-id weergegeven als een string via de Agent.Id eigenschap die door een agent is gedefinieerd.

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

await agent.delete()

is_deleted = agent._is_deleted

Agents zijn momenteel niet beschikbaar in Java.

Uitleg:

Zie voor een end-to-end-voorbeeld voor een OpenAIAssistantAgent:

De Azure AI-agent verkennen