Compartilhar via

O SDK Foundry da IA do Azure

  • Artigo

O SDK Foundry da IA do Azure é uma cadeia de ferramentas abrangente criada para simplificar o desenvolvimento de aplicativos de IA no Azure. Ele permite aos desenvolvedores:

  • Acessar modelos populares de vários provedores de modelos por meio de uma só interface
  • Combinar facilmente modelos, dados e serviços de IA para criar aplicativos da plataforma AI
  • Avaliar, depurar e aprimorar a qualidade e a segurança do aplicativo em ambientes de desenvolvimento, teste e produção

O SDK Foundry de IA é um conjunto de pacotes e serviços projetados para funcionar em conjunto. Você pode usar a biblioteca de clientes de Projetos de IA do Azure para usar com facilidade vários serviços por meio de um único cliente de projeto e cadeia de conexão. Você também pode usar serviços e SDKs de modo isolado e conectá-los diretamente aos seus serviços.

Para começar diretamente a criar um aplicativo, confira:

Introdução aos Projetos

A melhor maneira de começar a usar o SDK Foundry da IA do Azure é usando um projeto. Projetos de IA conectam diferentes dados, ativos e serviços necessários para criar aplicativos de IA. O cliente de projeto de IA permite que você acesse facilmente esses componentes do projeto de seu código usando uma só cadeia de conexão.

Primeiro, siga as etapas para criar um Projeto de IA se você ainda não tem um.

Entre com a CLI do Azure usando a mesma conta usada para acessar seu Projeto de IA:

az login

Instale a biblioteca de clientes de projetos de IA do Azure:

pip install azure-ai-projects azure-identity

Crie um cliente de projeto no código:

from azure.identity import DefaultAzureCredential
from azure.ai.projects import AIProjectClient

project_connection_string="your_connection_string"

project = AIProjectClient.from_connection_string(
  conn_str=project_connection_string,
  credential=DefaultAzureCredential())

dotnet add package Azure.AI.Projects
dotnet add package Azure.Identity

Adicionar instruções using:

using Azure.Identity;
using Azure.AI.Projects;

Crie um cliente de projeto no código:

var connectionString = "<your_connection_string>";
var projectClient = new AIProjectClient(connectionString, new DefaultAzureCredential());

Copie a Cadeia de conexão do projeto na página de Visão Geral do projeto e atualize o valor da cadeia de conexões acima.

Após criar o cliente do projeto, você pode usá-lo para os recursos nas seções a seguir.

Não deixe de conferir a referência e as amostras.

Não deixe de conferir a referência e as amostras.

Serviço OpenAI do Azure

O Serviço OpenAI do Azure fornece acesso aos modelos da OpenAI, como GPT-4o, GPT-4o mini, GPT-4, GPT-4 Turbo com as séries de modelos Vision, DALLE-3, Whisper e Embeddings com as funcionalidades corporativas, de residência de dados, de escalabilidade, de proteção e de segurança do Azure.

Se você tiver um código que usa o SDK do OpenAI, poderá instruir facilmente seu código a usar o Serviço OpenAI do Azure. Primeiro, instale o SDK do OpenAI:

pip install openai

Se você tem um código que usa o SDK do OpenAI, pode usar o cliente do projeto para criar um cliente AzureOpenAI que usa a conexão do OpenAI do Azure de seu projeto:

openai = project.inference.get_azure_openai_client(api_version="2024-06-01")
response = openai.chat.completions.create(
    model="gpt-4o",
    messages=[
        {"role": "system", "content": "You are a helpful writing assistant"},
        {"role": "user", "content": "Write me a poem about flowers"},
    ]
)

print(response.choices[0].message.content)

dotnet add package Azure.AI.OpenAI

Adicionar instruções using:

using OpenAI.Chat;
using Azure.AI.OpenAI;

Se você tem um código que usa o SDK do OpenAI, pode usar o cliente do projeto para criar um cliente AzureOpenAI que usa a conexão do OpenAI do Azure de seu projeto:

var connections = projectClient.GetConnectionsClient();
ConnectionResponse connection = connections.GetDefaultConnection(ConnectionType.AzureOpenAI, withCredential: true);
var properties = connection.Properties as ConnectionPropertiesApiKeyAuth;

if (properties == null) {
    throw new Exception("Invalid auth type, expected API key auth");
}

// Create and use an Azure OpenAI client
AzureOpenAIClient azureOpenAIClient = new(
    new Uri(properties.Target),
    new AzureKeyCredential(properties.Credentials.Key));

// This must match the custom deployment name you chose for your model
ChatClient chatClient = azureOpenAIClient.GetChatClient("gpt-4o-mini");

ChatCompletion completion = chatClient.CompleteChat(
    [
        new SystemChatMessage("You are a helpful assistant that talks like a pirate."),
        new UserChatMessage("Does Azure OpenAI support customer managed keys?"),
        new AssistantChatMessage("Yes, customer managed keys are supported by Azure OpenAI"),
        new UserChatMessage("Do other Azure AI services support this too?")
    ]);

Console.WriteLine($"{completion.Role}: {completion.Content[0].Text}");

Se você já estiver usando o SDK do OpenAI do Azure diretamente no Serviço OpenAI do Azure, o projeto fornecerá uma maneira conveniente de usar os recursos do Serviço OpenAI do Azure juntamente com o restante dos recursos de IA do Foundry.

Serviço de inferência de modelo de IA do Azure

O serviço de inferência de modelo de IA do Azure oferece acesso a modelos avançados de provedores líderes, como OpenAI, Microsoft, Meta e muito mais. Esses modelos dão suporte a tarefas como geração de conteúdo, sumarização e geração de código.

Para usar o serviço de inferência de modelo, primeiro verifique se o projeto tem uma conexão dos Serviços de IA (no centro de gerenciamento).

Instale a biblioteca azure-ai-inference cliente:

pip install azure-ai-inference

Você pode usar o cliente do projeto para obter um ChatCompletionsClient ou EmbeddingsClientconfigurado e autenticado:

# get an chat inferencing client using the project's default model inferencing endpoint
chat = project.inference.get_chat_completions_client()

# run a chat completion using the inferencing client
response = chat.complete(
    model="gpt-4o",
    messages=[
        {"role": "system", "content": "You are a helpful writing assistant"},
        {"role": "user", "content": "Write me a poem about flowers"},
    ]
)

print(response.choices[0].message.content)

dotnet add package Azure.AI.Inference

Adicionar instruções using:

using Azure.AI.Inference;

Você pode usar o cliente do projeto para obter um ChatCompletionsClient ou EmbeddingsClientconfigurado e autenticado:

var connectionString = Environment.GetEnvironmentVariable("AIPROJECT_CONNECTION_STRING");
var projectClient = new AIProjectClient(connectionString, new DefaultAzureCredential());

ChatCompletionsClient chatClient = projectClient.GetChatCompletionsClient();

var requestOptions = new ChatCompletionsOptions()
{
    Messages =
        {
            new ChatRequestSystemMessage("You are a helpful assistant."),
            new ChatRequestUserMessage("How many feet are in a mile?"),
        },
    Model = "gpt-4o-mini"
};

Response<ChatCompletions> response = chatClient.Complete(requestOptions);
Console.WriteLine(response.Value.Content);

Você pode alterar o nome do modelo para qualquer modelo implantado no serviço de inferência ou no Serviço OpenAI do Azure.

Para saber mais sobre como usar o cliente de inferência da IA do Azure, confira a Referência de inferência do modelo de IA do Azure.

Modelos de prompt

O cliente de inferência dá suporte à criação de mensagens de prompt de modelos. O modelo permite que você gere prompts dinamicamente usando entradas disponíveis em runtime.

Para usar modelos de prompt, instale o pacote azure-ai-inference:

pip install azure-ai-inference

Você pode renderizar um modelo de prompt de uma cadeia de caracteres embutida:

from azure.ai.inference.prompts import PromptTemplate

# create a prompt template from an inline string (using mustache syntax)
prompt_template = PromptTemplate.from_string(prompt_template="""
    system:
    You are a helpful writing assistant.
    The user's first name is {{first_name}} and their last name is {{last_name}}.

    user:
    Write me a poem about flowers
    """)

# generate system message from the template, passing in the context as variables
messages = prompt_template.create_messages(first_name="Jane", last_name="Doe")
print(messages)

Observação

O espaço em branco à esquerda é cortado automaticamente das cadeias de caracteres de entrada.

Esse código gera mensagens que você pode passar para uma chamada de conclusão de chat:

[
  {'role': 'system', 'content': "You are a helpful writing assistant.\nThe user's first name is Jane and their last name is Doe."}
  {'role': 'user', 'content': 'Write me a poem about flowers'}
]

Você também pode carregar prompts de um arquivo Prompty, permitindo que também carregue o nome e os parâmetros do modelo do arquivo .prompty:

from azure.ai.inference.prompts import PromptTemplate

prompt_template = PromptTemplate.from_prompty("myprompt.prompty")
messages = prompt_template.create_messages(first_name="Jane", last_name="Doe")

response = chat.complete(
    messages=messages,
    model=prompt_template.model_name,
    **prompt_template.parameters,
)

Se você tiver um recurso da Pesquisa de IA do Azure conectado ao seu projeto, também poderá usar o cliente do projeto para criar um cliente da Pesquisa de IA do Azure usando a conexão do projeto.

Instale a biblioteca de clientes da Pesquisa de IA do Azure:

pip install azure-search-documents

Crie uma instância do cliente de pesquisa e/ou do índice de pesquisa conforme desejado:

from azure.core.credentials import AzureKeyCredential
from azure.ai.projects.models import ConnectionType
from azure.search.documents import SearchClient
from azure.search.documents.indexes import SearchIndexClient

# use the project client to get the default search connection
search_connection = project.connections.get_default(
    connection_type=ConnectionType.AZURE_AI_SEARCH,
    with_credentials=True)

# Create a client to create and manage search indexes
index_client = SearchIndexClient(
    endpoint=search_connection.endpoint_url,
    credential=AzureKeyCredential(key=search_connection.key)
)

# Create a client to run search queries
search_client = SearchClient(
    index_name="your_index_name",
    endpoint=search_connection.endpoint_url,
    credential=AzureKeyCredential(key=search_connection.key)
)

dotnet add package Azure.Search.Documents

Adicionar instruções using:

using Azure.Search.Documents;
using Azure.Search.Documents.Models;

Crie uma instância do cliente de pesquisa e/ou do índice de pesquisa conforme desejado:

var connections = projectClient.GetConnectionsClient();
var connection = connections.GetDefaultConnection(ConnectionType.AzureAISearch, withCredential: true).Value;

var properties = connection.Properties as ConnectionPropertiesApiKeyAuth;
if (properties == null) {
    throw new Exception("Invalid auth type, expected API key auth");
}

SearchClient searchClient = new SearchClient(
    new Uri(properties.Target),
    "products",
    new AzureKeyCredential(properties.Credentials.Key));

Para saber mais sobre como usar a Pesquisa de IA do Azure, confira a documentação da Pesquisa de IA do Azure.

Serviço do Agente de IA do Azure

O Serviço de Agente da IA do Azure é um serviço totalmente gerenciado criado para capacitar os desenvolvedores a criar, implantar e dimensionar com segurança agentes de IA extensíveis e de alta qualidade. Usando um amplo ecossistema de modelos, ferramentas e funcionalidades do OpenAI, da Microsoft e de provedores terceirizados, o Serviço de Agente da IA do Azure permite a criação de agentes para uma ampla gama de casos de uso de IA generativa.

Para acessar os agentes, inscreva-se na versão prévia.

Avaliação

Você pode usar o cliente do projeto para se conectar facilmente ao serviço de avaliação da IA do Azure, e os modelos necessários para executar seus avaliadores.

pip install azure-ai-evaluation

Usando o parâmetro project.scope, podemos criar uma instância de um ViolenceEvaluator:

from azure.ai.evaluation import ViolenceEvaluator
from azure.identity import DefaultAzureCredential

# Initializing Violence Evaluator with project information
violence_eval = ViolenceEvaluator(
    azure_ai_project=project.scope,
    credential=DefaultAzureCredential())

# Running Violence Evaluator on single input row
violence_score = violence_eval(query="what's the capital of france", response="Paris")
print(violence_score)

NOTA: para executar avaliadores de violência, seu projeto precisa estar no Leste dos EUA 2, na Suécia Central, no Centro-Norte dos EUA ou na França Central.

Para saber mais, confira Avaliação usando o SDK.

O pacote de avaliação da IA do Azure ainda não está disponível para C#. Para conferir um exemplo de como usar o Prompty e o Semantic Kernel para avaliação, consulte a amostra contoso-chat-csharp-prompty.

Rastreamento

Para habilitar o rastreamento, verifique primeiro se o projeto tem um recurso do Application Insights anexado. Vá para a página Rastreamento do projeto e siga as instruções para criar ou anexar o Application Insights.

Instale o pacote OpenTelemetry do Azure Monitor:

pip install azure-monitor-opentelemetry

Use o seguinte código para habilitar a instrumentação do SDK de Inferência da IA do Azure e fazer logon em seu projeto de IA:

from azure.monitor.opentelemetry import configure_azure_monitor

# Enable instrumentation of AI packages (inference, agents, openai, langchain)
project.telemetry.enable()

# Log traces to the project's application insights resource
application_insights_connection_string = project.telemetry.get_connection_string()
if application_insights_connection_string:
    configure_azure_monitor(connection_string=application_insights_connection_string)

O rastreamento ainda não está integrado ao pacote de projetos. Para conferir instruções sobre como instrumentar e registrar rastreamentos no pacote de Inferência da Plataforma de IA do Azure, consulte azure-sdk-for-dotnet.

Conteúdo relacionado

Abaixo estão alguns links úteis para outros serviços e estruturas que você pode usar com o SDK Foundry da IA do Azure.

Serviços de IA do Azure

Bibliotecas de cliente:

Bibliotecas de gerenciamento:

Estruturas

Azure Machine Learning

Prompt flow

Semantic Kernel