Partilhar via


Guia de início rápido: criar um novo agente

O Azure AI Foundry Agent Service permite que você crie agentes de IA adaptados às suas necessidades por meio de instruções personalizadas e aumentadas por ferramentas avançadas, como interpretador de código e funções personalizadas.

Pré-requisitos

  • Uma assinatura do Azure - Crie uma gratuitamente.
  • Verifique se o indivíduo que cria a conta e o projeto tem a função de Proprietário da Conta do Azure AI no escopo da assinatura
    • Como alternativa, ter a função de Colaborador ou Colaborador de Serviços Cognitivos no nível de assinatura também satisfaz esse requisito.

Importante

O portal do Azure AI Foundry só dá suporte ao conjunto de agentes básicos no momento. Se você quiser executar uma configuração de agente padrão, consulte o artigo Configuração de ambiente para saber mais.

Criar uma conta e um projeto do Foundry no portal do Azure AI Foundry

Para criar uma conta e um projeto no Azure AI Foundry, siga estas etapas:

  1. Vá para Azure AI Foundry. Se você estiver em um projeto, selecione Azure AI Foundry no canto superior esquerdo da página para ir para a página inicial.

  2. Utilize o fluxo de criação de iniciação do agente para uma experiência mais rápida. Clique em Criar um agente.

    Uma captura de tela do portal do Azure AI Foundry.

  3. Introduza um nome para o projeto. Se quiser personalizar os valores padrão, selecione Opções avançadas.

    Uma captura de tela das opções avançadas para criar um projeto.

  4. Selecione Criar.

  5. Aguarde até que seus recursos sejam provisionados.

    1. Uma conta e um projeto (recurso filho da sua conta) serão criados.
    2. O modelo gpt-4o será implantado automaticamente
    3. Um agente padrão será criado
  6. Uma vez concluído, você pousará diretamente no playground do agente e poderá começar a criar agentes.

    Captura de ecrã do playground do agente.

    Observação

    Se você estiver recebendo erro de permissão ao tentar configurar ou criar agentes, certifique-se de ter o Usuário do Azure AI no projeto.

| Documentação de referência | Exemplos | Código-fonte da biblioteca | Pacote (NuGet) |

Pré-requisitos

  • Um ambiente de agente configurado
  • Atribua a função RBACdo Usuário do Azure AI a cada membro da equipe que precisa criar ou editar agentes usando o SDK ou o Agent Playground
    • Essa função deve ser atribuída no escopo do projeto
    • Permissões mínimas necessárias: agentes/*/read, agents/*/action, agents/*/delete

Configurar e executar um agente

Componente Descrição
Agente IA personalizada que usa modelos de IA em conjunto com ferramentas.
Ferramenta As ferramentas ajudam a ampliar a capacidade de um agente de responder de forma confiável e precisa durante a conversa. Como conectar-se a bases de conhecimento definidas pelo usuário para fundamentar o modelo ou permitir que a pesquisa na Web forneça informações atuais.
Tópico Uma sessão de conversa entre um agente 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 agente ou um usuário. As mensagens podem incluir texto, imagens e outros ficheiros. As mensagens são armazenadas como uma lista no Thread.
Correr Ativação de um agente para começar a ser executado com base no conteúdo do Thread. O agente usa sua configuração e as Mensagens do Thread para executar tarefas chamando modelos e ferramentas. Como parte de uma execução, o agente acrescenta mensagens ao thread.

Crie um projeto de console .NET.

dotnet new console

Instale o pacote .NET em seu projeto. Por exemplo, se você estiver usando a CLI do .NET, execute o seguinte comando.

dotnet add package Azure.AI.Agents.Persistent
dotnet add package Azure.Identity

Em seguida, para autenticar suas solicitações de API e executar o programa, use o comando az login para entrar em sua assinatura do Azure.

az login

Use o código a seguir para criar e executar um agente. Para executar este código, precisarás obter o endpoint para o teu projeto. Esta cadeia de caracteres está no formato:

https://<AIFoundryResourceName>.services.ai.azure.com/api/projects/<ProjectName>

Sugestão

Você pode encontrar seu ponto de extremidade na visão geral do seu projeto no portal do Azure AI Foundry, em Bibliotecas>do Azure AI Foundry. Uma captura de ecrã mostrando o ponto de extremidade no portal do Azure AI Foundry.

Por exemplo, o seu ponto de extremidade pode ter o seguinte aspeto:

https://myresource.services.ai.azure.com/api/projects/myproject

Defina esse ponto de extremidade em uma variável appsetting chamada ProjectEndpoint.

using Azure;
using Azure.AI.Agents.Persistent;
using Azure.Identity;
using Microsoft.Extensions.Configuration;
using System.Diagnostics;

IConfigurationRoot configuration = new ConfigurationBuilder()
    .SetBasePath(AppContext.BaseDirectory)
    .AddJsonFile("appsettings.json", optional: false, reloadOnChange: true)
    .Build();

var projectEndpoint = configuration["ProjectEndpoint"];
var modelDeploymentName = configuration["ModelDeploymentName"];

//Create a PersistentAgentsClient and PersistentAgent.
PersistentAgentsClient client = new(projectEndpoint, new DefaultAzureCredential());

//Give PersistentAgent a tool to execute code using CodeInterpreterToolDefinition.
PersistentAgent agent = client.Administration.CreateAgent(
    model: modelDeploymentName,
    name: "My Test Agent",
    instructions: "You politely help with math questions. Use the code interpreter tool when asked to visualize numbers.",
    tools: [new CodeInterpreterToolDefinition()]
);

//Create a thread to establish a session between Agent and a User.
PersistentAgentThread thread = client.Threads.CreateThread();

//Ask a question of the Agent.
client.Messages.CreateMessage(
    thread.Id,
    MessageRole.User,
    "Hi, Agent! Draw a graph for a line with a slope of 4 and y-intercept of 9.");

//Have Agent beging processing user's question with some additional instructions associated with the ThreadRun.
ThreadRun run = client.Runs.CreateRun(
    thread.Id,
    agent.Id,
    additionalInstructions: "Please address the user as Jane Doe. The user has a premium account.");

//Poll for completion.
do
{
    Thread.Sleep(TimeSpan.FromMilliseconds(500));
    run = client.Runs.GetRun(thread.Id, run.Id);
}
while (run.Status == RunStatus.Queued
    || run.Status == RunStatus.InProgress
    || run.Status == RunStatus.RequiresAction);

//Get the messages in the PersistentAgentThread. Includes Agent (Assistant Role) and User (User Role) messages.
Pageable<PersistentThreadMessage> messages = client.Messages.GetMessages(
    threadId: thread.Id,
    order: ListSortOrder.Ascending);

//Display each message and open the image generated using CodeInterpreterToolDefinition.
foreach (PersistentThreadMessage threadMessage in messages)
{
    foreach (MessageContent content in threadMessage.ContentItems)
    {
        switch (content)
        {
            case MessageTextContent textItem:
                Console.WriteLine($"[{threadMessage.Role}]: {textItem.Text}");
                break;
            case MessageImageFileContent imageFileContent:
                Console.WriteLine($"[{threadMessage.Role}]: Image content file ID = {imageFileContent.FileId}");
                BinaryData imageContent = client.Files.GetFileContent(imageFileContent.FileId);
                string tempFilePath = Path.Combine(AppContext.BaseDirectory, $"{Guid.NewGuid()}.png");
                File.WriteAllBytes(tempFilePath, imageContent.ToArray());
                client.Files.DeleteFile(imageFileContent.FileId);

                ProcessStartInfo psi = new()
                {
                    FileName = tempFilePath,
                    UseShellExecute = true
                };
                Process.Start(psi);
                break;
        }
    }
}

//Clean up test resources.
client.Threads.DeleteThread(threadId: thread.Id);
client.Administration.DeleteAgent(agentId: agent.Id);

| Documentação de referência | Exemplos | Código fonte da biblioteca | Pacote (PyPi) |

Pré-requisitos

  • Um ambiente de agente configurado
  • Atribua a função RBACdo Usuário do Azure AI a cada membro da equipe que precisa criar ou editar agentes usando o SDK ou o Agent Playground
    • Essa função deve ser atribuída no escopo do projeto
    • Permissões mínimas necessárias: agentes/*/read, agents/*/action, agents/*/delete

Configurar e executar um agente

Componente Descrição
Agente IA personalizada que usa modelos de IA em conjunto com ferramentas.
Ferramenta As ferramentas ajudam a ampliar a capacidade de um agente de responder de forma confiável e precisa durante a conversa. Como conectar-se a bases de conhecimento definidas pelo usuário para fundamentar o modelo ou permitir que a pesquisa na Web forneça informações atuais.
Tópico Uma sessão de conversa entre um agente 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 agente ou um usuário. As mensagens podem incluir texto, imagens e outros ficheiros. As mensagens são armazenadas como uma lista no Thread.
Correr Ativação de um agente para começar a ser executado com base no conteúdo do Thread. O agente usa sua configuração e as Mensagens do Thread para executar tarefas chamando modelos e ferramentas. Como parte de uma execução, o agente acrescenta mensagens ao thread.
Executar Etapa Uma lista detalhada das etapas que o agente seguiu durante um percurso. Um agente pode chamar ferramentas ou criar mensagens durante sua execução. Examinar as etapas de execução permite entender como o agente está chegando aos resultados.

Execute os seguintes comandos para instalar os pacotes python.

pip install azure-ai-projects
pip install azure-identity

Em seguida, para autenticar suas solicitações de API e executar o programa, use o comando az login para entrar em sua assinatura do Azure.

az login

Use o código a seguir para criar e executar um agente. Para executar este código, precisarás obter o endpoint para o teu projeto. Esta cadeia de caracteres está no formato:

https://<AIFoundryResourceName>.services.ai.azure.com/api/projects/<ProjectName>

Sugestão

Você pode encontrar seu ponto de extremidade na visão geral do seu projeto no portal do Azure AI Foundry, em Bibliotecas>do Azure AI Foundry. Uma captura de ecrã mostrando o ponto de extremidade no portal do Azure AI Foundry.

Por exemplo, o seu ponto de extremidade pode ter o seguinte aspeto:

https://myresource.services.ai.azure.com/api/projects/myproject

Defina esse ponto de extremidade como uma variável de ambiente chamada PROJECT_ENDPOINT.

import os
from azure.ai.projects import AIProjectClient
from azure.identity import DefaultAzureCredential
from azure.ai.agents.models import CodeInterpreterTool

# Create an Azure AI Client from an endpoint, copied from your Azure AI Foundry project.
# You need to login to Azure subscription via Azure CLI and set the environment variables
project_endpoint = os.environ["PROJECT_ENDPOINT"]  # Ensure the PROJECT_ENDPOINT environment variable is set

# Create an AIProjectClient instance
project_client = AIProjectClient(
    endpoint=project_endpoint,
    credential=DefaultAzureCredential(),  # Use Azure Default Credential for authentication
)

code_interpreter = CodeInterpreterTool()
with project_client:
    # Create an agent with the Bing Grounding tool
    agent = project_client.agents.create_agent(
        model=os.environ["MODEL_DEPLOYMENT_NAME"],  # Model deployment name
        name="my-agent",  # Name of the agent
        instructions="You are a helpful agent",  # Instructions for the agent
        tools=code_interpreter.definitions,  # Attach the tool
    )
    print(f"Created agent, ID: {agent.id}")

    # Create a thread for communication
    thread = project_client.agents.threads.create()
    print(f"Created thread, ID: {thread.id}")
    
    # Add a message to the thread
    message = project_client.agents.messages.create(
        thread_id=thread.id,
        role="user",  # Role of the message sender
        content="What is the weather in Seattle today?",  # Message content
    )
    print(f"Created message, ID: {message['id']}")
    
    # Create and process an agent run
    run = project_client.agents.runs.create_and_process(thread_id=thread.id, agent_id=agent.id)
    print(f"Run finished with status: {run.status}")
    
    # Check if the run failed
    if run.status == "failed":
        print(f"Run failed: {run.last_error}")
    
    # Fetch and log all messages
    messages = project_client.agents.messages.list(thread_id=thread.id)
    for message in messages:
        print(f"Role: {message.role}, Content: {message.content}")
    
    # Delete the agent when done
    project_client.agents.delete_agent(agent.id)
    print("Deleted agent")

| Documentação de referência | Exemplos | Biblioteca código fonte | Pacote (npm) |

Pré-requisitos

  • Um ambiente de agente configurado
  • Atribua a função RBACdo Usuário do Azure AI a cada membro da equipe que precisa criar ou editar agentes usando o SDK ou o Agent Playground
    • Essa função deve ser atribuída no escopo do projeto
    • Permissões mínimas necessárias: agentes/*/read, agents/*/action, agents/*/delete

Configurar e executar um agente

Componente Descrição
Agente IA personalizada que usa modelos de IA com ferramentas.
Ferramenta As ferramentas ajudam a ampliar a capacidade de um agente de responder de forma confiável e precisa durante a conversa. Como conectar-se a bases de conhecimento definidas pelo usuário para fundamentar o modelo ou permitir que a pesquisa na Web forneça informações atuais.
Tópico Uma sessão de conversa entre um agente 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 agente ou um usuário. As mensagens podem incluir texto, imagens e outros ficheiros. As mensagens são armazenadas como uma lista no Thread.
Correr Ativação de um agente para começar a ser executado com base no conteúdo do Thread. O agente usa sua configuração e as Mensagens do Thread para executar tarefas chamando modelos e ferramentas. Como parte de uma execução, o agente acrescenta mensagens ao thread.
Executar Etapa Uma lista detalhada das etapas que o agente seguiu durante um percurso. Um agente pode chamar ferramentas ou criar mensagens durante sua execução. Examinar as etapas de execução permite entender como o agente está chegando aos resultados.

Os principais objetos neste código incluem:

Primeiro, inicialize um novo projeto executando:

npm init -y

Execute os seguintes comandos para instalar os pacotes npm necessários.

npm install @azure/ai-agents @azure/identity
npm install dotenv

Em seguida, para autenticar suas solicitações de API e executar o programa, use o comando az login para entrar em sua assinatura do Azure.

az login

Use o código a seguir para criar e executar um agente que carrega um arquivo CSV de dados e, em seguida, gera um gráfico de barras a partir desses dados. Para executar esse código, você precisará obter o ponto de extremidade para seu projeto. Esta cadeia de caracteres está no formato:

https://<AIFoundryResourceName>.services.ai.azure.com/api/projects/<ProjectName>

Sugestão

Você pode encontrar seu ponto de extremidade na visão geral do seu projeto no portal do Azure AI Foundry, em Bibliotecas>do Azure AI Foundry. Uma captura de ecrã mostrando o ponto de extremidade no portal do Azure AI Foundry.

Por exemplo, o seu ponto de extremidade tem o seguinte aspecto:

https://myresource.services.ai.azure.com/api/projects/myproject

Defina esse ponto de extremidade como uma variável de ambiente nomeada PROJECT_ENDPOINT em um .env arquivo.

Importante

  • Este código de início rápido usa variáveis de ambiente para configuração confidencial. Nunca incorpore o seu ficheiro .env no controlo de versão, certificando-se de que .env está listado no seu ficheiro .gitignore.
  • Lembre-se: se você acidentalmente expuser informações confidenciais, considere essas credenciais comprometidas e altere-as imediatamente.

Em seguida, crie um index.js arquivo e cole o seguinte código:

// Copyright (c) Microsoft Corporation.
// Licensed under the MIT License.

/**
 * This sample demonstrates how to use agent operations with code interpreter from the Azure Agents service.
 *
 * @summary demonstrates how to use agent operations with code interpreter.
 */
// @ts-nocheck
import type {
  MessageDeltaChunk,
  MessageDeltaTextContent,
  MessageImageFileContent,
  MessageTextContent,
  ThreadRun,
} from "@azure/ai-agents";
import {
  RunStreamEvent,
  MessageStreamEvent,
  DoneEvent,
  ErrorEvent,
  AgentsClient,
  isOutputOfType,
  ToolUtility,
} from "@azure/ai-agents";
import { DefaultAzureCredential } from "@azure/identity";

import * as fs from "fs";
import path from "node:path";
import "dotenv/config";

const projectEndpoint = process.env["PROJECT_ENDPOINT"] || "<project endpoint>";
const modelDeploymentName = process.env["MODEL_DEPLOYMENT_NAME"] || "gpt-4o";

export async function main(): Promise<void> {
  // Create an Azure AI Client
  const client = new AgentsClient(projectEndpoint, new DefaultAzureCredential());

  // Upload file and wait for it to be processed
  const filePath = "./data/nifty500QuarterlyResults.csv";
  const localFileStream = fs.createReadStream(filePath);
  const localFile = await client.files.upload(localFileStream, "assistants", {
    fileName: "myLocalFile",
  });

  console.log(`Uploaded local file, file ID : ${localFile.id}`);

  // Create code interpreter tool
  const codeInterpreterTool = ToolUtility.createCodeInterpreterTool([localFile.id]);

  // Notice that CodeInterpreter must be enabled in the agent creation, otherwise the agent will not be able to see the file attachment
  const agent = await client.createAgent(modelDeploymentName, {
    name: "my-agent",
    instructions: "You are a helpful agent",
    tools: [codeInterpreterTool.definition],
    toolResources: codeInterpreterTool.resources,
  });
  console.log(`Created agent, agent ID: ${agent.id}`);

  // Create a thread
  const thread = await client.threads.create();
  console.log(`Created thread, thread ID: ${thread.id}`);

  // Create a message
  const message = await client.messages.create(
    thread.id,
    "user",
    "Could you please create a bar chart in the TRANSPORTATION sector for the operating profit from the uploaded CSV file and provide the file to me?",
  );

  console.log(`Created message, message ID: ${message.id}`);

  // Create and execute a run
  const streamEventMessages = await client.runs.create(thread.id, agent.id).stream();

  for await (const eventMessage of streamEventMessages) {
    switch (eventMessage.event) {
      case RunStreamEvent.ThreadRunCreated:
        console.log(`ThreadRun status: ${(eventMessage.data as ThreadRun).status}`);
        break;
      case MessageStreamEvent.ThreadMessageDelta:
        {
          const messageDelta = eventMessage.data as MessageDeltaChunk;
          messageDelta.delta.content.forEach((contentPart) => {
            if (contentPart.type === "text") {
              const textContent = contentPart as MessageDeltaTextContent;
              const textValue = textContent.text?.value || "No text";
              console.log(`Text delta received:: ${textValue}`);
            }
          });
        }
        break;

      case RunStreamEvent.ThreadRunCompleted:
        console.log("Thread Run Completed");
        break;
      case ErrorEvent.Error:
        console.log(`An error occurred. Data ${eventMessage.data}`);
        break;
      case DoneEvent.Done:
        console.log("Stream completed.");
        break;
    }
  }

  // Delete the original file from the agent to free up space (note: this does not delete your version of the file)
  await client.files.delete(localFile.id);
  console.log(`Deleted file, file ID : ${localFile.id}`);

  // Print the messages from the agent
  const messagesIterator = client.messages.list(thread.id);
  const messagesArray = [];
  for await (const m of messagesIterator) {
    messagesArray.push(m);
  }
  console.log("Messages:", messagesArray);

  // Get most recent message from the assistant
// Get most recent message from the assistant
  const assistantMessage = messagesArray.find((msg) => msg.role === "assistant");
  if (assistantMessage) {
    // Look for an image file in the assistant's message
    const imageFileOutput = assistantMessage.content.find(content => 
      content.type === "image_file" && content.imageFile?.fileId);
    
    if (imageFileOutput) {
      try {
        // Save the newly created file
        console.log(`Saving new files...`);
        const imageFile = imageFileOutput.imageFile.fileId;
        const imageFileName = path.resolve(
          "./data/" + (await client.files.get(imageFile)).filename + "ImageFile.png",
        );
        console.log(`Image file name : ${imageFileName}`);

        const fileContent = await client.files.getContent(imageFile).asNodeStream();
        if (fileContent && fileContent.body) {
          const chunks = [];
          for await (const chunk of fileContent.body) {
            chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
          }
          const buffer = Buffer.concat(chunks);
          fs.writeFileSync(imageFileName, buffer);
          console.log(`Successfully saved image to ${imageFileName}`);
        } else {
          console.error("No file content available in the response");
        }
      } catch (error) {
        console.error("Error saving image file:", error);
      }
    } else {
      console.log("No image file found in assistant's message");
    }
  } else {
    console.log("No assistant message found");
  }

  // Iterate through messages and print details for each annotation
  console.log(`Message Details:`);
  messagesArray.forEach((m) => {
    console.log(`File Paths:`);
    console.log(`Type: ${m.content[0].type}`);
    if (isOutputOfType<MessageTextContent>(m.content[0], "text")) {
      const textContent = m.content[0] as MessageTextContent;
      console.log(`Text: ${textContent.text.value}`);
    }
    console.log(`File ID: ${m.id}`);
    // firstId and lastId are properties of the paginator, not the messages array
    // Removing these references as they don't exist in this context
  });

  // Delete the agent once done
  await client.deleteAgent(agent.id);
  console.log(`Deleted agent, agent ID: ${agent.id}`);
}

main().catch((err) => {
  console.error("The sample encountered an error:", err);
});

Execute o código usando node index.js. Este código gera um ficheiro de imagem PNG de gráfico de barras no setor de TRANSPORTE para o lucro operacional a partir do ficheiro CSV carregado e disponibiliza-o para si. Exemplo completo de código-fonte disponível.

| Documentação de referência |

Pré-requisitos

  • Um ambiente de agente configurado
  • Atribua a função RBACdo Usuário do Azure AI a cada membro da equipe que precisa criar ou editar agentes usando o SDK ou o Agent Playground
    • Essa função deve ser atribuída no escopo do projeto
    • Permissões mínimas necessárias: agentes/*/read, agents/*/action, agents/*/delete

Configurar e executar um agente

Componente Descrição
Agente IA personalizada que usa modelos de IA em conjunto com ferramentas.
Ferramenta As ferramentas ajudam a ampliar a capacidade de um agente de responder de forma confiável e precisa durante a conversa. Como conectar-se a bases de conhecimento definidas pelo usuário para fundamentar o modelo ou permitir que a pesquisa na Web forneça informações atuais.
Tópico Uma sessão de conversa entre um agente 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 agente ou um usuário. As mensagens podem incluir texto, imagens e outros ficheiros. As mensagens são armazenadas como uma lista no Thread.
Correr Ativação de um agente para começar a ser executado com base no conteúdo do Thread. O agente usa sua configuração e as Mensagens do Thread para executar tarefas chamando modelos e ferramentas. Como parte de uma execução, o agente acrescenta mensagens ao thread.
Executar Etapa Uma lista detalhada das etapas que o agente seguiu durante um percurso. Um agente pode chamar ferramentas ou criar mensagens durante sua execução. Examinar as etapas de execução permite entender como o agente está chegando aos resultados.

Informações de chamada de API

Para autenticar suas solicitações de API, use o comando az login para entrar em sua assinatura do Azure.

az login

Em seguida, deverá obter o token Entra ID para fornecer como autorização para as chamadas de API. Buscar o token usando o comando CLI:

az account get-access-token --resource 'https://ai.azure.com' | jq -r .accessToken | tr -d '"'

Defina o token de acesso como uma variável de ambiente chamada AGENT_TOKEN.

Para fazer chamadas de API REST com êxito para o Serviço Azure AI Foundry Agent, terá de usar o endpoint como indicado abaixo:

https://<your_ai_service_name>.services.ai.azure.com/api/projects/<your_project_name>

Por exemplo, o seu ponto de extremidade pode ter o seguinte aspeto:

https://exampleaiservice.services.ai.azure.com/api/projects/project

Defina esse ponto de extremidade como uma variável de ambiente chamada AZURE_AI_FOUNDRY_PROJECT_ENDPOINT.

Observação

  • Para api-version o parâmetro, a versão da API do GA é 2025-05-01 e a versão mais recente da API de visualização é 2025-05-15-preview. Você deve usar a API de visualização para ferramentas que estão em visualização.
  • Considere tornar sua versão da API uma variável de ambiente, como $API_VERSION.

Criar um agente

Observação

Com o Azure AI Agents Service, o parâmetro requer o nome de implantação do modelo model. Se o nome de implementação do modelo for diferente do nome do modelo subjacente, deve ajustar o seu código para "model": "{your-custom-model-deployment-name}".

curl --request POST \
  --url $AZURE_AI_FOUNDRY_PROJECT_ENDPOINT/assistants?api-version=2025-05-01 \
  -H "Authorization: Bearer $AGENT_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "instructions": "You are a helpful agent.",
    "name": "my-agent",
    "tools": [{"type": "code_interpreter"}],
    "model": "gpt-4o-mini"
  }'

Criar um thread

curl --request POST \
  --url $AZURE_AI_FOUNDRY_PROJECT_ENDPOINT/threads?api-version=2025-05-01 \
  -H "Authorization: Bearer $AGENT_TOKEN" \
  -H "Content-Type: application/json" \
  -d ''

Adicionar uma pergunta de usuário ao thread

curl --request POST \
  --url $AZURE_AI_FOUNDRY_PROJECT_ENDPOINT/threads/thread_abc123/messages?api-version=2025-05-01 \
  -H "Authorization: Bearer $AGENT_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
      "role": "user",
      "content": "I need to solve the equation `3x + 11 = 14`. Can you help me?"
    }'

Executar o thread

curl --request POST \
  --url $AZURE_AI_FOUNDRY_PROJECT_ENDPOINT/threads/thread_abc123/runs?api-version=2025-05-01 \
  -H "Authorization: Bearer $AGENT_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "assistant_id": "asst_abc123",
  }'

Recuperar o status da execução

curl --request GET \
  --url $AZURE_AI_FOUNDRY_PROJECT_ENDPOINT/threads/thread_abc123/runs/run_abc123?api-version=2025-05-01 \
  -H "Authorization: Bearer $AGENT_TOKEN"

Recuperar a resposta do agente

curl --request GET \
  --url $AZURE_AI_FOUNDRY_PROJECT_ENDPOINT/threads/thread_abc123/messages?api-version=2025-05-01 \
  -H "Authorization: Bearer $AGENT_TOKEN"