Utiliser LangChain avec des modèles dans Microsoft Foundry

Utilisez langchain-azure-ai pour générer des applications LangChain qui appellent des modèles déployés dans Microsoft Foundry. Les modèles avec des API compatibles OpenAI peuvent être utilisés directement. Dans cet article, vous allez créer des clients de chat et des clients pour les embeddings, exécuter des chaînes de prompts et combiner la génération avec les processus de vérification.

Conditions préalables

• Un abonnement Azure. Créez-en un gratuitement.
• Un projet Foundry.
• Le rôle Utilisateur Azure AI sur le projet Foundry.
• Modèle de conversation déployé qui prend en charge les API compatibles OpenAI, telles que gpt-4.1 ou Mistral-Large-3.
• Un modèle d’intégrations déployé, tel que text-embedding-3-large.
• Python 3.9 ou version ultérieure.

Installez les packages requis :

pip install -U langchain langchain-azure-ai azure-identity

Configurer l’environnement

Définissez l’un des modèles de connexion suivants :

• Project point de terminaison avec Microsoft Entra ID (recommandé).
• Point de terminaison direct avec une clé API.

import os

# Option 1: Project endpoint (recommended)
os.environ["AZURE_AI_PROJECT_ENDPOINT"] = (
	"https://<resource>.services.ai.azure.com/api/projects/<project>"
)

# Option 2: Direct OpenAI-compatible endpoint + API key
os.environ["OPENAI_BASE_URL"] = (
	"https://<resource>.services.ai.azure.com/openai/v1"
)
os.environ["OPENAI_API_KEY"] = "<your-api-key>"

Ce que fait cet extrait de code : Définit les variables d’environnement utilisées par les classes de modèle pour l’accès langchain-azure-ai au point de terminaison basé sur un projet ou direct.

Utiliser des modèles de conversation

Vous pouvez facilement instancier un modèle à l’aide init_chat_modelde :

from langchain.chat_models import init_chat_model

model = init_chat_model("azure_ai:gpt-4.1")

Tous les modèles Foundry prenant en charge les API compatibles OpenAI peuvent être utilisés avec le client, mais ils doivent d’abord être déployés sur votre ressource Foundry. L’utilisation de project_endpoint (variable d’environnement AZURE_AI_PROJECT_ENDPOINT) nécessite Microsoft Entra ID pour l’authentification et le rôle Azure utilisateur IA.

Ce que fait cet extrait de code : Crée un client de modèle de conversation à l’aide de la init_chat_model méthode pratique. Le client achemine vers le modèle spécifié via le point de terminaison du projet Foundry ou le point de terminaison direct configuré dans l’environnement.

Références:

• AzureAIOpenAIApiChatModel

Vérifier votre configuration

Exécutez un appel de modèle simple :

response = model.invoke("Say hello")
response.pretty_print()

================================== Ai Message ==================================
Hello! 👋 How can I help you today?

Ce que fait cet extrait de code : Envoie une invite de base pour vérifier le point de terminaison, l’authentification et le routage du modèle.

Références:

• Interface LangChain runnable

Modèles configurables

Vous pouvez également créer un modèle configurable par le runtime en spécifiant configurable_fields. Lorsque vous omettez le model paramètre, il devient un champ configurable par défaut.

from langchain.chat_models import init_chat_model
from azure.identity import DefaultAzureCredential

configurable_model = init_chat_model(
    model_provider="azure_ai", 
    temperature=0,
	credential=DefaultAzureCredential()
)


configurable_model.invoke(
    "what's your name",
    config={"configurable": {"model": "gpt-5-nano"}},  # Run with GPT-5-nano
).pretty_print()

configurable_model.invoke(
    "what's your name",
    config={"configurable": {"model": "Mistral-Large-3"}}, # Run with Mistral Large
).pretty_print()

================================== Ai Message ==================================

Hi! I'm ChatGPT, an AI assistant built by OpenAI. You can call me ChatGPT or just Assistant. How can I help you today?
================================== Ai Message ==================================

I don't have a name, but you can call me **Assistant** or anything you like! 😊 What can I help you with today?

Ce que fait cet extrait de code : Crée une instance de modèle configurable qui vous permet de changer facilement de modèle au moment de l’appel. Étant donné que le model paramètre est manquant dans init_chat_model, il s’agit par défaut d’un champ configurable et peut être passé avec invoke(). Vous pouvez ajouter d’autres champs à configurer en configurant configurable_fields.

Configurer les clients directement

Vous pouvez également créer un client de modèle de conversation à l’aide de AzureAIOpenAIApiChatModel la classe.

import os

from azure.identity import DefaultAzureCredential
from langchain_azure_ai.chat_models import AzureAIOpenAIApiChatModel

model = AzureAIOpenAIApiChatModel(
	project_endpoint=os.environ["AZURE_AI_PROJECT_ENDPOINT"],
	credential=DefaultAzureCredential(),
	model="Mistral-Large-3",
)

Par défaut, AzureAIOpenAIApiChatModel utilise l’API Réponses OpenAI. Vous pouvez modifier ce comportement en passant use_responses_api=False:

import os

from azure.identity import DefaultAzureCredential
from langchain_azure_ai.chat_models import AzureAIOpenAIApiChatModel

model = AzureAIOpenAIApiChatModel(
    endpoint=os.environ["AZURE_AI_PROJECT_ENDPOINT"],
    credential=DefaultAzureCredential(),
    model="Mistral-Large-3",
    use_responses_api=False
)

Exécuter des appels asynchrones

Utilisez des informations d’identification asynchrones si votre application appelle des modèles avec ainvoke. Lorsque vous utilisez Microsoft Entra ID pour l’authentification, utilisez l’implémentation asynchrone correspondante pour les informations d’identification :

import os

from azure.identity.aio import DefaultAzureCredential as DefaultAzureCredentialAsync
from langchain_azure_ai.chat_models import AzureAIOpenAIApiChatModel

model = AzureAIOpenAIApiChatModel(
	project_endpoint=os.environ["AZURE_AI_PROJECT_ENDPOINT"],
	credential=DefaultAzureCredentialAsync(),
	model="gpt-4.1",
)


async def main():
	response = await model.ainvoke("Say hello asynchronously")
	response.pretty_print()


import asyncio
asyncio.run(main())

================================== Ai Message ==================================
Hello! 👋 How can I help you today?

Ce que fait cet extrait de code : Crée un client asynchrone et exécute une demande non bloquante avec ainvoke.

Références:

• Identifiants asynchrones dans Azure Identity
• Interface LangChain runnable

Raisonnement

De nombreux modèles peuvent effectuer un raisonnement en plusieurs étapes pour arriver à une conclusion. Cela implique de décomposer les problèmes complexes en étapes plus petites et plus gérables.

from langchain.chat_models import init_chat_model

model = init_chat_model("azure_ai:DeepSeek-R1-0528")

for chunk in model.stream("Why do parrots have colorful feathers?"):
    reasoning_steps = [r for r in chunk.content_blocks if r["type"] == "reasoning"]
    print(reasoning_steps if reasoning_steps else chunk.text, end="")

print("\n")

Parrots have colorful feathers primarily due to a combination of evolutionary ...

Références:

• Le streaming de LangChain

Outils côté serveur

Les modèles OpenAI déployés dans Foundry prennent en charge les boucles d’appel d’outils côté serveur : les modèles peuvent interagir avec la recherche web, les interpréteurs de code et d’autres outils, puis analyser les résultats d’un tour de conversation unique. Si un modèle appelle un serveur d’outils, le contenu du message de réponse inclut le contenu représentant l’appel et le résultat de l’outil.

Il s’agit d’outils fournis par OpenAI qui étendent les fonctionnalités du modèle. Pour afficher la liste complète des outils pris en charge, consultez les outils intégrés.

L’exemple suivant montre comment utiliser la recherche web :

from langchain.chat_models import init_chat_model
from langchain_azure_ai.tools.builtin import WebSearchTool
from azure.identity import DefaultAzureCredential

model = init_chat_model("azure_ai:gpt-4.1", credential=DefaultAzureCredential())
model_with_web_search = model.bind_tools([WebSearchTool()])

result = model_with_web_search.invoke("What is the current price of gold? Give me the answer in one sentence.")
result.content[-1]["text"]

As of today, March 24, 2026, the spot price of gold is approximately $4,397.80 per ounce. ([tradingeconomics.com](https://tradingeconomics.com/commodity/gold))

Certains outils peuvent nécessiter la configuration d’autres ressources dans votre projet. Permet azure-ai-projects de configurer ces ressources, puis de les référencer à partir de LangChain/LangGraph.

L’exemple suivant montre comment configurer un magasin de fichiers avant de l’utiliser dans un outil :

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

# Create clients to call Foundry API
project = AIProjectClient(
    endpoint=os.environ["AZURE_AI_PROJECT_ENDPOINT"],
    credential=DefaultAzureCredential(),
)
openai = project.get_openai_client()

# Create vector store and upload file
vector_store = openai.vector_stores.create(name="ProductInfoStore")
vector_store_id = vector_store.id

with open("product_info.md", "rb") as file_handle:
    vector_store_file = openai.vector_stores.files.upload_and_poll(
        vector_store_id=vector_store.id,
        file=file_handle,
    )

Quoi fait : Configure un magasin de vecteurs avec un fichier dans Microsoft Foundry afin qu'un modèle puisse effectuer une recherche ultérieure sur le contenu de ce fichier (utilisé avec le FileSearchTool dans le bloc de code suivant).

from langchain_azure_ai.tools.builtin import FileSearchTool

model_with_tools = model.bind_tools([FileSearchTool(vector_store_ids=[vector_store.id])])

results = model_with_tools.invoke("Tell me about Contoso products")
print("Answer:", results.content[-1]["text"])
print("Annotations:", results.content[-1]["annotations"])

Answer: Contoso offers the following products:

1. **The widget**
   - Description: A high-quality widget that is perfect for all your widget needs.
   - Price: $19.99

2. **The gadget**
   - Description: An advanced gadget that offers exceptional performance and reliability.
   - Price: $49.99

These products are part of Contoso's main offerings as detailed in their product information documentation.
Annotations: [{'file_id': 'assistant-MvU5SEqUcUBumoLUV5BXxn', 'filename': 'product_info.md', 'type': 'file_citation', 'file_index': 395}]

Utiliser des modèles Foundry dans les agents

Utilisez create_agent avec les modèles connectés à Foundry pour créer des boucles d'agents au style ReAct :

from langchain.agents import create_agent

agent = create_agent(
    model="azure_ai:gpt-5.2", 
    system_prompt="You're an informational agent. Answer questions cheerfully.", 
)

response = agent.invoke({"messages": "what's your name?"})
response["messages"][-1].pretty_print()

================================== Ai Message ==================================

I’m ChatGPT, your AI assistant.

Les outils côté serveur peuvent également être utilisés, mais ils nécessitent un appel bind_tools.

from langchain.chat_models import init_chat_model
from langchain.agents import create_agent
from langchain_azure_ai.tools.builtin import ImageGenerationTool

model = init_chat_model("azure_ai:gpt-5.2")
tools = [ImageGenerationTool(model="gpt-image-1.5", size="1024x1024")]
model_with_tools = model.bind_tools(tools)

agent = create_agent(
    model=model_with_tools,
    tools=tools,
    system_prompt="You're an informational agent. Answer questions with graphics.", 
)

Utiliser des modèles d’incorporation

Vous pouvez facilement instancier un modèle à l’aide init_embeddingsde :

from langchain.embeddings import init_embeddings

embed_model = init_embeddings("azure_ai:text-embedding-3-small")

Ce que fait cet extrait de code : Crée un client de modèle d’incorporation à l’aide de la init_embeddings méthode pratique.

Tous les modèles Foundry prenant en charge les API compatibles OpenAI peuvent être utilisés avec le client, mais ils doivent d’abord être déployés sur votre ressource Foundry. L’utilisation de project_endpoint (variable d’environnement AZURE_AI_PROJECT_ENDPOINT) nécessite Microsoft Entra ID pour l’authentification et le rôle Azure utilisateur IA.

Ou créez le client d’incorporation avec AzureAIOpenAIApiEmbeddingsModel.

import os

from azure.identity import DefaultAzureCredential
from langchain_azure_ai.embeddings import AzureAIOpenAIApiEmbeddingsModel

embed_model = AzureAIOpenAIApiEmbeddingsModel(
	project_endpoint=os.environ["AZURE_AI_PROJECT_ENDPOINT"],
	credential=DefaultAzureCredential(),
	model="text-embedding-3-large",
)

Pour l’authentification directe de point de terminaison et de clé API :

import os

from langchain_azure_ai.embeddings import AzureAIOpenAIApiEmbeddingsModel

embed_model = AzureAIOpenAIApiEmbeddingsModel(
	endpoint=os.environ["OPENAI_BASE_URL"],
	credential=os.environ["OPENAI_API_KEY"],
	model="text-embedding-3-large",
)

Ce que fait cet extrait de code : Configure la génération d’incorporations pour la recherche vectorielle, la récupération et les flux de travail de classement.

Références:

• AzureAIOpenAIApiEmbeddingsModel

Exemple : Exécuter une recherche de similarité avec un magasin de vecteurs

Utilisez un magasin vectoriel en mémoire pour l’expérimentation locale.

from langchain_core.documents import Document
from langchain_core.vectorstores import InMemoryVectorStore

vector_store = InMemoryVectorStore(embed_model)

documents = [
	Document(id="1", page_content="foo", metadata={"baz": "bar"}),
	Document(id="2", page_content="thud", metadata={"bar": "baz"}),
]

vector_store.add_documents(documents=documents)

results = vector_store.similarity_search(query="thud", k=1)
for doc in results:
	print(f"* {doc.page_content} [{doc.metadata}]")

* thud [{'bar': 'baz'}]

Ce que fait cet extrait de code : Ajoute des exemples de documents à un magasin vectoriel et retourne le document le plus similaire pour une requête.

Références:

• Magasins de vecteurs LangChain

Débogage des requêtes grâce à la journalisation.

Activez le langchain_azure_ai journal de débogage pour inspecter le flux des requêtes.

import logging
import sys

logger = logging.getLogger("langchain_azure_ai")
logger.setLevel(logging.DEBUG)

handler = logging.StreamHandler(stream=sys.stdout)
formatter = logging.Formatter(
	"%(asctime)s:%(levelname)s:%(name)s:%(message)s"
)
handler.setFormatter(formatter)
logger.addHandler(handler)

Ce que fait cet extrait de code : configure la journalisation Python pour émettre des journaux de SDK détaillés qui aident à résoudre les problèmes de point de terminaison ou de charge utile.

Références:

• Journalisation pour Python

Informations de référence sur les variables d’environnement

Vous pouvez configurer les variables d’environnement suivantes. Ces valeurs peuvent également être configurées lors de la construction des objets :

Étape suivante

Contenu connexe

• Vue d'ensemble des modèles Foundry
• Vue d’ensemble du Kit de développement logiciel (SDK) Microsoft Foundry
• Utiliser LangChain avec mémoire dans Foundry
• Utiliser LangChain avec le service Agent Foundry