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 | Agentes alojados e sistemas multiagente criados com código. O foundry pacote depende do SDK do Foundry para acesso ao projeto. Executa num processo próprio. |
API de respostas no endpoint do projeto, via FoundryChatClient. |
| OpenAI SDK | Superfície completa da API OpenAI, incluindo embeddings. 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
- Use o Agent Framework ao construir agentes alojados ou sistemas multi-agente em código usando a API Responses
- Utilize o SDK da OpenAI quando for necessária a máxima compatibilidade com a OpenAI ou a latência mais baixa, quando gerar embeddings ou quando utilizar modelos diretos do Foundry através de 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 um dos seguintes papéis Azure RBAC para criar e gerir recursos Foundry:
Utilizador do Foundry (função de privilégios mínimos para desenvolvimento)
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.
Foundry Project Manager (para gerir projetos Foundry)
Contribuidor ou Proprietário (para permissões a nível de subscrição)
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.
Importante
Antes de começar, certifique-se de que o seu ambiente de desenvolvimento está preparado.
Este artigo foca-se em passos específicos de cenários , como instalação do SDK, autenticação e execução de código de exemplo.
Verificar os pré-requisitos
Antes de prosseguir, confirme:
- A subscrição Azure está ativa:
az account show - Tem a função necessária do RBAC: Consulte o Portal do Azure → recurso Foundry → Controlo de Acesso (IAM)
- Runtime da linguagem instalado:
- Python:
python --version(≥3.8)
- Python:
- Runtime da linguagem instalado:
- Node.js:
node --version(≥18)
- Node.js:
- Runtime da linguagem instalado:
- .NET:
dotnet --version(≥6.0)
- .NET:
- Runtime da linguagem instalado:
- Java:
java --version(≥11)
- Java:
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
| 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.0.1 | Fundição (nova) | Estável | @azure/ai-projects |
| 1.0.1 | Clássico da fundição | Estável | @azure/ai-projects |
| 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.
Adicione estes pacotes à sua instalação para projetos da Foundry.
package com.azure.ai.agents;
import com.azure.core.util.Configuration;
import com.azure.identity.DefaultAzureCredentialBuilder;
import com.openai.models.responses.Response;
import com.openai.models.responses.ResponseCreateParams;
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 dotenv
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
Utilizando o SDK 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 tem como alvo a API de Responses no endpoint do seu projeto, que lhe dá acesso aos modelos Foundry do catálogo (incluindo modelos de acesso direto não-Azure-OpenAI), além de ferramentas da plataforma — ferramentas padrão da OpenAI, como pesquisa de ficheiros, interpretador de código e pesquisa na Web, juntamente com ferramentas exclusivas do Foundry, como 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 (incluindo modelos diretos do Foundry).
Crie um cliente de projeto:
from azure.identity import DefaultAzureCredential
from azure.ai.projects import AIProjectClient
project_client = AIProjectClient(
endpoint="https://<resource-name>.services.ai.azure.com/api/projects/<project-name>",
credential=DefaultAzureCredential())
Crie um cliente compatível com OpenAI a partir do seu projeto:
with project_client.get_openai_client() as openai_client:
response = openai_client.responses.create(
model="gpt-5.2",
input="What is the size of France in square miles?",
)
print(f"Response output: {response.output_text}")
Produção esperada:
Response output: France has an area of approximately 213,011 square miles (551,695 square kilometers).
Crie um cliente de projeto:
import com.azure.ai.projects.ProjectsClient;
import com.azure.ai.projects.ProjectsClientBuilder;
import com.azure.identity.DefaultAzureCredentialBuilder;
String endpoint = "https://<resource-name>.services.ai.azure.com/api/projects/<project-name>";
ProjectsClient projectClient = new ProjectsClientBuilder()
.credential(new DefaultAzureCredentialBuilder().build())
.endpoint(endpoint)
.buildClient();
```**Create and use an OpenAI-compatible client from your project:**
```java
OpenAIClient openAIClient = projectClient.getOpenAIClient();
Crie um cliente de projeto:
import { DefaultAzureCredential } from "@azure/identity";
import { AIProjectClient } from "@azure/ai-projects";
import "dotenv/config";
const projectEndpoint = "https://<resource-name>.services.ai.azure.com/api/projects/<project-name>";
const deploymentName = "gpt-5.2";
const project = new AIProjectClient(projectEndpoint, new DefaultAzureCredential());
Crie um cliente compatível com OpenAI a partir do seu projeto:
const openAIClient = await project.getOpenAIClient();
const response = await openAIClient.responses.create({
model: deploymentName,
input: "What is the size of France in square miles?",
});
console.log(`Response output: ${response.output_text}`);
Crie um cliente de projeto:
using Azure.AI.Projects;
using Azure.AI.Extensions.OpenAI;
using Azure.Identity;
string endpoint = "https://<resource-name>.services.ai.azure.com/api/projects/<project-name>";
AIProjectClient projectClient = new(
endpoint: new Uri(endpoint),
tokenProvider: new DefaultAzureCredential());
Crie um cliente compatível com OpenAI a partir do seu projeto:
var responseClient = projectClient.ProjectOpenAIClient.GetProjectResponsesClientForModel("gpt-5.2");
var response = responseClient.CreateResponse("What is the speed of light?");
Console.WriteLine(response.GetOutputText());
O que pode fazer com o SDK da 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 aos modelos do Azure OpenAI e aos modelos diretos do Foundry, incluindo embeddings, chat completions e geração de imagens. Não fornece acesso a funcionalidades específicas da Foundry, como agentes, avaliações ou ferramentas de plataforma exclusivas da Foundry — para isso, use a API Responses no endpoint do seu projeto através do SDK Foundry.
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 openai import OpenAI
from azure.identity import DefaultAzureCredential, get_bearer_token_provider
token_provider = get_bearer_token_provider(
DefaultAzureCredential(), "https://ai.azure.com/.default"
)
client = OpenAI(
base_url = "https://<resource-name>.openai.azure.com/openai/v1/",
api_key=token_provider,
)
response = client.responses.create(
model="model_deployment_name",
input= "What is the size of France in square miles?"
)
print(response.model_dump_json(indent=2))
Produção esperada:
{
"id": "resp_abc123",
"object": "response",
"created": 1234567890,
"model": "gpt-5.2",
"output_text": "France has an area of approximately 213,011 square miles (551,695 square kilometers)."
}
Para mais informações, consulte Azure Linguagens de programação suportadas pela OpenAI
O excerto seguinte mostra como usar diretamente o endpoint Azure OpenAI /openai/v1.
import com.azure.identity.AuthenticationUtil;
import com.azure.identity.DefaultAzureCredential;
import com.azure.identity.DefaultAzureCredentialBuilder;
import com.openai.client.OpenAIClient;
import com.openai.client.okhttp.OpenAIOkHttpClient;
import com.openai.credential.BearerTokenCredential;
import java.util.function.Supplier;
DefaultAzureCredential tokenCredential = new DefaultAzureCredentialBuilder().build();
String endpoint = "https://<resource-name>.openai.azure.com/openai/v1";
String deploymentName = "gpt-5.2";
Supplier<String> bearerTokenSupplier = AuthenticationUtil.getBearerTokenSupplier(
tokenCredential, "https://ai.azure.com/.default");
OpenAIClient openAIClient = OpenAIOkHttpClient.builder()
.baseUrl(endpoint)
.credential(BearerTokenCredential.create(bearerTokenSupplier))
.build();
ResponseCreateParams responseCreateParams = ResponseCreateParams.builder()
.input("What is the speed of light?")
.model(deploymentName)
.build();
Response response = openAIClient.responses().create(responseCreateParams);
System.out.println("Response output: " + response.getOutputText());
Para mais informações sobre a utilização do SDK OpenAI, consulte Azure Linguagens de programação suportadas pela OpenAI
const endpoint = "https://<resource-name>.openai.azure.com/openai/v1";
const scope = "https://ai.azure.com/.default";
const azureADTokenProvider = getBearerTokenProvider(new DefaultAzureCredential(), scope);
const client = new OpenAI({ baseURL: endpoint, apiKey: azureADTokenProvider });
const response = await client.responses.create({
model: deploymentName,
input: "What is the size of France in square miles?",
});
console.log(`Response output: ${response.output_text}`);
Para mais informações sobre a utilização do SDK OpenAI, consulte Azure Linguagens de programação suportadas pela OpenAI
- Instale o pacote OpenAI: Execute este comando para adicionar a biblioteca cliente OpenAI ao seu projeto .NET.
dotnet add package OpenAI ```When it succeeds, the .NET CLI confirms that it installed the `OpenAI` package. This snippet configures `DefaultAzureCredential`, builds `OpenAIClientOptions`, and creates a `ResponsesClient` for the Azure OpenAI v1 endpoint. ```csharp using Azure.Identity; using OpenAI; using OpenAI.Responses; using System.ClientModel.Primitives; #pragma warning disable OPENAI001 const string directModelEndpoint = "https://<resource-name>.openai.azure.com/openai/v1/"; const string deploymentName = "gpt-5.2"; BearerTokenPolicy tokenPolicy = new( new DefaultAzureCredential(), "https://ai.azure.com/.default"); OpenAIClient openAIClient = new( authenticationPolicy: tokenPolicy, options: new OpenAIClientOptions() { Endpoint = new($"{directModelEndpoint}"), }); ResponsesClient client = openAIClient.GetResponsesClient(); CreateResponseOptions options = new() { Model = deploymentName, InputItems = { ResponseItem.CreateUserMessageItem("What is the size of France in square miles?") }, Temperature = (float)0.7, }; var modelDirectResponse = client.CreateResponse(options); Console.WriteLine($"[ASSISTANT]: {modelDirectResponse.Value.GetOutputText()}"); #pragma warning restore OPENAI001
Para mais informações sobre a utilização do SDK OpenAI, consulte Azure Linguagens de programação suportadas pela 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(message.content)
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";
string deploymentName = "claude-sonnet-4-6"; // Replace with your deployment name
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 = deploymentName,
messages = new[] { new { role = "user", content = "What are 3 things to visit in Seattle?" } },
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);
import AnthropicFoundry from '@anthropic-ai/foundry-sdk';
import { getBearerTokenProvider, DefaultAzureCredential } 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(message);
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";
String deploymentName = "claude-sonnet-4-6"; // Replace with your deployment name
var credential = new DefaultAzureCredentialBuilder().build();
var token = credential.getToken(
new TokenRequestContext().addScopes("https://ai.azure.com/.default")).block();
String requestBody = """
{
"model": "%s",
"messages": [{"role": "user", "content": "What are 3 things to visit in Seattle?"}],
"max_tokens": 1048
}
""".formatted(deploymentName);
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());
Para mais informações, consulte Utilizar modelos Anthropic Claude no Microsoft Foundry.
Estrutura do agente
Microsoft Agent Framework é um SDK open-source (Python e .NET) para construir agentes e sistemas multiagente em código. É o caminho recomendado para Hosted agents (pré-visualização) no Microsoft Foundry.
Executa o teu código como um agente alojado
A principal história dos agentes baseados em código no Foundry é Hosted Agents (pré-visualização). 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.