Kit de développement logiciel (SDK) Azure AI Foundry

pip install azure-ai-projects azure-identity

Créez un client de projet dans le code :

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

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

project_connection_string="your_connection_string"

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

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

Ajoutez des instructions à l'aide de :

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

Créez un client de projet dans le code :

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

Veillez à consulter la référenceet les exemples.

Veillez à consulter la référenceet les exemples.

pip install openai

Si vous avez du code existant qui utilise le Kit de développement logiciel (SDK) OpenAI, vous pouvez utiliser le client de projet pour créer un client AzureOpenAI qui utilise la connexion Azure OpenAI de votre projet :

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

Ajoutez des instructions à l'aide de :

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

Si vous avez du code existant qui utilise le Kit de développement logiciel (SDK) OpenAI, vous pouvez utiliser le client de projet pour créer un client AzureOpenAI qui utilise la connexion Azure OpenAI de votre projet :

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

pip install azure-ai-inference

Vous pouvez utiliser le client de projet pour obtenir un client de projet configuré et authentifié ChatCompletionsClient ou EmbeddingsClient :

# 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

Ajoutez des instructions à l'aide de :

using Azure.AI.Inference;

Vous pouvez utiliser le client de projet pour obtenir un client de projet configuré et authentifié ChatCompletionsClient ou EmbeddingsClient :

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

Modèles d’invite

Le client d’inférence prend en charge la création de messages d’invite à partir de modèles. Le modèle vous permet de générer dynamiquement des invites à l’aide d’entrées disponibles au moment de l’exécution.

Pour utiliser des modèles d’invite, installez le package azure-ai-inference :

pip install azure-ai-inference

Vous pouvez afficher un modèle d’invite à partir d’une chaîne inline :

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)

Ce code génère des messages que vous pouvez ensuite passer à un appel d’achèvement de conversation :

[
  {'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'}
]

Vous pouvez également charger des invites à partir d’un fichier Prompty, ce qui vous permet de charger également le nom du modèle et les paramètres à partir du fichier .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,
)

pip install azure-search-documents

Instanciez le client d’index de recherche et/ou de recherche comme vous le souhaitez :

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

Ajoutez des instructions à l'aide de :

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

Instanciez le client d’index de recherche et/ou de recherche comme vous le souhaitez :

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

Vous pouvez utiliser le client de projet pour vous connecter facilement au service d’évaluation Azure AI et les modèles nécessaires à l’exécution de vos évaluateurs.

pip install azure-ai-evaluation

À l’aide du paramètre project.scope, nous pouvons instancier un 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)

REMARQUE : pour exécuter des évaluateurs de violence, votre projet doit se trouver dans USA Est 2, Suède Centre, USA Centre Nord, France Centre.

Pour en savoir plus, consultez Évaluation à l’aide du Kit de développement logiciel (SDK).

Un package d’évaluation Azure AI n’est pas encore disponible pour C#. Pour un exemple sur la façon d'utiliser Prompty et Semantic Kernel pour l'évaluation, consultez l'exemple contoso-chat-csharp-prompty.

Pour activer le suivi, vérifiez d’abord que votre projet dispose d’une ressource Application Insights attachée. Accédez à la page Suivi de votre projet et suivez les instructions pour créer ou joindre Application Insights.

Installez le dernier package Azure Monitor OpenTelemetry :

pip install azure-monitor-opentelemetry

Utilisez le code suivant pour activer l’instrumentation du Kit de développement logiciel (SDK) d’inférence Azure AI et la journalisation dans votre projet 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)

Le traçage n'est pas encore intégré dans le package des projets. Pour obtenir des instructions sur la manière d’instrumenter et de consigner les traces à partir du package Azure AI Inferencing, consultez azure-sdk-for-dotnet.