Compartilhar via

Criar um assistente de IA mínimo usando o .NET

Neste início rápido, você aprenderá a criar um assistente de IA mínimo usando as bibliotecas openai ou do SDK do Azure OpenAI. Os assistentes de IA fornecem funcionalidades agente para ajudar os usuários a concluir tarefas usando ferramentas e modelos de IA. Nas seções a seguir, você aprenderá o seguinte:

  • Principais componentes e conceitos de assistentes de IA
  • Como criar um assistente usando o SDK do Azure OpenAI
  • Como aprimorar e personalizar os recursos de um assistente

Pré-requisitos

Componentes principais de assistentes de IA

Os assistentes de IA são baseados em tópicos conversacionais com um usuário. O usuário envia prompts para o assistente em um thread de conversa, que orienta o assistente a concluir tarefas usando as ferramentas disponíveis. Os assistentes podem processar e analisar dados, tomar decisões e interagir com usuários ou outros sistemas para atingir metas específicas. A maioria dos assistentes inclui os seguintes componentes:

Componente Descrição
Assistente O cliente de IA principal e a lógica que usa modelos do Azure OpenAI, gerencia threads de conversa e utiliza ferramentas configuradas.
Tópico Uma sessão de conversa entre um assistente e um usuário. Os threads armazenam mensagens e manipulam automaticamente o truncamento para ajustar o conteúdo ao contexto de um modelo.
Mensagem Uma mensagem criada por um assistente ou um usuário. As mensagens podem incluir texto, imagens e outros arquivos. As mensagens são armazenadas como uma lista no thread.
Executar Ativação de um assistente para começar a ser executado com base no conteúdo do thread. O assistente usa sua configuração e as mensagens do thread para executar tarefas chamando modelos e ferramentas. Como parte de uma execução, o assistente acrescenta mensagens ao thread.
Etapas de execução Uma lista detalhada das etapas que o assistente realizou como parte de uma execução. Um assistente pode chamar ferramentas ou criar mensagens durante sua execução. Examinar as etapas de execução permite que você entenda como o assistente está chegando aos resultados finais.

Os assistentes também podem ser configurados para usar várias ferramentas em paralelo para concluir tarefas, incluindo o seguinte:

  • ferramenta interpretador de código: grava e executa código em um ambiente de execução em área restrita.
  • Chamada de função: executa funções personalizadas locais que você define em seu código.
  • Recursos de pesquisa de arquivos: enriquece o assistente com conhecimento de fora do seu modelo.

Ao entender esses componentes principais e como eles interagem, você pode criar e personalizar poderosos assistentes de IA para atender às suas necessidades específicas.

Criar o aplicativo .NET

Conclua as seguintes etapas para criar um aplicativo de console do .NET e adicionar o pacote necessário para trabalhar com os assistentes:

  1. Em uma janela de terminal, navegue até um diretório vazio em seu dispositivo e crie um novo aplicativo com o comando dotnet new:

    dotnet new console -o AIAssistant

  2. Adicione o pacote OpenAI ao seu aplicativo:

    dotnet add package OpenAI --prerelease

  3. Abra o novo aplicativo em seu editor de escolha, como o Visual Studio Code.

    code .

  1. Em uma janela de terminal, navegue até um diretório vazio em seu dispositivo e crie um novo aplicativo com o comando dotnet new:

    dotnet new console -o AIAssistant

  2. Adicione o pacote Azure.AI.OpenAI ao seu aplicativo:

    dotnet add package Azure.AI.OpenAI --prerelease

  3. Abra o novo aplicativo em seu editor de escolha, como o Visual Studio Code.

    code .

Criar o cliente assistente de IA

  1. Abra o Program.cs arquivo e substitua o conteúdo do arquivo pelo seguinte código para criar os clientes necessários:

    using OpenAI;
using OpenAI.Assistants;
using OpenAI.Files;
using Azure.AI.OpenAI;
using Azure.Identity;

// Create the OpenAI client
OpenAIClient openAIClient = new("your-apy-key");

// For Azure OpenAI, use the following client instead:
AzureOpenAIClient azureAIClient = new(
        new Uri("your-azure-openai-endpoint"),
        new DefaultAzureCredential());

#pragma warning disable OPENAI001
AssistantClient assistantClient = openAIClient.GetAssistantClient();
OpenAIFileClient fileClient = openAIClient.GetOpenAIFileClient();

  2. Crie um documento de exemplo na memória e carregue-o no OpenAIFileClient:

    // Create an in-memory document to upload to the file client
using Stream document = BinaryData.FromBytes("""
    {
        "description": "This document contains the sale history data for Contoso products.",
        "sales": [
            {
                "month": "January",
                "by_product": {
                    "113043": 15,
                    "113045": 12,
                    "113049": 2
                }
            },
            {
                "month": "February",
                "by_product": {
                    "113045": 22
                }
            },
            {
                "month": "March",
                "by_product": {
                    "113045": 16,
                    "113055": 5
                }
            }
        ]
    }
    """u8.ToArray()).ToStream();

// Upload the document to the file client
OpenAIFile salesFile = fileClient.UploadFile(
    document,
    "monthly_sales.json",
    FileUploadPurpose.Assistants);

  3. Ative as funcionalidades para pesquisa de arquivos e interpretação de código por meio do AssistantCreationOptions.

    // Configure the assistant options
AssistantCreationOptions assistantOptions = new()
{
    Name = "Example: Contoso sales RAG",
    Instructions =
        "You are an assistant that looks up sales data and helps visualize the information based"
        + " on user queries. When asked to generate a graph, chart, or other visualization, use"
        + " the code interpreter tool to do so.",
    Tools =
    {
        new FileSearchToolDefinition(), // Enable the assistant to search and access files
        new CodeInterpreterToolDefinition(), // Enable the assistant to run code for data analysis
    },
    ToolResources = new()
    {
        FileSearch = new()
        {
            NewVectorStores =
            {
                new VectorStoreCreationHelper([salesFile.Id]),
            }
        }
    },
};

  4. Crie o Assistant e um thread para gerenciar interações entre o usuário e o assistente:

    // Create the assistant
Assistant assistant = assistantClient.CreateAssistant("gpt-4o", assistantOptions);

// Configure and create the conversation thread
ThreadCreationOptions threadOptions = new()
{
    InitialMessages = { "How well did product 113045 sell in February? Graph its trend over time." }
};

ThreadRun threadRun = assistantClient.CreateThreadAndRun(assistant.Id, threadOptions);

// Sent the prompt and monitor progress until the thread run is complete
do
{
    Thread.Sleep(TimeSpan.FromSeconds(1));
    threadRun = assistantClient.GetRun(threadRun.ThreadId, threadRun.Id);
}
while (!threadRun.Status.IsTerminal);

// Get the messages from the thread run
var messages = assistantClient.GetMessagesAsync(
    threadRun.ThreadId,
    new MessageCollectionOptions()
    {
        Order = MessageCollectionOrder.Ascending
    });

  5. Imprima as mensagens e salve a imagem gerada da conversa com o assistente:

    // Process the messages from the assistant
await foreach (ThreadMessage message in messages)
{
    // Print out the messages from the assistant
    Console.Write($"[{message.Role.ToString().ToUpper()}]: ");
    foreach (MessageContent contentItem in message.Content)
    {
        if (!string.IsNullOrEmpty(contentItem.Text))
        {
            Console.WriteLine($"{contentItem.Text}");

            if (contentItem.TextAnnotations.Count > 0)
            {
                Console.WriteLine();
            }

            // Include annotations, if any
            foreach (TextAnnotation annotation in contentItem.TextAnnotations)
            {
                if (!string.IsNullOrEmpty(annotation.InputFileId))
                {
                    Console.WriteLine($"* File citation, file ID: {annotation.InputFileId}");
                }
                if (!string.IsNullOrEmpty(annotation.OutputFileId))
                {
                    Console.WriteLine($"* File output, new file ID: {annotation.OutputFileId}");
                }
            }
        }
        // Save the generated image file
        if (!string.IsNullOrEmpty(contentItem.ImageFileId))
        {
            OpenAIFile imageInfo = fileClient.GetFile(contentItem.ImageFileId);
            BinaryData imageBytes = fileClient.DownloadFile(contentItem.ImageFileId);
            using FileStream stream = File.OpenWrite($"{imageInfo.Filename}.png");
            imageBytes.ToStream().CopyTo(stream);

            Console.WriteLine($"<image: {imageInfo.Filename}.png>");
        }
    }
    Console.WriteLine();
}

    Localize e abra a imagem salva no diretório do aplicativo bin , que deve ser semelhante ao seguinte:

    Um grafo mostrando a visualização gerada pelo modelo de IA.

Próximas etapas