L’Intelligence Artificielle (IA) est un sujet à la mode : tout le monde en parle et souhaite l’intégrer à ses produits. Dans le domaine du Web, l’IA est souvent synonyme d’utilisation de modèles LLM. Si les noms de Mistral ou OpenAI ne vous sont pas inconnus, il est plus rare de savoir comment intégrer les modèles LLM qu’ils proposent.
Dans cet article nous vous présentons d’abord comment intégrer facilement les LLM de Mistral et OpenAI par le biais de leurs SDK avant de nous intéresser à une solution plus modulable qu’est LangChain.
Avant-propos
Avant de commencer, voici quelques informations qui vous seront utiles pour la compréhension de la suite de l’article.
Tout d’abord, un petit rappel des acronymes :
- SDK : Software Development Kit - Ensemble d’outils logiciels destinés à la facilitation du développement.
- LLM : Large Language Model - Modèle de langage qui possède un grand nombre de paramètres et reposent sur des réseaux de neurones profonds.
Les LLM sont des modèles statistiques qui, pour pouvoir être utilisés, doivent être associés à une application. Par exemple, Chat-GPT est une application de type chatbot qui utilise le modèle LLM GPT.
Les SDK associés à ces LLM sont donc des outils qui vous facilitent le travail d’intégration de ces modèles à votre propre application. Ces SDK sont la plupart du temps développés en Python (langage de prédilection des IA) mais peuvent aussi exister dans des langages plus couramment utilisés sur le Web.
Approche directe : utiliser les SDK
Si le choix sur le modèle d’Intelligence Artificielle que l’on souhaite utiliser est déjà arrêté, il peut être plus intéressant de s’orienter directement vers une intégration qui utilise les outils (le SDK) dédiés au modèle choisi. Voyons comment intégrer rapidement et facilement un LLM Mistral AI et un LLM OpenAI à nos applications.
NB : Nous proposons ici deux exemples ciblés, mais il est important de mentionner qu’Anthropic (fournisseur de Claude) et Google (fournisseur de Gemini) proposent eux aussi leur propre SDK.
Intégration avec le SDK de Mistral AI
La documentation utilisateur de Mistral présente les différents SDK disponibles et comment rapidement les implémenter.
Ceux-ci existent en version officielle en langage Python et Typescript, mais aussi en version non-officielle (i.e. fournis par la communauté et non pas par Mistral AI) dans d’autres langages, dont PHP et JavaScript. Toutefois, comme il est possible d’exécuter un script Python par le biais d’un script PHP, nous présentons ci-dessous l’intégration du SDK Python.
Première étape : récupérer le package « mistralai ». Nous utilisons le package manager par défaut de Python : pip.
pip install mistralai
Une fois Mistral installé, nous pouvons créer un premier exemple dans un fichier script_mistral.py :
#!/usr/bin/env python
import os
from mistralai import Mistral
from mistralai.models import UserMessage
def main():
api_key = os.getenv("MISTRAL_API_KEY", "{my_key_value}")
model = "mistral-medium-latest"
client = Mistral(api_key=api_key)
chat_response = client.chat.complete(
model=model,
messages=[UserMessage(content="Can you give me a short description of french web agency Adimeo?")],
)
print(chat_response.choices[0].message.content)
if __name__ == "__main__":
main()
Exécuté depuis une console, ce script nous donne par exemple le résultat suivant :
Si l’on souhaite améliorer la qualité de la réponse, il est possible de jouer sur le nombre de tokens maximal (max_tokens) que la requête peut utiliser ainsi que sur la température (ou niveau de créativité). Il aura donc suffi d’une commande d’installation et d’un fichier de script pour pouvoir commencer à utiliser le LLM de Mistral.
Intégration avec le SDK d’OpenAI
Afin de comparer la facilité d’implémentation, intéressons-nous maintenant à OpenAI et ses SDK. Tout comme pour Mistral, la liste des SDK est disponible dans la documentation officielle. Une fois encore, nous allons utiliser le SDK en Python, puisqu’il fait partie des versions officiellement maintenues par OpenAI.
De la même manière, la première étape consiste à récupérer le package openai :
# install from PyPI
pip install openai
Nous pouvons ensuite utiliser le petit script suivant pour simuler un chat et lui demander des informations à propos d’Adimeo.
import os
from openai import OpenAI
client = OpenAI(
api_key=os.getenv("OPENAI_API_KEY", "{my_api_key_value}"),
)
response = client.responses.create(
model="gpt-4o",
temperature=0.7
input="Can you give me a short description of french web agency Adimeo?",
)
print(response.output_text)
Ce script nous donne le résultat suivant :
De la même manière qu’avec Mistral, il est possible de jouer sur les paramètres pour changer le modèle LLM que l’on souhaite utiliser, le nombre de tokens à utiliser ou bien donner plus ou moins de contexte au modèle afin d’orienter sa réponse.
LangChain : un framework pour les gouverner tous
Voyons maintenant une autre approche, celle de LangChain. LangChain est un outil qui se veut être une interface standard pour l’intégration des modèles, qu’ils proviennent d’OpenAI, Anthropic, Google ou autre.
Là où les SDK dédiés ont chacun leurs propres spécificités, LangChain permet au contraire de construire des applications sur une architecture commune. Le développeur utilise la librairie (framework) mise à disposition par LangChain et c’est ensuite celle-ci qui se charge de gérer les spécificités propres à chaque modèle utilisé. C’est donc un gain de temps non négligeable pour les développeurs s’ils doivent utiliser plusieurs modèles issus de fournisseurs différents.
Si vous souhaitez en apprendre plus sur LangChain, vous pouvez vous référer à la documentation officielle. Reprenons nos exemples des chapitres précédents, mais intégrés cette fois-ci par l’intermédiaire de LangChain.
Première étape : installer LangChain
pip install -U langchain
Deuxième étape : installer le ou les paquets relatifs au(x) modèle(s) que l’on souhaite utiliser (dans notre cas, OpenAI et Mistral AI)
pip install -U langchain-openai
pip install -U langchain-mistralai
Intégration de Mistral AI via LangChain
Créons maintenant un petit script dont le but sera le même que lors de l’utilisation du SDK de Mistral AI : demander au modèle de nous donner des informations sur Adimeo.
La différence par rapport au SDK est qu’ici le code utilise des classes et méthodes définies par LangChain. Nous n’utilisons pas directement du code proposé par Mistral AI.
#!/usr/bin/env python
import os
from langchain_mistralai import ChatMistralAI
def main():
api_key = os.getenv("MISTRAL_API_KEY", "{my_key_value}")
llm = ChatMistralAI(
model="mistral-medium-latest",
temperature=0.7,
mistral_api_key=api_key,
)
messages = [
(
"human",
"Can you give me a short description of french web agency Adimeo?"
),
]
ai_msg = llm.invoke(messages)
print(ai_msg.content)
if __name__ == "__main__":
main()
Sans grande surprise, le résultat est très similaire à ce que nous avions obtenu avec l’utilisation du SDK de Mistral.
Intégration de OpenAI via LangChain
Dernier cas de figure, reprenons notre exemple OpenAI mais intégré via LangChain.
#!/usr/bin/env python
import os
from langchain_openai import ChatOpenAI
def main():
api_key = os.getenv("OPENAI_API_KEY", "{my_key_value}")
llm = ChatOpenAI(
model="gpt-4o",
temperature=0.7,
api_key=api_key,
)
messages = [
(
"human",
"Can you give me a short description of french web agency Adimeo?"
),
]
ai_msg = llm.invoke(messages)
print(ai_msg.content)
if __name__ == "__main__":
main()
Une fois encore, le résultat est très similaire à celui obtenu via le SDK d’OpenAI.
Comparaison entre l’intégration de Mistral et l’intégration d’OpenAI via LangChain
Si nous comparons nos deux exemples d’intégration via LangChain, nous constatons que les deux codes sont très similaires. Les deux seules différences résident dans :
- la classe importée pour cibler l’Intelligence Artificielle à utiliser (
ChatMistralAId’un côté,ChatOpenAIde l’autre). - Les paramètres passés lors de l’instanciation de cette classe importée :
- côté Mistral :
llm = ChatMistralAI(
model="mistral-medium-latest",
temperature=0.7,
mistral_api_key=api_key,
) - côté OpenAI :
llm = ChatOpenAI(
model="gpt-4o",
temperature=0.7,
api_key=api_key,
)
Hormis ces deux différences, le code est similaire entre nos deux exemples, c’est là tout l’intérêt de LangChain : plus besoin de connaître les spécificités de chaque modèle pour pouvoir l’intégrer.
En conclusion, dans cet article, nous vous avons montré avec quelle facilité il est possible d’intégrer l’Intelligence Artificielle à vos applications.
Par le biais des SDKs dédiés, l’avantage est d’utiliser un set d’outils optimisés pour communiquer avec le modèle de votre choix. L’inconvénient se présente lorsque vous devez intégrer différents modèles issus de différents fournisseurs : cela oblige à connaître les spécificités de code de chacun.
Par le biais de LangChain, un niveau d’abstraction supplémentaire est introduit, ce qui vous permet de passer facilement d’un modèle d’IA à l’autre sans pour autant devoir réécrire tout votre code.
Si les solutions proposées dans cet article requièrent l’utilisation du code, il est à noter qu’il existe aussi d’autres solutions dites « all-in-one » qui proposent un niveau d’abstraction encore plus élevé. C’est le cas par exemple de Dify, Flowise ou n8n.
Poursuivez votre lecture avec d’autres articles du blog Adimeo :
- Dify et les modules Chatbot pour intranet et site Web
- Mistral AI : zoom sur l'intelligence artificielle 100 % française
Crédit photo : NicoElNino
27 octobre 2025
6 minutes
