Nota
O acesso a esta página requer autorização. Pode tentar iniciar sessão ou alterar os diretórios.
O acesso a esta página requer autorização. Pode tentar alterar os diretórios.
Um recurso Foundry fornece acesso unificado a modelos, agentes e ferramentas. Este artigo explica qual o SDK e endpoint a usar para o seu cenário.
O SDK Foundry é um SDK thin-client que expõe todas as APIs do projeto Foundry através de um único endpoint de projeto. SDKs de nível superior baseiam-se nele — por exemplo, o pacote Agent Framework foundry depende do SDK Foundry para aceder a modelos, ferramentas e configuração de projetos Foundry.
| SDK | Para que serve | Ponto final |
|---|---|---|
| Foundry SDK | SDK thin-client para todas as APIs de todos os projetos Foundry. Acesso a Foundry Models e ferramentas de plataforma (pesquisa de ficheiros, interpretador de código, pesquisa web, memória, SharePoint, WorkIQ, Fabric IQ, MCP). | https://<resource-name>.services.ai.azure.com/api/projects/<project-name> |
| Quadro de Agente | Orquestração multiagente unificada para agentes alojados e sistemas multiagente, disponível em C#/.NET e Python. O foundry pacote depende do SDK do Foundry para acesso ao projeto. |
API de respostas no endpoint do projeto, via FoundryChatClient. |
| OpenAI SDK | Superfície completa da API OpenAI, incluindo embeddings e modelos Foundry vendidos pelo Azure através do Chat Completions. Melhor latência e máxima compatibilidade com OpenAI. | https://<resource-name>.openai.azure.com/openai/v1 |
| Anthropic SDK | Modelos Anthropic Claude implementados no Foundry. | https://<resource-name>.services.ai.azure.com/anthropic |
| SDKs de Ferramentas de Fundição | Soluções pré-construídas (Visão, Fala, Segurança de Conteúdos e mais). | Pontos de extremidade específicos da ferramenta. |
Escolha o seu SDK:
- Use o Foundry SDK ao criar aplicações com agentes, avaliações ou funcionalidades específicas da Foundry
- Utilize Agent Framework para agentes alojados ou sistemas multiagente em código, usando a API Responses em C#/.NET ou Python
- Use o SDK OpenAI quando for necessária a máxima compatibilidade OpenAI ou a menor latência, ao gerar embeddings ou ao usar modelos vendidos pelo Azure através do Chat Completions
- Use Anthropic SDK ao trabalhar com modelos Anthropic Claude implementados no Foundry
- Utilize os SDKs das Ferramentas Foundry ao trabalhar com serviços específicos de IA (visão, fala, linguagem, etc.)
Nota
Tipos de recursos: Um recurso da Foundry fornece todos os endpoints anteriormente listados. Um recurso Azure OpenAI fornece apenas o endpoint /openai/v1.
Authentication: Os exemplos aqui usam Microsoft Entra ID (DefaultAzureCredential). As chaves API funcionam em /openai/v1. Passa a chave como api_key em vez de um fornecedor de tokens.
Pré-requisitos
-
Uma conta no Azure com uma subscrição ativa. Se não tiveres uma, cria uma conta Azure free, que inclui uma subscrição de teste gratuita.
Tenha o papel Azure RBAC exigido para a sua tarefa no âmbito mais restrito:
Utilizador da Foundry no projeto Foundry para o desenvolvimento diário.
Importante
As funções RBAC do Foundry foram recentemente renomeadas. Foundry User, Foundry Owner, Foundry Account Owner e Foundry Project Manager foram anteriormente nomeados Azure AI User, Azure AI Owner, Azure AI Account Owner e Azure AI Project Manager. Poderá ainda ver os nomes anteriores em alguns locais enquanto esta alteração de nome está a ser implementada. Os IDs das funções e as permissões principais não são alterados por esta mudança de nome.
Gestor de Project Foundry no project Foundry para gerir um project existente e as suas ligações.
Proprietário da Conta Foundry no recurso Foundry para criar projetos ou gerir recursos ao nível da conta. Atribui esta função ao grupo de recursos alvo apenas quando precisares de criar um recurso da Foundry.
Ative a atribuição de grupo de recursos mesmo a tempo através do Microsoft Entra Privileged Identity Management (PIM) e desative-a após o provisionamento. Os programadores do dia a dia e os utilizadores de runtime não precisam desta tarefa elevada.
Para detalhes sobre as permissões de cada função, veja Controlo de acesso baseado em funções para Microsoft Foundry.
Instale os runtimes de linguagem necessários, ferramentas globais e extensões VS Code conforme descrito em Preparar o seu ambiente de desenvolvimento.
Verificar os pré-requisitos
Antes de prosseguir, confirme que cada verificação retorna o resultado indicado:
Confirme que a CLI do Azure utiliza a subscrição e o tenant pretendidos:
az account show --query "{subscription:name, tenant:tenantId}" --output tableO comando sai com sucesso e mostra a subscrição e o tenant esperados.
Confirme se a sua credencial local pode solicitar um token de acesso Foundry sem mostrar o token:
az account get-access-token --resource https://ai.azure.com --query expiresOn --output tsvO comando sai com sucesso e mostra o tempo de expiração do token. Se falhar, joga
az logincom uma identidade que tenha o papel exigido de Foundry.Confirme que tem o papel RBAC exigido no portal Azure em Controlo de Acesso a Recursos> daFoundry (IAM).
- Execute
python --version. O comando sai com sucesso e reporta Python 3.9 ou posterior.
- Execute
node --version. O comando sai com sucesso e reporta Node.js 22 ou mais tarde.
- Execute
dotnet --version. O comando sai com sucesso e reporta .NET 8 ou posterior.
- Execute
java --version. O comando sai com sucesso e reporta Java 17 ou posterior.
Confirme que o endpoint do seu projeto tem este formato:
https://<resource-name>.services.ai.azure.com/api/projects/<project-name>.Confirme que a
gpt-5-miniimplementação está pronta:az cognitiveservices account deployment show \ --name <resource-name> \ --resource-group <resource-group> \ --deployment-name gpt-5-mini \ --query properties.provisioningState \ --output tsvO comando retorna
Succeeded. Use o nome de implementação nos exemplos de código se a sua implementação tiver um nome diferente.
Foundry SDK
O Foundry SDK é um SDK thin-client que lhe dá acesso a todas as APIs do projeto Foundry através de um único endpoint de projeto:
https://<resource-name>.services.ai.azure.com/api/projects/<project-name>
É a base sobre a qual são desenvolvidos outros SDKs compatíveis com a Foundry. Por exemplo, o pacote Agent Framework foundry tem uma dependência do SDK Foundry e utiliza-o para aceder às funcionalidades do Foundry — não tem de configurar o ponto final do projeto nem o cliente compatível com OpenAI quando utiliza FoundryChatClient.
Nota
Se a sua organização usar um subdomínio personalizado, substitua <resource-name> por <your-custom-subdomain> na URL do endpoint.
Esta abordagem simplifica a configuração da aplicação. Em vez de gerir múltiplos endpoints, configura-se um.
Instalar o SDK do Foundry
| Versão SDK | Versão Portal | Estado | Pacote Python |
|---|---|---|---|
| 2.x | Fundição (nova) | Estável | azure-ai-projects>=2.0.0 |
| 1.x | Foundry (clássico) | Estável | azure-ai-projects==1.0.0 |
A biblioteca cliente Azure AI Projects para Python é uma biblioteca unificada que permite usar múltiplas bibliotecas clientes em conjunto, ligando-as a um único endpoint de projeto.
Execute este comando para instalar os pacotes para projetos Foundry.
pip install "azure-ai-projects>=2.0.0"
| Versão SDK | Versão Portal | Estado | Pacote Java |
|---|---|---|---|
| 2.0.0 | Fundição (nova) | Estável | azure-ai-projectsazure-ai-agents |
| Versão SDK | Versão Portal | Estado | Pacote JavaScript |
|---|---|---|---|
| 2.4.0 | Fundição (nova) | Estável | @azure/ai-projects |
| 1.0.1 | Clássico da fundição | Estável | @azure/ai-projects |
Usa Node.js 22 ou posterior com @azure/ai-projects a 2.4.0.
| Versão SDK | Versão Portal | Estado | Pacote .NET |
|---|---|---|---|
| 2.0.0 (GA) | Fundição (nova) | Estável | Azure.AI.ProjectsAzure.AI.Projects.AgentsAzure.AI.Extensions.OpenAI |
| 1.1.0 (GA) | Clássico da fundição | Estável | Azure.AI.Projects |
Importante
Não instales Azure.AI.Projects.OpenAI (pré-visualização) juntamente com Azure.AI.Extensions.OpenAI (GA). Ambos os pacotes definem os mesmos tipos em diferentes espaços de nomes, o que causa erros ambíguos de referência. Usa apenas Azure.AI.Extensions.OpenAI para cenários de agente.
A biblioteca cliente Azure AI Projects para Java é uma biblioteca unificada que permite usar múltiplas bibliotecas clientes em conjunto ligando-se a um único endpoint de projeto.
Adiciona estas dependências aos teus projetos Maven pom.xml for Foundry.
<dependency>
<groupId>com.azure</groupId>
<artifactId>azure-ai-projects</artifactId>
<version>2.2.0</version>
</dependency>
<dependency>
<groupId>com.azure</groupId>
<artifactId>azure-ai-agents</artifactId>
<version>2.2.0</version>
</dependency>
<dependency>
<groupId>com.azure</groupId>
<artifactId>azure-identity</artifactId>
<version>1.18.4</version>
</dependency>
A biblioteca cliente Azure AI Projects para JavaScript é uma biblioteca unificada que permite usar múltiplas bibliotecas clientes em conjunto ao ligar-se a um único endpoint de projeto.
Execute este comando para instalar os pacotes JavaScript dos projetos Foundry.
npm install @azure/ai-projects @azure/identity
A biblioteca cliente Azure AI Projects para .NET é uma biblioteca unificada que permite usar múltiplas bibliotecas clientes em conjunto ligando-as a um único endpoint de projeto.
Execute estes comandos para adicionar os pacotes necessários ao seu projeto .NET.
dotnet add package Azure.AI.Projects
dotnet add package Azure.AI.Projects.Agents
dotnet add package Azure.AI.Extensions.OpenAI
dotnet add package Azure.Identity
Faça a sua primeira chamada para o SDK da Foundry
O SDK expõe dois tipos de clientes porque o Foundry e o OpenAI têm formas de API diferentes:
- Project client – Uso para operações nativas da Foundry onde a OpenAI não tem equivalente. Exemplos: listar ligações, recuperar propriedades do projeto, ativar o rastreio.
-
Cliente compatível com OpenAI – Funcionalidade Use for Foundry que se baseia em conceitos OpenAI. A API de Respostas, os agentes, as avaliações e o ajuste fino utilizam todos padrões de pedido/resposta ao estilo OpenAI. Este cliente direciona-se para a API Responses no endpoint do seu projeto, que lhe dá acesso a Foundry Models vendidos pelo Azure, outros modelos do catálogo e ferramentas da plataforma. Estas ferramentas incluem pesquisa de ficheiros, interpretador de código, pesquisa web, memória, SharePoint, WorkIQ, Fabric IQ e servidores MCP. O endpoint do projeto serve este tráfego na
/openairota.
A maioria das aplicações usa ambos os clientes. Use o cliente do projeto para configuração e configuração, depois use o cliente compatível com OpenAI para executar agentes, avaliações e chamar modelos.
from azure.ai.projects import AIProjectClient
from azure.identity import DefaultAzureCredential
project_endpoint = (
"https://<resource-name>.services.ai.azure.com/api/projects/<project-name>"
)
project = AIProjectClient(
endpoint=project_endpoint,
credential=DefaultAzureCredential(),
)
openai = project.get_openai_client()
response = openai.responses.create(
model="gpt-5-mini",
input="What is the size of France in square miles?",
)
print(f"Response output: {response.output_text}")
Response output: <model response>
Referência: classe AIProjectClient
import com.azure.ai.agents.AgentsClientBuilder;
import com.azure.ai.agents.AgentsServiceVersion;
import com.azure.ai.agents.ResponsesClient;
import com.azure.identity.DefaultAzureCredentialBuilder;
import com.openai.models.responses.Response;
import com.openai.models.responses.ResponseCreateParams;
String projectEndpoint =
"https://<resource-name>.services.ai.azure.com/api/projects/<project-name>";
ResponsesClient responsesClient = new AgentsClientBuilder()
.credential(new DefaultAzureCredentialBuilder().build())
.endpoint(projectEndpoint)
.serviceVersion(AgentsServiceVersion.getLatest())
.buildResponsesClient();
Response response = responsesClient.getResponseService().create(
ResponseCreateParams.builder()
.model("gpt-5-mini")
.input("What is the size of France in square miles?")
.build());
response.output().forEach(item -> item.message().ifPresent(message ->
message.content().forEach(content -> content.outputText().ifPresent(text ->
System.out.println("Response output: " + text.text())))));
Response output: <model response>
Referência: CreateResponse.java
import { DefaultAzureCredential } from "@azure/identity";
import { AIProjectClient } from "@azure/ai-projects";
const projectEndpoint =
"https://<resource-name>.services.ai.azure.com/api/projects/<project-name>";
const project = new AIProjectClient(
projectEndpoint,
new DefaultAzureCredential(),
);
const openai = project.getOpenAIClient();
const response = await openai.responses.create({
model: "gpt-5-mini",
input: "What is the size of France in square miles?",
});
console.log(`Response output: ${response.output_text}`);
Response output: <model response>
Referência: classe AIProjectClient
using Azure.AI.Projects;
using Azure.AI.Extensions.OpenAI;
using Azure.Identity;
string projectEndpoint =
"https://<resource-name>.services.ai.azure.com/api/projects/<project-name>";
AIProjectClient projectClient = new(
endpoint: new Uri(projectEndpoint),
tokenProvider: new DefaultAzureCredential());
ProjectResponsesClient responseClient = projectClient.ProjectOpenAIClient
.GetProjectResponsesClientForModel("gpt-5-mini");
ResponseResult response = responseClient.CreateResponse(
"What is the size of France in square miles?");
Console.WriteLine($"Response output: {response.GetOutputText()}");
Response output: <model response>
Referência: classe AIProjectClient
Explore as capacidades do SDK do Foundry
- Access Foundry Models, incluindo Azure OpenAI
- Use o Serviço de Agente de Fundição
- Executar avaliações em lote
- Ativar rastreamento de aplicações
- Ajustar finamente um modelo
- Obtenha endpoints e chaves para Foundry Tools, para orquestração local e outras funcionalidades.
Resolução de problemas
Erros de autenticação
Se vir DefaultAzureCredential failed to retrieve a token:
Verificar se a CLI do Azure está autenticada:
az account show az login # if not logged inVerifique a atribuição de funções no RBAC:
Confirma que tens pelo menos o papel de Utilizador Foundry no projeto Foundry
Importante
As funções RBAC do Foundry foram recentemente renomeadas. Foundry User, Foundry Owner, Foundry Account Owner e Foundry Project Manager foram anteriormente nomeados Azure AI User, Azure AI Owner, Azure AI Account Owner e Azure AI Project Manager. Poderá ainda ver os nomes anteriores em alguns locais enquanto esta alteração de nome está a ser implementada. Os IDs das funções e as permissões principais não são alterados por esta mudança de nome.
Para identidade gerida em produção:
- Garantir que a identidade gerida tem o papel apropriado atribuído
- Ver Configurar identidades geridas
Erros de configuração de endpoints
Se visualizares Connection refused ou 404 Not Found:
- Verifique se os nomes dos recursos e projetos correspondem à sua implementação real
-
Verificar o formato da URL do endpoint: Deve ser
https://<resource-name>.services.ai.azure.com/api/projects/<project-name> -
Para subdomínios personalizados: Substitua
<resource-name>pelo seu subdomínio personalizado
Incompatibilidades de versões do SDK
Se os exemplos de código falharem com AttributeError ou ModuleNotFoundError:
Verifique a versão do SDK:
pip show azure-ai-projects # Python npm list @azure/ai-projects # JavaScript dotnet list package # .NETReinstalar com os flags de versão corretos: Consulte comandos de instalação em cada secção de linguagem acima
OpenAI SDK
Use o SDK OpenAI quando quiser a superfície completa da API OpenAI, a melhor latência e máxima compatibilidade com os clientes OpenAI existentes. Este endpoint expõe diretamente a API Responses no Azure OpenAI e fornece acesso a modelos OpenAI do Azure e vendidos pelo Azure, incluindo embeddings, completões de chat e geração de imagens. Não oferece acesso a funcionalidades específicas da Foundry, como agentes, avaliações ou ferramentas de plataforma exclusivas da Foundry. Para essas funcionalidades, use a API Respostas no endpoint do seu projeto através do Foundry SDK.
Dica
Utilize o endpoint do OpenAI SDK para gerar embeddings. O endpoint do projeto usado pelo SDK do Foundry não encaminha atualmente os pedidos de embedding.
O excerto seguinte mostra como usar diretamente o endpoint Azure OpenAI /openai/v1.
from azure.identity import DefaultAzureCredential, get_bearer_token_provider
from openai import OpenAI
token_provider = get_bearer_token_provider(
DefaultAzureCredential(), "https://ai.azure.com/.default"
)
openai_endpoint = "https://<resource-name>.openai.azure.com/openai/v1/"
openai = OpenAI(
base_url=openai_endpoint,
api_key=token_provider,
)
response = openai.responses.create(
model="gpt-5-mini",
input="What is the size of France in square miles?",
)
print(f"Response output: {response.output_text}")
Response output: <model response>
Referência: Linguagens de programação suportadas pelo Azure OpenAI
O excerto seguinte mostra como usar diretamente o endpoint Azure OpenAI /openai/v1.
import com.azure.identity.AuthenticationUtil;
import com.azure.identity.DefaultAzureCredentialBuilder;
import com.openai.client.OpenAIClient;
import com.openai.client.okhttp.OpenAIOkHttpClient;
import com.openai.credential.BearerTokenCredential;
import com.openai.models.responses.Response;
import com.openai.models.responses.ResponseCreateParams;
String openAIEndpoint = "https://<resource-name>.openai.azure.com/openai/v1";
OpenAIClient openAIClient = OpenAIOkHttpClient.builder()
.baseUrl(openAIEndpoint)
.credential(BearerTokenCredential.create(
AuthenticationUtil.getBearerTokenSupplier(
new DefaultAzureCredentialBuilder().build(),
"https://ai.azure.com/.default")))
.build();
Response response = openAIClient.responses().create(
ResponseCreateParams.builder()
.model("gpt-5-mini")
.input("What is the size of France in square miles?")
.build());
response.output().forEach(item -> item.message().ifPresent(message ->
message.content().forEach(content -> content.outputText().ifPresent(text ->
System.out.println("Response output: " + text.text())))));
Response output: <model response>
Referência: Linguagens de programação suportadas pelo Azure OpenAI
import {
DefaultAzureCredential,
getBearerTokenProvider,
} from "@azure/identity";
import OpenAI from "openai";
const openAIEndpoint = "https://<resource-name>.openai.azure.com/openai/v1";
const tokenProvider = getBearerTokenProvider(
new DefaultAzureCredential(),
"https://ai.azure.com/.default",
);
const openai = new OpenAI({ baseURL: openAIEndpoint, apiKey: tokenProvider });
const response = await openai.responses.create({
model: "gpt-5-mini",
input: "What is the size of France in square miles?",
});
console.log(`Response output: ${response.output_text}`);
Response output: <model response>
Referência: Linguagens de programação suportadas pelo Azure OpenAI
Execute este comando para adicionar a biblioteca cliente OpenAI ao seu projeto .NET.
dotnet add package OpenAI
Quando tem sucesso, a CLI .NET confirma que instalou o OpenAI pacote.
Este snippet configura DefaultAzureCredential, constrói OpenAIClientOptions, e cria um ResponsesClient para o endpoint Azure OpenAI v1.
using Azure.Identity;
using OpenAI;
using OpenAI.Responses;
using System.ClientModel.Primitives;
#pragma warning disable OPENAI001
const string openAIEndpoint =
"https://<resource-name>.openai.azure.com/openai/v1/";
BearerTokenPolicy tokenPolicy = new(
new DefaultAzureCredential(),
"https://ai.azure.com/.default");
OpenAIClient openAIClient = new(
authenticationPolicy: tokenPolicy,
options: new OpenAIClientOptions()
{
Endpoint = new(openAIEndpoint),
});
ResponsesClient responsesClient = openAIClient.GetResponsesClient();
CreateResponseOptions options = new()
{
Model = "gpt-5-mini",
InputItems =
{
ResponseItem.CreateUserMessageItem(
"What is the size of France in square miles?")
},
};
var response = responsesClient.CreateResponse(options);
Console.WriteLine($"Response output: {response.Value.GetOutputText()}");
#pragma warning restore OPENAI001
Response output: <model response>
Referência: Linguagens de programação suportadas pelo Azure OpenAI
Kit de Desenvolvimento de Software Anthropic
Use o SDK Anthropic para trabalhar com modelos Anthropic Claude implementados no Foundry. Os modelos Claude usam um endpoint separado /anthropic e a API Anthropic Messages, não o endpoint compatível com OpenAI.
O endpoint Anthropic acrescenta /anthropic à URL do seu recurso:
https://<resource-name>.services.ai.azure.com/anthropic
A API de Mensagens está disponível em:
https://<resource-name>.services.ai.azure.com/anthropic/v1/messages
from anthropic import AnthropicFoundry
from azure.identity import DefaultAzureCredential, get_bearer_token_provider
token_provider = get_bearer_token_provider(
DefaultAzureCredential(), "https://ai.azure.com/.default"
)
client = AnthropicFoundry(
azure_ad_token_provider=token_provider,
base_url="https://<resource-name>.services.ai.azure.com/anthropic",
)
message = client.messages.create(
model="claude-sonnet-4-6", # Replace with your deployment name
messages=[
{"role": "user", "content": "What are 3 things to visit in Seattle?"}
],
max_tokens=1048,
)
print(f"Response output: {message.content[0].text}")
Response output: <model response>
O Anthropic SDK não fornece um cliente nativo em C#. Utilize a API REST com HttpClient para invocar os modelos Claude.
using System.Net.Http.Headers;
using System.Text;
using System.Text.Json;
using Azure.Identity;
string endpoint =
"https://<resource-name>.services.ai.azure.com/anthropic/v1/messages";
var credential = new DefaultAzureCredential();
var token = await credential.GetTokenAsync(
new Azure.Core.TokenRequestContext(["https://ai.azure.com/.default"]));
using var httpClient = new HttpClient();
httpClient.DefaultRequestHeaders.Authorization =
new AuthenticationHeaderValue("Bearer", token.Token);
httpClient.DefaultRequestHeaders.Add("anthropic-version", "2023-06-01");
var requestBody = new
{
model = "claude-sonnet-4-6",
messages = new[]
{
new { role = "user", content = "Name three Seattle attractions." }
},
max_tokens = 1048
};
var response = await httpClient.PostAsync(
endpoint,
new StringContent(
JsonSerializer.Serialize(requestBody), Encoding.UTF8,
"application/json"));
string result = await response.Content.ReadAsStringAsync();
Console.WriteLine(result);
<JSON response body containing the model response>
import AnthropicFoundry from "@anthropic-ai/foundry-sdk";
import {
DefaultAzureCredential,
getBearerTokenProvider,
} from "@azure/identity";
const tokenProvider = getBearerTokenProvider(
new DefaultAzureCredential(),
"https://ai.azure.com/.default",
);
const client = new AnthropicFoundry({
azureADTokenProvider: tokenProvider,
baseURL: "https://<resource-name>.services.ai.azure.com/anthropic",
apiVersion: "2023-06-01",
});
const message = await client.messages.create({
model: "claude-sonnet-4-6", // Replace with your deployment name
messages: [
{ role: "user", content: "What are 3 things to visit in Seattle?" },
],
max_tokens: 1048,
});
console.log(`Response output: ${message.content[0].text}`);
Response output: <model response>
O Anthropic SDK não fornece um cliente Java nativo. Utilize a API REST com HttpClient para invocar os modelos Claude.
import com.azure.identity.DefaultAzureCredentialBuilder;
import com.azure.core.credential.TokenRequestContext;
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
String endpoint =
"https://<resource-name>.services.ai.azure.com/anthropic/v1/messages";
var credential = new DefaultAzureCredentialBuilder().build();
var token = credential.getToken(new TokenRequestContext()
.addScopes("https://ai.azure.com/.default")).block();
String requestBody = """
{"model": "claude-sonnet-4-6",
"messages": [{"role": "user",
"content": "What are 3 things to visit in Seattle?"}],
"max_tokens": 1048}
""";
HttpClient httpClient = HttpClient.newHttpClient();
HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create(endpoint))
.header("Authorization", "Bearer " + token.getToken())
.header("Content-Type", "application/json")
.header("anthropic-version", "2023-06-01")
.POST(HttpRequest.BodyPublishers.ofString(requestBody))
.build();
HttpResponse<String> response = httpClient.send(
request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
<JSON response body containing the model response>
Para mais informações, consulte Utilizar modelos Anthropic Claude no Microsoft Foundry.
Estrutura do agente
O Microsoft Agent Framework é um SDK open-source para C#/.NET e Python que fornece orquestração multi-agente unificada e abstrações consistentes para construir agentes e sistemas multi-agente. É a camada de orquestração recomendada para agentes hospedados no Foundry.
- Se anteriormente usou AutoGen ou Kernel Semântico para orquestração multi-agente (coordenando múltiplos agentes para trabalharem juntos em tarefas), considere o Agent Framework como a sua camada principal de orquestração. Ajuda a evitar combinar múltiplos SDKs de orquestração que resolvem tarefas de coordenação semelhantes, o que pode adicionar abstrações e dependências conflitantes.
- Se já tem um código de orquestração substancial, depende de funcionalidades específicas do produto ou enfrenta requisitos complexos de migração, avalie esses requisitos antes de consolidar no Agent Framework.
Executa o teu código como um agente alojado
A principal história dos agentes baseados em código no Foundry é os agentes alojados. Escreva o seu agente com o Agent Framework, empacote-o como uma imagem de contentor ou um ficheiro ZIP do seu código-fonte e deixe o Foundry executá-lo através de um ponto final gerido, com dimensionamento automático em Micro VMs isoladas, uma identidade de agente dedicada do Microsoft Entra, estado ao nível da sessão e observabilidade de ponta a ponta.
Os agentes alojados são o caminho recomendado quando se quer um endpoint gerido pela Foundry, endereçável na rede, que outras aplicações ou agentes possam acedir. Veja : Implementar o seu primeiro agente alojado.
Construir agentes em código fora do Foundry com a API Responses
Se estiver a hospedar o seu agente fora do Foundry — no seu próprio processo ou infraestrutura — pode também usar o Agent Framework para chamar diretamente a API Responses no endpoint do seu projeto . O Agent Framework liga-se através do FoundryChatClient fornecedor, que tem como alvo:
{project_endpoint}/openai/v1/responses
Passar pelo endpoint do projeto — em vez de um endpoint OpenAI ao nível de recursos — dá ao seu agente:
- Modelos Foundry do catálogo (Azure OpenAI e modelos diretos do Foundry) por meio de uma API.
- Ferramentas de plataforma para além do conjunto de ferramentas OpenAI, incluindo pesquisa de ficheiros, interpretador de código, memória, pesquisa web, servidores MCP, SharePoint, WorkIQ e Fabric IQ.
- Dados no âmbito do projeto, autenticação da ferramenta On-Behalf-Of (OBO) e o rastreamento, os filtros de conteúdo e a configuração de identidade do projeto.
Este padrão complementa os agentes alojados, não é uma alternativa — o mesmo código do Agent Framework pode chamar a Responses API no seu próprio processo hoje e ser empacotado mais tarde como um agente alojado, quando pretender um endpoint gerido pela Foundry. Veja Quickstart: Construir agentes usando a API Responses.
Para uma comparação completa dos tipos de agentes e opções de alojamento, veja O que é Microsoft Foundry Agent Service?.
SDKs de Ferramentas de Fundição
As Foundry Tools (anteriormente Azure AI Services) são soluções pontuais pré-construídas com SDKs dedicados. Utilize os seguintes endpoints para trabalhar com o Foundry Tools.
Qual endpoint deve usar?
Escolha um endpoint com base nas suas necessidades:
Use o endpoint Azure AI Services para aceder às ferramentas de Imagem Digitalizada, Content Security, Document Intelligence, Language, Translation e Token Foundry.
Endpoint Foundry Tools: https://<your-resource-name>.cognitiveservices.azure.com/
Nota
Os endpoints usam ou o nome do seu recurso ou um subdomínio personalizado. Se a sua organização configurou um subdomínio personalizado, substitua your-resource-name por your-custom-subdomain em todos os exemplos de endpoint.
Se as suas cargas de trabalho utilizarem funcionalidades do Linguagem da IA do Azure que estão a ser retiradas — por exemplo, análise de sentimento, extração de frases-chave, sumarização, ligação de entidades, CLU, ou CQA — planeie migrar para alternativas ao Microsoft Foundry. Para novos desenvolvimentos, considere usar o SDK Foundry ou o endpoint compatível com OpenAI, conforme descrito anteriormente neste artigo. Veja Migrar do Language Studio para Microsoft Foundry.
Para as Ferramentas Speech e Translation Foundry, utilize os endpoints nas tabelas seguintes. Substitua os marcadores de lugar pela informação dos seus recursos.
Pontos finais da fala
| Ferramenta de Fundição | Ponto final |
|---|---|
| Voz para Texto (Padrão) | https://<YOUR-RESOURCE-REGION>.stt.speech.microsoft.com |
| Texto para Fala (Neural) | https://<YOUR-RESOURCE-REGION>.tts.speech.microsoft.com |
| Voz Personalizada | https://<YOUR-RESOURCE-NAME>.cognitiveservices.azure.com/ |
Pontos finais de tradução
| Ferramenta de Fundição | Ponto final |
|---|---|
| Tradução de Texto | https://api.cognitive.microsofttranslator.com/ |
| Tradução de Documentos | https://<YOUR-RESOURCE-NAME>.cognitiveservices.azure.com/ |
Endpoints da Linguagem
| Ferramenta de Fundição | Ponto final |
|---|---|
| Análise de texto | https://<YOUR-RESOURCE-NAME>.cognitiveservices.azure.com |
Importante
A 20 de março de 2027, o Azure Language Studio será retirado e migrado para o Microsoft Foundry; todas as funcionalidades e futuras melhorias estarão disponíveis no Microsoft Foundry.
A 31 de março de 2029, as seguintes funcionalidades do Azure Language serão retiradas (fim do suporte). Antes dessa data, os utilizadores devem migrar cargas de trabalho existentes e integrar novos projetos para modelos Microsoft Foundry para melhorar a compreensão da linguagem natural e simplificar a integração de aplicações:
- Extração de Expressões-Chave
- Análise de Sentimento e Mineração de Opinião
- Classificação de Texto Personalizada
- Compreensão de Linguagem Conversacional (CLU)
- Resposta personalizada a perguntas (CQA)
- Fluxo de Trabalho de Orquestração
- Sumarização (extrativa e abstrativa, para documentos e conversas)
- Ligação de Entidades
Funcionalidades principais com suporte contínuo: Deteção de Linguagem, Deteção de PII, Análise de Texto for Health, NER pré-construído e NER personalizado.
Para opções de migração, veja Migrar do Language Studio para Microsoft Foundry.