Partilhar via

Explorando o Kernel Semântico OpenAIAssistantAgent

  • Artigo

Importante

Este recurso está na fase de candidato a lançamento. Os recursos neste estágio estão quase completos e geralmente estáveis, embora possam passar por pequenos refinamentos ou otimizações antes de atingir a disponibilidade geral total.

A documentação detalhada da API relacionada a esta discussão está disponível em:

Os agentes estão atualmente indisponíveis em Java.

O que é um Assistente?

A API OpenAI Assistant é uma interface especializada projetada para recursos de IA mais avançados e interativos, permitindo que os desenvolvedores criem agentes personalizados e orientados a tarefas em várias etapas. Ao contrário da API de conclusão de bate-papo, que se concentra em trocas conversacionais simples, a API do Assistente permite interações dinâmicas e orientadas por objetivos com recursos adicionais, como interpretador de código e pesquisa de arquivos.

Preparando seu ambiente de desenvolvimento

Para prosseguir com o desenvolvimento de um OpenAIAIAssistantAgent, configure seu ambiente de desenvolvimento com os pacotes apropriados.

Adicione o pacote Microsoft.SemanticKernel.Agents.OpenAI ao seu projeto:

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

Você também pode incluir o pacote Azure.Identity:

dotnet add package Azure.Identity

Instale o pacote semantic-kernel com as dependências opcionais de Azure: e

pip install semantic-kernel[azure]

Os agentes estão atualmente indisponíveis em Java.

Criando uma OpenAIAssistantAgent

A criação de um OpenAIAssistant requer a invocação de um serviço remoto, que é tratado de forma assíncrona. Para gerenciar isso, o OpenAIAssistantAgent é instanciado por meio de um método estático de fábrica, garantindo que o processo ocorra de maneira sem bloqueio. Esse método abstrai a complexidade da chamada assíncrona, retornando uma promessa ou futuro assim que o assistente estiver totalmente inicializado e pronto para uso.

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

Os agentes estão atualmente indisponíveis em Java.

Recuperando um OpenAIAssistantAgent

Uma vez criado, o identificador do assistente pode ser acessado através do seu identificador. Esse identificador pode ser usado para criar um OpenAIAssistantAgent a partir de uma definição de assistente existente.

Para .NET, o identificador do agente é exposto como um string através da propriedade definida por qualquer agente.

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

Os agentes estão atualmente indisponíveis em Java.

Usando um OpenAIAssistantAgent

Como em todos os aspetos da API do Assistente, as conversas são armazenadas remotamente. Cada conversa é referida como um segmento e identificada por um identificador exclusivo string . As interações com seus OpenAIAssistantAgent estão vinculadas a esse identificador de thread específico, que deve ser especificado ao chamar o agente/

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

Os agentes estão atualmente indisponíveis em Java.

Eliminar uma OpenAIAssistantAgent

Como a definição do assistente é armazenada remotamente, ela persistirá se não for excluída.
A exclusão de uma definição de assistente pode ser realizada diretamente com o AssistantClient.

Nota: Tentar usar uma instância de agente depois de ser excluído resultará em uma exceção de serviço.

Para .NET, o identificador do agente é exposto como um string através da Agent.Id propriedade definida por qualquer agente.

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

await agent.delete()

is_deleted = agent._is_deleted

Os agentes estão atualmente indisponíveis em Java.

Procedimentos

Para obter um exemplo completo de um OpenAIAssistantAgent, consulte:

Explorando o Agente de IA do Azure