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

2025-06-30

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:

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.
Utilize o fluxo de criação de iniciação do agente para uma experiência mais rápida. Clique em Criar um agente.
Introduza um nome para o projeto. Se quiser personalizar os valores padrão, selecione Opções avançadas.
Selecione Criar.
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
Uma vez concluído, você pousará diretamente no playground do agente e poderá começar a criar agentes.

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.

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.

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

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.

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

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.

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"

Partilhar via

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

Pré-requisitos

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

Pré-requisitos

Configurar e executar um agente

Pré-requisitos

Configurar e executar um agente

Pré-requisitos

Configurar e executar um agente

Pré-requisitos

Configurar e executar um agente

Informações de chamada de API

Criar um agente

Criar um thread

Adicionar uma pergunta de usuário ao thread

Executar o thread

Recuperar o status da execução

Recuperar a resposta do agente

Comentários

Recursos adicionais