Observação
O acesso a essa página exige autorização. Você pode tentar entrar ou alterar diretórios.
O acesso a essa página exige autorização. Você pode tentar alterar os diretórios.
Exibição no momento:Versão do portal do Foundry - Alternar para a versão do novo portal do Foundry
Um recurso do Foundry fornece acesso unificado a modelos, agentes e ferramentas. Este artigo explica qual SDK e endpoint utilizar para seu cenário.
O Foundry SDK é um SDK thin client que expõe todas as APIs do projeto Foundry por meio de um único endpoint de projeto. SDKs de nível superior baseiam-se nele – por exemplo, o pacote do Agent Framework foundry depende do SDK do Foundry para acessar modelos, ferramentas e configuração de projeto do Foundry.
| SDK | Para que serve | Ponto de Extremidade |
|---|---|---|
| Foundry SDK | SDK de cliente leve para todas as APIs de projetos do Foundry. Acesso aos Modelos de Fundação e ferramentas de plataforma (pesquisa de arquivos, interpretador de código, pesquisa na Web, memória, SharePoint, WorkIQ, Fabric IQ, MCP). | https://<resource-name>.services.ai.azure.com/api/projects/<project-name> |
| Estrutura do Agente | Agentes hospedados e sistemas multiagente desenvolvidos com código. O foundry pacote depende do SDK do Foundry para acesso ao projeto. Execute em seu próprio processo. |
API de respostas no ponto de extremidade do projeto, via FoundryChatClient. |
| OpenAI SDK | Superfície de API OpenAI completa, incluindo inserções. Melhor latência e compatibilidade máxima do OpenAI. | https://<resource-name>.openai.azure.com/openai/v1 |
| Anthropic SDK | Modelos Claude da Anthropic implementados na Foundry. | https://<resource-name>.services.ai.azure.com/anthropic |
| Ferramentas de Fundição SDKs | Soluções predefinidas (Visão, Fala, Segurança de Conteúdo e muito mais). | Pontos de extremidade específicos da ferramenta. |
Escolha seu SDK:
- Usar o SDK do Foundry ao criar aplicativos com agentes, avaliações ou recursos específicos do Foundry
- Usar o Agent Framework ao criar agentes hospedados ou sistemas de vários agentes no código usando a API de Respostas
- Use o SDK do OpenAI quando a compatibilidade máxima do OpenAI ou a menor latência for necessária, ao gerar inserções ou ao usar modelos diretos do Foundry por meio de Preenchimentos de Chat
- Use Anthropic SDK ao trabalhar com modelos Anthropic Claude implantados no Foundry
- Use SDKs das Ferramentas Foundry ao trabalhar com serviços específicos de IA (Visão, Fala, Linguagem etc.)
Nota
Tipos de recurso: Um recurso Foundry fornece todos os pontos de extremidade anteriormente listados. Um recurso do Azure OpenAI fornece apenas o endpoint /openai/v1.
Authentication: Exemplos aqui usam Microsoft Entra ID (DefaultAzureCredential). As chaves de API funcionam em /openai/v1. Passe a chave como api_key em vez de um provedor de token.
Pré-requisitos
-
Uma conta Azure com uma assinatura ativa. Se você não tiver uma, crie uma conta de Azure free, que inclui uma assinatura de avaliação gratuita.
Tenha uma das seguintes Azure funções RBAC para criar e gerenciar recursos do Foundry:
Usuário do Foundry (função de privilégio mínimo para desenvolvimento)
Importante
As funções RBAC do Foundry foram renomeadas recentemente. Foundry User, Foundry Owner, Foundry Account Owner e Foundry Project Manager eram anteriormente chamados de Usuário do Azure AI, Proprietário do Azure AI, Proprietário da conta do Azure AI e Gerente de Projeto do Azure AI. Você ainda pode ver os nomes anteriores em alguns lugares enquanto essa mudança de nome está sendo implementada. Os IDs das funções e as permissões principais não são alterados com a mudança de nome.
Foundry Project Manager (para gerenciar projetos do Foundry)
Colaborador ou Proprietário (para permissões no nível da assinatura)
Para obter detalhes sobre as permissões de cada função, consulte o controle de acesso baseado em Role para Microsoft Foundry.
Instale os runtimes de idioma necessários, as ferramentas globais e as extensões do VS Code, conforme descrito em Preparar seu ambiente de desenvolvimento.
Importante
Antes de começar, verifique se o ambiente de desenvolvimento está pronto.
Este artigo se concentra em etapas específicas do cenário , como instalação do SDK, autenticação e execução de código de exemplo.
Verificar pré-requisitos
Antes de prosseguir, confirme:
- Azure assinatura está ativa:
az account show - Você tem a função RBAC necessária: Verifique o portal do Azure → recurso Foundry → Controle de Acesso (IAM)
- Runtime de idioma instalado:
- Python:
python --version(≥3.8)
- Python:
- Runtime de idioma instalado:
- Node.js:
node --version(≥18)
- Node.js:
- Runtime de idioma instalado:
- .NET:
dotnet --version(≥6.0)
- .NET:
- Runtime de idioma instalado:
- Java:
java --version(≥11)
- Java:
Foundry SDK
O SDK do Foundry se conecta a um único endpoint de projeto que fornece acesso aos recursos mais populares do Foundry.
https://<resource-name>.services.ai.azure.com/api/projects/<project-name>
Nota
Se sua organização usar um subdomínio personalizado, substitua <resource-name><your-custom-subdomain> na URL do ponto de extremidade.
Essa abordagem simplifica a configuração do aplicativo. Em vez de gerenciar vários pontos de extremidade, você configura um.
Instalar o SDK
Nota
Este artigo se aplica a um projeto do Foundry. O código mostrado aqui não funciona para um projeto baseado em hub. Para obter mais informações, consulte Tipos de projetos.
Nota
Versões do SDK: Este artigo aborda a instalação do SDK 1.x. Verifique se os exemplos a seguir correspondem ao pacote instalado. Mude para a nova documentação do portal Foundry para visualizar o artigo da versão 2.x.
| Versão do SDK | Versão do Portal | Status | Pacote Python |
|---|---|---|---|
| 2.x | Fundição (novo) | Estável | azure-ai-projects>=2.0.0 |
| 1.x | Fundição (clássico) | Estável | azure-ai-projects==1.0.0 |
A biblioteca de clientes Azure AI Projects para Python é uma biblioteca unificada que permite que você use várias bibliotecas de cliente juntas conectando-se a um único ponto de extremidade de projeto.
Execute este comando para instalar os pacotes 1.x para projetos clássicos do Foundry.
pip install openai azure-identity azure-ai-projects==1.0.0
| Versão do SDK | Versão do Portal | Status | Pacote Java |
|---|---|---|---|
| 2.0.0 | Fundição (novo) | Estável | azure-ai-projectsazure-ai-agents |
| Versão do SDK | Versão do Portal | Status | Pacote JavaScript |
|---|---|---|---|
| 2.0.1 | Fundição (novo) | Estável | @azure/ai-projects |
| 1.0.1 | Clássico da fundição | Estável | @azure/ai-projects |
| Versão do SDK | Versão do Portal | Status | Pacote .NET |
|---|---|---|---|
| 2.0.0-beta.1 (versão prévia) | Fundição (novo) | Visualizar | Azure.AI.ProjectsAzure.AI.Projects.OpenAI |
| 1.1.0 (GA) | Clássico da fundição | Estável | Azure.AI.Projects |
A biblioteca de clientes Azure AI Projects para Java é uma biblioteca unificada que permite que você use várias bibliotecas de cliente juntas conectando-se a um único ponto de extremidade de projeto.
Importante
O pacote Java azure-ai-projects não tem uma versão de GA 1.x. Os exemplos de código nas seções Java usam o pacote azure-ai-inference diretamente, que está sendo preterido e será desativado em 30 de maio de 2026.
Para o SDK de Projetos 2.x, consulte a nova documentação do portal do Foundry.
Adicione essas dependências ao seu Maven pom.xml para projetos clássicos do Foundry.
<dependency>
<groupId>com.azure</groupId>
<artifactId>azure-ai-inference</artifactId>
<version>1.0.0-beta.6</version>
</dependency>
<dependency>
<groupId>com.azure</groupId>
<artifactId>azure-identity</artifactId>
<version>1.18.2</version>
</dependency>
A biblioteca de clientes Azure AI Projects para JavaScript é uma biblioteca unificada que permite que você use várias bibliotecas de cliente juntas conectando-se a um único ponto de extremidade de projeto.
Execute este comando para instalar os pacotes JavaScript 1.x para projetos clássicos do Foundry.
npm install @azure/ai-projects@1.0.1 @azure/identity
A biblioteca de clientes Azure AI Projects para .NET é uma biblioteca unificada que permite que você use várias bibliotecas de clientes juntas conectando-se a um único ponto de extremidade de projeto.
Execute esses comandos para adicionar os pacotes 1.x Azure SDK de IA para projetos clássicos do Foundry.
# Add 1.x Azure AI SDK packages
dotnet add package Azure.Identity
dotnet add package Azure.AI.Projects --version 1.1.0
dotnet add package Azure.AI.Agents.Persistent --version 1.1.0
dotnet add package Azure.AI.Inference
Usando o SDK do Foundry
O SDK expõe dois tipos de cliente porque o Foundry e o OpenAI têm formas de API diferentes:
- Project client – Use para operações nativas do Foundry em que o OpenAI não tem equivalente. Exemplos: listar conexões, recuperar propriedades do projeto, habilitar o rastreamento.
-
Cliente compatível com OpenAI – Use a funcionalidade Foundry que se baseia em conceitos OpenAI. A API de Respostas, agentes, avaliações e ajuste fino usam padrões de solicitação/resposta no estilo OpenAI. Esse cliente também fornece acesso aos modelos diretos do Foundry (modelos nãoAzure-OpenAI hospedados na Foundry). O endpoint do projeto direciona esse tráfego na rota
/openai.
A maioria dos aplicativos usa os dois clientes. Use o cliente do projeto para configuração e configuração e use o cliente compatível com OpenAI para executar agentes, avaliações e modelos de chamada (incluindo modelos diretos do Foundry).
Criar um cliente de projeto:
from azure.ai.projects import AIProjectClient
from azure.identity import DefaultAzureCredential
project_client = AIProjectClient(
endpoint="https://<resource-name>.services.ai.azure.com/api/projects/<project-name>",
credential=DefaultAzureCredential(),
)
Crie um cliente compatível com OpenAI do seu projeto:
models = project_client.get_openai_client(api_version="2024-10-21")
chat_responses = models.chat.completions.create(
model="gpt-4o",
messages=[
{"role": "system", "content": "You are a helpful assistant"},
{"role": "user", "content": "What is the size of France in square miles?"},
],
)
print(chat_responses.choices[0].message.content)
Criar um cliente de projeto:
package com.azure.ai.foundry.samples;
import com.azure.ai.inference.ChatCompletionsClient;
import com.azure.ai.inference.ChatCompletionsClientBuilder;
import com.azure.ai.inference.models.ChatCompletions;
import com.azure.core.credential.AzureKeyCredential;
import com.azure.core.credential.TokenCredential;
import com.azure.core.exception.HttpResponseException;
import com.azure.core.util.logging.ClientLogger;
import com.azure.identity.DefaultAzureCredentialBuilder;
String prompt = "What best practices should I follow when asking an AI model to review Java code?";
String endpoint = "https://<resource-name>.services.ai.azure.com/api/projects/<project-name>";
TokenCredential credential = new DefaultAzureCredentialBuilder().build();
ChatCompletionsClient client = new ChatCompletionsClientBuilder()
.credential(credential)
.endpoint(endpoint)
.buildClient();
```**Create and use an OpenAI-compatible client from your project:**
```java
ChatCompletions completions = client.complete(prompt);
String content = completions.getChoice().getMessage().getContent();
System.out.println("\nResponse from AI assistant:\n" + content);
Criar um cliente de projeto:
const endpoint = "https://<resource-name>.services.ai.azure.com/api/projects/<project-name>";
const deployment = "gpt-4o";
const project = new AIProjectClient(endpoint, new DefaultAzureCredential());
Crie um cliente compatível com OpenAI do seu projeto:
const client = await project.getAzureOpenAIClient({
// The API version should match the version of the Azure OpenAI resource
apiVersion: "2024-12-01-preview"
});
const chatCompletion = await client.chat.completions.create({
model: deployment,
messages: [
{ role: "system", content: "You are a helpful assistant" },
{ role: "user", content: "What is the speed of light?" },
],
});
console.log(chatCompletion.choices[0].message.content);
Criar um cliente de projeto:
using System.ClientModel.Primitives;
using Azure.AI.OpenAI;
using Azure.AI.Projects;
using Azure.Identity;
using OpenAI.Chat;
string endpoint = "https://<resource-name>.services.ai.azure.com/api/projects/<project-name>";
AIProjectClient projectClient = new AIProjectClient(new Uri(endpoint), new DefaultAzureCredential());
Crie um cliente compatível com OpenAI do seu projeto:
ClientConnection connection = projectClient.GetConnection(typeof(AzureOpenAIClient).FullName!);
if (!connection.TryGetLocatorAsUri(out Uri uri) || uri is null)
{
throw new InvalidOperationException("Invalid URI.");
}
uri = new Uri($"https://{uri.Host}");
const string modelDeploymentName = "gpt-4o";
AzureOpenAIClient azureOpenAIClient = new AzureOpenAIClient(uri, new DefaultAzureCredential());
ChatClient chatClient = azureOpenAIClient.GetChatClient(deploymentName: modelDeploymentName);
Console.WriteLine("Complete a chat");
ChatCompletion result = chatClient.CompleteChat("List all the rainbow colors");
Console.WriteLine(result.Content[0].Text);
O que você pode fazer com o SDK do Foundry
- Access Foundry Models, incluindo Azure OpenAI
- Usar o Serviço do Foundry Agent
- Executar avaliações de nuvem
- Habilitar o rastreamento de aplicativo
- Ajustar um modelo
- Obtenha endpoints e chaves para Ferramentas Foundry, orquestração local e muito mais
Solucionando problemas
Erros de autenticação
Se você vir DefaultAzureCredential failed to retrieve a token:
Verify CLI do Azure é autenticado:
az account show az login # if not logged inVerifique a atribuição de função RBAC:
Confirme se você tem pelo menos a função de Usuário do Foundry no projeto Foundry
Importante
As funções RBAC do Foundry foram renomeadas recentemente. Foundry User, Foundry Owner, Foundry Account Owner e Foundry Project Manager eram anteriormente chamados de Usuário do Azure AI, Proprietário do Azure AI, Proprietário da conta do Azure AI e Gerente de Projeto do Azure AI. Você ainda pode ver os nomes anteriores em alguns lugares enquanto essa mudança de nome está sendo implementada. Os IDs das funções e as permissões principais não são alterados com a mudança de nome.
Consulte Atribuir funções do Azure
Para identidade gerenciada em produção:
- Verifique se a identidade gerenciada tem a função apropriada atribuída
- Consulte Configurar identidades gerenciadas
Erros de configuração de ponto de extremidade
Se você vir Connection refused ou 404 Not Found:
- Verificar se os nomes de recursos e projetos correspondem à sua implantação real
-
Verificar o formato da URL do ponto de extremidade: Deve ser
https://<resource-name>.services.ai.azure.com/api/projects/<project-name> -
Para subdomínios personalizados: substitua
<resource-name>pelo subdomínio personalizado
Incompatibilidades de versão 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 sinalizadores de versão corretos: consulte os comandos de instalação em cada seção de idioma acima
SDK de OpenAI
Use o SDK do OpenAI quando quiser a integração completa com a API do OpenAI e compatibilidade máxima com o cliente. Esse ponto de extremidade fornece acesso a modelos Azure OpenAI e modelos diretos do Foundry (por meio da API de Conclusões de Conversa). Ele não fornece acesso a recursos específicos do Foundry, como agentes e avaliações.
O seguinte trecho mostra como usar o endpoint Azure OpenAI /openai/v1 diretamente.
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))
Para obter mais informações, consulte linguagens de programação com suporte do Azure OpenAI. Saída 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 linguagens de programação com suporte do Azure OpenAI
Importante
Itens marcados (versão prévia) neste artigo estão atualmente em versão prévia pública. Essa versão prévia é fornecida sem um contrato de nível de serviço e não recomendamos isso para cargas de trabalho de produção. Alguns recursos podem não ter suporte ou ter recursos restritos. Para obter mais informações, consulte Supplemental Terms of Use for Microsoft Azure Previews.
O seguinte trecho mostra como usar o endpoint Azure OpenAI /openai/v1 diretamente.
import com.azure.ai.openai.OpenAIClient;
import com.azure.ai.openai.OpenAIClientBuilder;
import com.azure.ai.openai.models.ChatChoice;
import com.azure.ai.openai.models.ChatCompletions;
import com.azure.ai.openai.models.ChatCompletionsOptions;
import com.azure.ai.openai.models.ChatRequestAssistantMessage;
import com.azure.ai.openai.models.ChatRequestMessage;
import com.azure.ai.openai.models.ChatRequestSystemMessage;
import com.azure.ai.openai.models.ChatRequestUserMessage;
import com.azure.ai.openai.models.ChatResponseMessage;
import com.azure.core.credential.AzureKeyCredential;
import com.azure.core.util.Configuration;
import java.util.ArrayList;
import java.util.List;
String endpoint = "https://<resource-name>.openai.azure.com/openai/v1";
String deploymentName = "gpt-5.2";
TokenCredential defaultCredential = new DefaultAzureCredentialBuilder().build();
OpenAIClient client = new OpenAIClientBuilder()
.credential(defaultCredential)
.endpoint("{endpoint}")
.buildClient();
List<ChatRequestMessage> chatMessages = new ArrayList<>();
chatMessages.add(new ChatRequestSystemMessage("You are a helpful assistant."));
chatMessages.add(new ChatRequestUserMessage("What is the speed of light?"));
ChatCompletions chatCompletions = client.getChatCompletions(deploymentName, new ChatCompletionsOptions(chatMessages));
System.out.printf("Model ID=%s is created at %s.%n", chatCompletions.getId(), chatCompletions.getCreatedAt());
for (ChatChoice choice : chatCompletions.getChoices()) {
ChatResponseMessage message = choice.getMessage();
System.out.printf("Index: %d, Chat Role: %s.%n", choice.getIndex(), message.getRole());
System.out.println("Message:");
System.out.println(message.getContent());
Para obter mais informações sobre como usar o SDK do OpenAI, consulte Azure linguagens de programação com suporte do OpenAI.
import { AzureOpenAI } from "openai";
import { DefaultAzureCredential, getBearerTokenProvider } from "@azure/identity";
const deployment = "gpt-4o";
const endpoint = "https://<resource-name>.openai.azure.com";
const scope = "https://ai.azure.com/.default";
const apiVersion = "2024-04-01-preview";
const azureADTokenProvider = getBearerTokenProvider(new DefaultAzureCredential(), scope);
const options = { azureADTokenProvider, deployment, apiVersion, endpoint };
const client = new AzureOpenAI(options);
const result = await client.chat.completions.create({
model: deployment,
messages: [
{ role: "system", content: "You are a helpful assistant" },
{ role: "user", content: "What is the speed of light?" },
],
});
console.log(result.choices[0].message.content);
Para obter mais informações sobre como usar o SDK do OpenAI, consulte Azure linguagens de programação com suporte do OpenAI.
- Instale o pacote OpenAI: execute este comando para adicionar a biblioteca de clientes OpenAI ao seu projeto de .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 `ChatClient` for the Azure OpenAI v1 endpoint. ```csharp using System.ClientModel.Primitives; using Azure.Identity; using OpenAI; using OpenAI.Chat; #pragma warning disable OPENAI001 const string directModelEndpoint = "https://<resource-name>.openai.azure.com/openai/v1/"; const string modelDeploymentName = "gpt-5.2"; BearerTokenPolicy tokenPolicy = new( new DefaultAzureCredential(), "https://ai.azure.com/.default"); OpenAIClient openAIClient = new( authenticationPolicy: tokenPolicy, options: new OpenAIClientOptions() { Endpoint = new($"{directModelEndpoint}"), }); ChatClient chatClient = openAIClient.GetChatClient(modelDeploymentName); ChatCompletion completion = await chatClient.CompleteChatAsync( [ new SystemChatMessage("You are a helpful assistant."), new UserChatMessage("How many feet are in a mile?") ]); Console.WriteLine(completion.Content[0].Text); #pragma warning restore OPENAI001
Para obter mais informações sobre como usar o SDK do OpenAI, consulte Azure linguagens de programação com suporte do OpenAI.
Estrutura do Agente
Microsoft Agent Framework é um SDK de software livre (Python e .NET) para compilar agentes e sistemas de vários agentes no código. É o caminho recomendado para agentes Hosted (versão prévia) no Microsoft Foundry.
Executar seu código como um agente hospedado
A história principal para agentes baseados em código na Foundry é Agentes hospedados (versão prévia). Escreva seu agente com o Agent Framework, empacote-o como uma imagem de contêiner ou zip do código-fonte e deixe o Foundry executá-lo com um ponto de extremidade gerenciado, dimensionamento automático em Micro VMs isoladas, uma identidade de agente Microsoft Entra dedicada, estado de nível de sessão e observabilidade de ponta a ponta.
Os agentes hospedados são a opção recomendada quando você deseja um endpoint gerenciado pelo Foundry, acessível pela rede, que pode ser chamado por outros aplicativos ou agentes. Consulte Implantar seu primeiro agente hospedado.
Criar agentes em código fora do Foundry com a API de Respostas
Se você hospedar seu agente fora do Foundry — no seu próprio processo ou na sua própria infraestrutura — também poderá usar o Agent Framework para chamar diretamente a API de Respostas no endpoint do seu projeto. O Agent Framework se conecta por meio do FoundryChatClient provedor, que tem como destino:
{project_endpoint}/openai/v1/responses
Usar o endpoint do projeto — em vez de um endpoint da OpenAI no nível do recurso — fornece ao seu agente:
- Modelos Foundry do catálogo (Azure OpenAI e modelos Foundry diretos) em uma única API.
- Ferramentas de plataforma além do conjunto de ferramentas da OpenAI, incluindo busca de arquivos, interpretador de código, memória, busca na Web, servidores MCP, SharePoint, WorkIQ e Fabric IQ.
- dados com escopo do projeto, autenticação de ferramenta On-Behalf-Of (OBO) e o rastreamento, os filtros de conteúdo e a configuração de identidade do projeto.
Esse padrão é complementar aos agentes hospedados, não uma alternativa — o mesmo código do Agent Framework pode chamar a API de Respostas a partir do seu próprio processo hoje e ser empacotado posteriormente como um agente hospedado, quando você quiser um ponto de extremidade gerenciado pelo Foundry. Confira o Início Rápido: Criar agentes usando a API de Respostas.
Para obter uma comparação completa dos tipos de agentes e das opções de hospedagem, consulte O que é o Microsoft Foundry Agent Service?.
SDKs de Ferramentas de Fundição
As Ferramentas Foundry (anteriormente Serviços de IA do Azure) são soluções pontuais predefinidas com SDKs dedicados. Use os endereços a seguir para trabalhar com as Ferramentas Foundry.
Qual ponto de extremidade você deve utilizar?
Escolha um ponto de extremidade com base em suas necessidades:
Use o ponto de extremidade dos serviços de IA do Azure para acessar Pesquisa Visual Computacional, Segurança de Conteúdo, Inteligência de Documento, Linguagem, Tradução e Ferramentas de Token Foundry.
Ponto de extremidade das Ferramentas de Fundição: https://<your-resource-name>.cognitiveservices.azure.com/
Nota
Os pontos de extremidade usam o nome do recurso ou um subdomínio personalizado. Se sua organização configurou um subdomínio personalizado, substitua your-resource-name por your-custom-subdomain em todos os exemplos de pontos de extremidade.
Se suas cargas de trabalho usarem recursos de Linguagem de IA do Azure em desativação — por exemplo, análise de sentimento, extração de frases-chave, resumo, vinculação de entidade, CLU ou CQA — planeje migrar para alternativas da Microsoft Foundry. Para um novo desenvolvimento, considere usar o SDK do Foundry ou o endpoint compatível com o OpenAI, como descrito anteriormente neste artigo. Consulte Migrar do Language Studio para o Microsoft Foundry.
Para as Ferramentas da Fábrica de Fala e Tradução, use os pontos de extremidade nas tabelas a seguir. Substitua marcadores de posição por as informações de recurso.
Pontos finais de fala
| Ferramenta de Fundição | Ponto de Extremidade |
|---|---|
| Conversão de Fala em 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 de extremidade de tradução
| Ferramenta de Fundição | Ponto de Extremidade |
|---|---|
| Tradução de texto | https://api.cognitive.microsofttranslator.com/ |
| Tradução de Documento | https://<YOUR-RESOURCE-NAME>.cognitiveservices.azure.com/ |
Pontos de extremidade de linguagem
| Ferramenta de Fundição | Ponto de Extremidade |
|---|---|
| Análise de texto | https://<YOUR-RESOURCE-NAME>.cognitiveservices.azure.com |
Importante
Em 20 de março de 2027, o Azure Language Studio será desativado e migrado para Microsoft Foundry; todos os recursos e aprimoramentos futuros estarão disponíveis no Microsoft Foundry.
Em 31 de março de 2029, os seguintes recursos do Azure Language serão desativados (fim do suporte). Antes dessa data, os usuários devem migrar cargas de trabalho existentes e integrar novos projetos para modelos Microsoft Foundry para melhor compreensão da linguagem natural e integração simplificada de aplicativos:
- Extração de Frases-chave
- Análise de Sentimento e Mineração de Opiniões
- Classificação de texto personalizado
- Compreensão da Linguagem Conversacional (CLU)
- Resposta a perguntas personalizadas (CQA)
- Fluxo de trabalho de orquestração
- Resumo (extrativo e abstrativo, para documentos e conversas)
- Relacionamento de Entidades
Principais recursos com suporte contínuo: Detecção de Idioma, Detecção de PII, Análise de Texto para Saúde, NER Predefinido e NER Personalizado.
Para obter opções de migração, consulte Migrate do Language Studio para Microsoft Foundry.