Développer des applications avec LlamaIndex et Microsoft Foundry (classique)

S’applique uniquement au :Portail Foundry (classique). Cet article n’est pas disponible pour le nouveau portail Foundry. En savoir plus sur le nouveau portail.

Dans cet article, vous allez apprendre à utiliser LlamaIndex avec des modèles déployés à partir du catalogue de modèles dans Microsoft Foundry.

Vous pouvez utiliser des modèles déployés sur Microsoft Foundry avec LlamaIndex de deux façons :

• Utilisation de l’API spécifique du fournisseur du modèle : Certains modèles, comme OpenAI, Cohere ou Mistral, offrent leur propre ensemble d’API et d’extensions pour LlamaIndex. Ces extensions peuvent inclure des fonctionnalités spécifiques prises en charge par le modèle et sont donc adaptées si vous souhaitez les exploiter. Lorsque vous utilisez llama-index, installez l’extension spécifique au modèle que vous souhaitez utiliser, comme llama-index-llms-openai ou llama-index-llms-cohere.

• Utilisez l’API d’inférence de modèle IA Azure : Tous les modèles déployés sur Foundry prennent en charge l’API d’inférence Model, qui offre un ensemble commun de fonctionnalités que la plupart des modèles du catalogue peuvent utiliser. L’avantage de cette API est que, étant donné qu’il s’agit de la même chose pour tous les modèles, la modification de l’un à l’autre est aussi simple que la modification du déploiement du modèle en cours d’utilisation. Aucune autre modification n’est requise dans le code. Quand vous utilisez LlamaIndex, installez les extensions llama-index-llms-azure-inference et llama-index-embeddings-azure-inference.

Dans cet exemple, vous travaillez avec l’API d’inférence de modèle.

Conditions préalables

Pour exécuter ce tutoriel, vous avez besoin des éléments suivants :

• Un compte Azure avec un abonnement actif. Si vous n'en avez pas, créez un compte Azure gratuit, qui inclut un abonnement d'essai gratuit.
• Un projet Foundry.

• Rôle requis :
  • Propriétaire ou Contributeur sur la ressource Foundry ou AI Hub pour déployer des modèles
  • Azure AI User pour utiliser un modèle dans un projet Foundry
  • Développeur IA Azure pour utiliser le modèle dans un projet basé sur un hub

• Déploiement de modèle qui prend en charge l’API d’inférence de modèle. Cet article utilise Mistral-Large-3 dans des exemples de code ; vous pouvez remplacer votre propre nom de modèle déployé.

• Pour utiliser des fonctionnalités d’incorporation dans LlamaIndex, vous avez besoin d’un modèle d’incorporation comme cohere-embed-v3-multilingual.

  • Vous pouvez suivre les instructions fournies dans Déployer des modèles en tant que déploiements d’API serverless.

• Python 3.8 ou version ultérieure installée, y compris pip.

• LlamaIndex installé. Vous pouvez l’installer à l’aide de la commande suivante :

  pip install llama-index
  

• Dans cet exemple, vous utilisez l’API d’inférence de modèle pour installer les packages suivants :

  pip install -U llama-index-llms-azure-inference
  pip install -U llama-index-embeddings-azure-inference
  

  Important

  L’utilisation du service Foundry Models nécessite une version 0.2.4 pour llama-index-llms-azure-inference ou llama-index-embeddings-azure-inference.

Configurer l’environnement

Pour utiliser les LLMs déployés dans le portail Microsoft Foundry, vous avez besoin du point de terminaison et des informations d’identification pour vous y connecter. Procédez comme suit pour obtenir les informations dont vous avez besoin à partir du modèle que vous souhaitez utiliser :

1. Connectez-vous à Microsoft Foundry. Vérifiez que le commutateur New Foundry est activé. Ces étapes font référence à Foundry (nouveau).

   

2. Ouvrez le projet dans lequel le modèle est déployé, s’il n’est pas déjà ouvert.

3. Copiez l’URL du point de terminaison et la clé.

Dans ce scénario, définissez l’URL et la clé de point de terminaison en tant que variables d’environnement. (Si le point de terminaison que vous avez copié inclut du texte supplémentaire après /models, supprimez-le afin que l’URL se termine comme /models indiqué ci-dessous.)

export AZURE_INFERENCE_ENDPOINT="https://<resource>.services.ai.azure.com/models"
export AZURE_INFERENCE_CREDENTIAL="<your-key-goes-here>"

Après avoir configuré l’environnement, créez un client pour vous connecter au point de terminaison.

import os
from llama_index.llms.azure_inference import AzureAICompletionsModel

llm = AzureAICompletionsModel(
    endpoint=os.environ["AZURE_INFERENCE_ENDPOINT"],
    credential=os.environ["AZURE_INFERENCE_CREDENTIAL"],
)

Si votre point de terminaison sert plusieurs modèles, comme avec le service Foundry Models ou GitHub Models, vous devez spécifier le paramètre model_name :

import os
from llama_index.llms.azure_inference import AzureAICompletionsModel

llm = AzureAICompletionsModel(
    endpoint=os.environ["AZURE_INFERENCE_ENDPOINT"],
    credential=os.environ["AZURE_INFERENCE_CREDENTIAL"],
    model_name="Mistral-Large-3",
)

Procédez comme suit : Crée un client LLM avec une spécification de nom de modèle explicite pour les points de terminaison multimodèles. Le model_name paramètre indique au service quel modèle utiliser pour les achèvements de conversation.

Références:

• LlamaIndex Azure Intégration d’inférence
• Paramètres AzureAICompletionsModel

Sinon, si votre point de terminaison prend en charge Microsoft Entra ID, vous pouvez utiliser le code suivant pour créer le client :

import os
from azure.identity import DefaultAzureCredential
from llama_index.llms.azure_inference import AzureAICompletionsModel

llm = AzureAICompletionsModel(
    endpoint=os.environ["AZURE_INFERENCE_ENDPOINT"],
    credential=DefaultAzureCredential(),
)

Ce que cela signifie : Crée un client LLM à l’aide de l’authentification Microsoft Entra ID (Azure AD), qui est plus sécurisée pour les environnements de production que pour les clés API.

Vérifier votre configuration

Testez la connexion de votre client avec un appel simple :

from llama_index.core.llms import ChatMessage

messages = [ChatMessage(role="user", content="Hello")]
response = llm.chat(messages)
print(response)

Procédez comme suit : Appelle le modèle avec un message simple pour vérifier l’authentification et la connectivité. Sortie attendue : objet de réponse contenant le message d’accueil du modèle.

Références:

• LlamaIndex ChatMessage
• Méthode de chat LlamaIndex LLM

Si vous envisagez d’utiliser l’appel asynchrone, utilisez la version asynchrone pour les informations d’identification :

from azure.identity.aio import (
    DefaultAzureCredential as DefaultAzureCredentialAsync,
)
from llama_index.llms.azure_inference import AzureAICompletionsModel

llm = AzureAICompletionsModel(
    endpoint=os.environ["AZURE_INFERENCE_ENDPOINT"],
    credential=DefaultAzureCredentialAsync(),
)

Modèles OpenAI d'Azure et le service Foundry Models

Si vous utilisez Azure service OpenAI ou Foundry Models, assurez-vous d'avoir au moins la version 0.2.4 de l'intégration LlamaIndex. Utilisez le api_version paramètre si vous devez sélectionner un paramètre spécifique api_version.

Pour le service Foundry Models, vous devez passer le model_name paramètre :

from llama_index.llms.azure_inference import AzureAICompletionsModel

llm = AzureAICompletionsModel(
    endpoint="https://<resource>.services.ai.azure.com/models",
    credential=os.environ["AZURE_INFERENCE_CREDENTIAL"],
    model_name="Mistral-Large-3",
)

Pour Azure OpenAI dans les modèles Foundry :

from llama_index.llms.azure_inference import AzureAICompletionsModel

llm = AzureAICompletionsModel(
    endpoint="https://<resource>.openai.azure.com/openai/deployments/<deployment-name>",
    credential=os.environ["AZURE_INFERENCE_CREDENTIAL"],
    api_version="2024-05-01-preview",
)

Paramètres d’inférence

Vous pouvez configurer la façon dont l’inférence est effectuée pour toutes les opérations qui utilisent ce client en définissant des paramètres supplémentaires. Cette approche vous permet d’éviter de les spécifier sur chaque appel que vous effectuez au modèle.

llm = AzureAICompletionsModel(
    endpoint=os.environ["AZURE_INFERENCE_ENDPOINT"],
    credential=os.environ["AZURE_INFERENCE_CREDENTIAL"],
    temperature=0.0,
    model_kwargs={"top_p": 1.0},
)

Procédez comme suit : Définit les paramètres d’inférence par défaut (temperature et top_p) qui s’appliquent à tous les appels de conversation et d’achèvement effectués avec ce client. La température inférieure (0,0) produit des sorties plus déterministes ; top_p contrôle la diversité de l’échantillonnage.

Références:

• Paramètres de l’API d’inférence de modèle

Pour les paramètres non pris en charge dans l’API d’inférence de modèle (référence), mais disponibles dans le modèle sous-jacent, utilisez l’argument model_extras . Dans l’exemple suivant, le paramètre safe_prompt, qui est disponible uniquement pour les modèles Mistral, est passé.

llm = AzureAICompletionsModel(
    endpoint=os.environ["AZURE_INFERENCE_ENDPOINT"],
    credential=os.environ["AZURE_INFERENCE_CREDENTIAL"],
    temperature=0.0,
    model_kwargs={"model_extras": {"safe_prompt": True}},
)

Utiliser des modèles LLM

Vous pouvez utiliser le client directement ou configurer les modèles utilisés par votre code dans LlamaIndex. Pour utiliser le modèle directement, utilisez la méthode chat pour les modèles d’instructions de conversation :

from llama_index.core.llms import ChatMessage

messages = [
    ChatMessage(
        role="system", content="You are a pirate with colorful personality."
    ),
    ChatMessage(role="user", content="Hello"),
]

response = llm.chat(messages)
print(response)

Vous pouvez également diffuser en continu les sorties :

response = llm.stream_chat(messages)
for r in response:
    print(r.delta, end="")

La complete méthode est toujours disponible pour les modèles de type chat-completions. Dans ces cas, votre texte d’entrée est converti en message à l’aide de role="user".

Utiliser des modèles d’incorporation

Tout comme vous créez un client LLM, vous pouvez vous connecter à un modèle d’embeddings. Dans l’exemple suivant, définissez la variable d’environnement pour qu’elle pointe vers un modèle d’incorporation :

export AZURE_INFERENCE_ENDPOINT="<your-model-endpoint-goes-here>"
export AZURE_INFERENCE_CREDENTIAL="<your-key-goes-here>"

Créez ensuite le client :

from llama_index.embeddings.azure_inference import AzureAIEmbeddingsModel

embed_model = AzureAIEmbeddingsModel(
    endpoint=os.environ["AZURE_INFERENCE_ENDPOINT"],
    credential=os.environ['AZURE_INFERENCE_CREDENTIAL'],
    model="<your-model-name>",
)

Procédez comme suit : Instancie un client d’incorporations pour convertir du texte en incorporations vectorielles. Les embeddings sont des représentations numériques du texte utilisées pour les recherches de similarité sémantique et la génération augmentée par récupération (RAG).

Références:

• Intégration de LlamaIndex Embeddings
• AzureAIEmbeddingsModel

L’exemple suivant montre un test simple pour vérifier qu’il fonctionne :

from llama_index.core.schema import TextNode

nodes = [
    TextNode(
        text="Before college the two main things I worked on, "
        "outside of school, were writing and programming."
    )
]
response = embed_model(nodes=nodes)
print(response[0].embedding)

Procédez comme suit : Convertit un nœud de texte en incorporations et imprime la représentation vectorielle numérique. Sortie attendue : liste de nombres à virgule flottante représentant la signification sémantique du texte (longueur classique : 384 à 1024 dimensions en fonction du modèle).

Références:

• TextNode

Configurer les modèles que votre code utilise

Dans votre code, vous pouvez utiliser le client de modèle LLM ou d’incorporation individuellement lors de l’utilisation de LlamaIndex, ou configurer l’intégralité de la session à l’aide des Settings options. Lorsque vous configurez la session, tout votre code utilise les mêmes modèles pour toutes les opérations.

from llama_index.core import Settings

Settings.llm = llm
Settings.embed_model = embed_model

Procédez comme suit : Inscrit globalement les clients LLM et embeddings afin que toutes les opérations LlamaIndex utilisent automatiquement ces modèles sans avoir à les transmettre en tant que paramètres à chaque fonction.

Références:

• Paramètres LlamaIndex

Toutefois, certains scénarios nécessitent un modèle général pour la plupart des opérations et un modèle spécifique pour une tâche donnée. Dans ces cas, définissez le modèle LLM ou le modèle d'incorporation pour chaque construction LlamaIndex. L’exemple suivant montre comment définir un modèle spécifique :

from llama_index.core.evaluation import RelevancyEvaluator

relevancy_evaluator = RelevancyEvaluator(llm=llm)

Procédez comme suit : Crée un évaluateur de pertinence qui utilise votre client LLM personnalisé pour évaluer les résultats de récupération. Cela vous permet d’utiliser différents modèles pour différentes tâches (par exemple, un modèle spécifique pour l’évaluation et la conversation générale).

Références:

• Évaluateurs LlamaIndex

En règle générale, utilisez une combinaison des deux stratégies.

Contenu connexe

• Comment démarrer avec les SDKs Azure AI
• Informations de référence sur l’intégration de LlamaIndex Embeddings
• Informations de référence sur l’intégration de LLamaIndex LLMs