Python : utiliser l’API de Mistral AI pour intégrer l’IA dans un projet

I. Présentation

Vous souhaitez intégrer l’IA dans votre terminal ou vos projets Python ? On vous montre comment faire dans ce tutoriel d’introduction à l’API de Mistral AI.

L’utilisation de l’API des services de Mistral AI permet d’intégrer facilement ses LLM (Large Language Model) dans un programme, script, une application web ou simplement dans votre terminal. Nous utiliserons ici la version gratuite de l’API, parfaite pour se faire une première idée de la simplicité d’intégration et des contextes d’utilisation. Nous allons notamment voir plusieurs exemples d’utilisation, du prompt pré-enregistré à l’utilisation plus dynamique de paramètres.

Quelques bases de Python sont requises pour suivre ce tutoriel, qui reste cependant très accessible. Si vous avez besoin d’un petit rappel, n’hésitez pas à consulter notre article Python pour débutant : 

• IT-Connect.fr - Écrire son premier script Python : guide pour débutants

II. Compte Mistral et API

Un prérequis nécessaire à l’utilisation de l’API gratuite de Mistral AI pour accéder à son LLM est de disposer d’une clé API, elle aussi gratuite. La création de cette clé nécessite bien entendu un compte sur la plateforme. 

Pourquoi une clé API si c’est gratuit ? 

L’utilisation d’une clé API permet à Mistral AI de contrôler l’utilisation de son API. Elle permet de savoir qui effectue la requête (chaque clé API est rattachée à un compte), de vérifier si les quotas d’utilisation sont atteints pour ce compte et de gérer les permissions et avantages associés (notamment si vous utilisez une version payante). Dans le cadre d’une version gratuite, il est normal que l’accès à toute la puissance et aux ressources de Mistral AI soit limité.

En tant qu’utilisateur de la version gratuite, vous verrez que le nombre de requêtes (et leur priorité de traitement) est restreint. Mais, à nouveau, cela nous laisse quand même la possibilité de tester et d’expérimenter avant de passer aux choses sérieuses.

La création d’un compte Mistral AI s'effectue via cette page : auth.mistral.ai/ui/registration 

Une fois votre compte créé, je vous invite à vous rendre sur cette page :  admin.mistral.ai/plateforme/subscription 

Ce que Mistral AI appelle “La plateforme” semble être l’espace principal de gestion et configuration dans lequel nous pouvons gérer nos souscriptions, quotas, agents, et tout un tas d’autres paramètres. Ici, nous devons nous rendre dans “La Plateforme > Subscription”.

Vous arriverez ensuite sur la page console.mistral.ai/upgrade/plans et pourrez choisir le plan gratuit “Experiment” :

Comme indiqué, vos requêtes pourront être utilisées pour améliorer le service de Mistral AI et ce plan vous permettra d’accéder à quelques fonctionnalités. 

Suite à cette sélection, vous devrez accepter les termes et conditions, puis saisir un numéro de téléphone pour recevoir un code confirmation.

Cette procédure permet à Mistral AI de contrôler le nombre d’inscriptions et d’éviter qu’une même personne ne se crée plusieurs centaines de comptes pour disposer d’un accès quasi illimité à ses ressources.

Une fois cette opération réalisée, vous aurez droit à un “Subscription Successfull !” et pourrez vous rendre sur la page console.mistral.ai/api-keys. Cette page vous permet de créer et gérer vos clés API. Cliquons à présent sur “Create new key” :

Dans le pop-up qui apparait, saisissez le nom de votre clé ainsi qu’une date d’expiration :

Attention ! La date d’expiration est importante (notamment quand vous utilisez une API sensible ou payante). En cas de fuite de cette clé, cette information suffira à l’attaquant pour utiliser votre compte à votre place, pour consommer vos ressources et voler vos informations. La date d’expiration permet de limiter l’impact d’un vol de votre clé dans le temps.

Pour finir, votre clé API apparaitra. Il est important de la conserver, par exemple, dans un KeePass ou autre coffre-fort de mot de passe. Pour des raisons de sécurité, il vous sera impossible de la récupérer à nouveau depuis l’interface Mistral et il faudra en recréer une autre si vous la perdez.

Au passage, n’hésitez pas à parcourir les autres menus de La Plateforme, cela vous permettra d’avoir un aperçu de ce qu’il est possible de faire avec notre plan actuel, ou un plan payant dans le futur.

Comme indiqué plus haut, cette clé API va nous autoriser à utiliser les modèles et les ressources de Mistral AI afin d’expérimenter via du code (dans notre cas : Python). Nous pouvons à présent passer à la partie la plus intéressante !

III. Quelques lignes de Python

A. Installation du module

À présent, nous devons installer le module nommé mistralai, je vais passer par un environnement Python virtuel afin de respecter les bonnes pratiques : 

# Création du répertoire projet et accès
mkdir mistral.ai-tests
cd mistral.ai-tests/

# Création du venv Python
python3 -m venv venv\
python3 -m venv .
source ./bin/activate

Nous sommes à présent dans notre environnement virtuel et pouvons installer le module qui nous intéresse : 

pip install mistralai

Si tout se passe bien, vous devriez avoir un retour tel que celui-ci :

Ce module est en fait un client pour la plateforme de Mistral AI. Il contient toutes les fonctions utiles pour accéder aux différents modèles disponibles, gérer les clés API, les échanges asynchrones avec les modèles, les ressources, etc. Cela nous évite d’avoir à tout coder et d’utiliser des modules plus basiques comme requests.

Nous allons à présent mettre notre clé API dans une variable d’environnement, qui ne sera valide que pour notre terminal actuel. Cela évite d’avoir à l’inscrire directement dans notre script. Si vous êtes habitués du Python, vous pouvez aussi passer par un fichier de configuration ou d’autres méthodes : 

# Création d’une variable d’environnement bash contenant la clé API
export MISTRAL_API_KEY="<votre clé API>"

B. Script basique pour Mistral AI

Nous avons maintenant tout ce qu’il faut ! Créons un script python classique dans lequel nous allons importer et utiliser ce module :

# Importation des modules nécessaires
# Module pour interagir avec le système d'exploitation
import os
# Importation de la classe Mistral du module mistralai
from mistralai import Mistral     

# Récupération de la clé API à partir des variables d'environnement
api_key = os.environ["MISTRAL_API_KEY"]
# Définition du modèle à utiliser pour la requête
model = "mistral-large-latest"

# Création d'une instance de la classe Mistral avec la clé API
client = Mistral(api_key=api_key)

# Envoi d'une requête de complétion de chat au modèle spécifié
chat_response = client.chat.complete(
    model=model,                   # Spécification du modèle à utiliser
    messages=[                     # Liste des messages pour la conversation
        {
            "role": "user",       # Rôle de l'expéditeur du message
            "content": "D'où vient la popularité du nombre 42 ?",  # Contenu du message
        },
    ]
)

# Affichage de la réponse générée par le modèle
print(chat_response.choices[0].message.content)

Je vous invite à retrouver ce petit script sur notre GitHub. Notamment pour profiter de la coloration syntaxique, mais aussi pour le réutiliser et modifier :

Ce code importe les modules mistralai et os (pour la récupération de la variable d’environnement). La variable model permet de définir le modèle que nous souhaitons utiliser, nous verrons un peu plus tard que plusieurs sont disponibles, chacun avec des capacités et des performances différentes.

Nous créons ensuite une instance de la classe Mistral dans la variable client et qui aura comme paramètre notre clé API. C’est via cet objet que nous allons échanger avec les services de Mistral AI.

Ensuite, nous utilisons la fonction client.chat.complete(), qui prend en paramètre le modèle, ainsi qu’une liste de messages où chaque message est un dictionnaire contenant le rôle (role) et le contenu (content) du message.

La dernière ligne nous permet bien sûr d’afficher la réponse du modèle une fois celle-ci réceptionnée.

En utilisant le plan “Experiment”, c'est-à-dire gratuit, j’ai l’impression que nos requêtes ne sont pas traitées en priorité et il peut y avoir, en fonction de la charge et des périodes, quelques secondes d’attente.

Sans plus attendre, voici la démonstration d’utilisation de ce premier script :

Plutôt pas mal non ? Après quelques tests, je suis assez étonné de la quasi-absence d’hallucinations et de la rapidité de traitement. L’IA m’a même indiqué qu’elle n’avait pas les informations nécessaires au lieu d’inventer une donnée comme le fait souvent ChatGPT (Comment ça je suis partial ? :D).

• IT-Connect.fr - Intelligence artificielle et LLM : qu’est-ce qu’une hallucination ?

Dans ce premier script, le prompt est écrit en dur, ce qui n’est pas très réaliste. Essayons de faire un deuxième script un peu plus dynamique qui nous demande de saisir un prompt, puis nous fournit la réponse jusqu’à ce que nous saisissions bye ou quit :

# Importation des modules nécessaires
# Module pour interagir avec le système d'exploitation
import os
# Importation de la classe Mistral du module mistralai
from mistralai import Mistral     

# Récupération de la clé API à partir des variables d'environnement
api_key = os.environ["MISTRAL_API_KEY"]
# Définition du modèle à utiliser pour la requête
model = "mistral-small-latest"

# Création d'une instance de la classe Mistral avec la clé API
client = Mistral(api_key=api_key)

# Boucle infinie pour permettre une interaction continue avec l'utilisateur
while True:

    # Demande à l'utilisateur d'entrer un prompt
    prompt = input("\n=> Enter your prompt : ")

    # Vérifie si l'utilisateur souhaite quitter la boucle
    if prompt in ["bye", "quit"]:
        break  # Sort de la boucle

    # Envoi d'une requête de complétion de chat au modèle spécifié
    chat_response = client.chat.complete(
        model=model,                   # Spécification du modèle à utiliser
        messages=[                     # Liste des messages pour la conversation
            {
                "role": "user",        # Rôle de l'expéditeur du message (ici, l'utilisateur)
                "content": prompt,     # Contenu du message, basé sur l'entrée de l'utilisateur
            },
        ]
    )

    # Affichage de la réponse générée par le modèle
    print(chat_response.choices[0].message.content)

Je vous invite à retrouver ce petit script sur notre GitHub. Notamment pour profiter de la coloration syntaxique, mais aussi pour le réutiliser et modifier :

J’ai utilisé une boucle infinie while True pour pouvoir soumettre autant de prompt que souhaité. Si je saisis bye ou quit : je quitte cette boucle et le script prend fin. Également, j’utilise la fonction input() pour demander à l’utilisateur de saisir son prompt de manière interactive dans le terminal. Le reste des instructions concernant la définition du modèle, de la clé API et des fonctions propres au module mistralai sont les mêmes que précédemment.

Voici un exemple d’utilisation de ce second script : 

C’est déjà plus intéressant. J’ai ici posé deux questions consécutives et de manière interactive. Mais, attention, il ne s’agit pas d’une conversation. On voit notamment que quand je pose la question “et celle de la statue de la Liberté”, le modèle ne comprend pas que je parle de sa taille. On peut en conclure qu’il ne garde pas en mémoire ma conversation. Cela signifie que, par défaut, l'API ne conserve pas l'état ou le contexte de la conversation entre les appels.

Il est possible de rappeler à l’API l’historique de la conversation pour qu’elle puisse l’utiliser, mais c’est un peu plus complexe est hors du périmètre de ce tutoriel introductif sur l’API de Mistral AI.

Cela permet d’avoir un échange qui ressemble presque à celui sur l’interface web classique, mais dans notre terminal.

Dernier exemple de script pour la route, l’utilisation en “one-shot” avec le passage de notre prompt dans un paramètre, ce qui permet une utilisation directe et sans aller-retour :

# Importation des modules nécessaires
# Module pour interagir avec le système d'exploitation
import os
# Importation de la classe Mistral du module mistralai
from mistralai import Mistral
# Module pour analyser les arguments de la ligne de commande
import argparse

def main(args) -> None:
    """
    Fonction principale qui utilise l'API de Mistral AI pour générer une réponse
    à partir d'un prompt fourni en argument.
    """

    # Récupération de la clé API à partir des variables d'environnement
    api_key = os.environ["MISTRAL_API_KEY"]
    # Définition du modèle à utiliser pour la requête
    model = "mistral-small-latest"

    # Création d'une instance de la classe Mistral avec la clé API
    client = Mistral(api_key=api_key)

    # Boucle infinie pour permettre une interaction continue avec l'utilisateur
    while True:
        # Envoi d'une requête de complétion de chat au modèle spécifié
        chat_response = client.chat.complete(
            model=model,                   # Spécification du modèle à utiliser
            messages=[                     # Liste des messages pour la conversation
                {
                    "role": "user",       # Rôle de l'expéditeur du message (ici, l'utilisateur)
                    "content": args.prompt, # Contenu du message, basé sur l'argument fourni
                },
            ]
        )
        # Affichage de la réponse générée par le modèle
        print(chat_response.choices[0].message.content)

if __name__ == '__main__':
    # Création du parseur d'arguments pour la ligne de commande
    parser = argparse.ArgumentParser(prog='mistral-params')
    # Ajout d'un argument pour le prompt avec une aide et une exigence de saisie
    parser.add_argument("-p", '--prompt', help='Your prompt, between quotes if you have space', required=True)
    # Analyse des arguments fournis en ligne de commande
    args = parser.parse_args()
    # Appel de la fonction principale avec les arguments analysés
    main(args)

Je vous invite à retrouver ce script sur notre espace GitHub. Notamment pour profiter de la coloration syntaxique, mais aussi pour le réutiliser et modifier :

J’utilise ici le module argparse pour gérer le paramètre -p ou –prompt qui sera inséré dans ma liste de messages. À nouveau, voici un exemple d’utilisation : 

En quelques lignes, nous parvenons à envoyer notre prompt aux services Mistral AI via leur API, puis à récupérer une réponse. Cela ouvre la possibilité à de très nombreux cas d’usage et d’automatisation, bien plus avancé que via une interface web !

C. Pour aller plus loin

Les plus observateurs auront remarqué que le modèle utilisé entre mon premier script et les suivants a changé, je suis passé de mistral-large-latest à mistral-small-latest. Via l’API, nous avons effectivement accès à de nombreux modèles, plus ou moins rapides, complets, performants ou optimisés.

La liste des modèles disponibles est accessible sur cette page de la documentation : docs.mistral.ai/getting-started/models/models_overview/

Pour sélectionner un modèle, utilisez son nom, indiqué dans la colonne “API Endpoints”. Le choix d’un modèle en fonction des tâches à réaliser requiert de bonnes connaissances concernant le fonctionnement des intelligences artificielles, ce n’est pas un sujet que nous allons traiter dans cet article, mais je vous invite à être curieux ! 

Nous n’avons dans cet article bien sûr fait qu’effleurer l’utilisation de l’API Mistral. Bien d’autres méthodes et capacités sont utilisables via du code et l’API. Je pense notamment à la génération de code, la modération, la visualisation (via le modèle Pixtral 12B), l’utilisation d’agent, du RAG, etc. Concernant ces différents sujets, parcourir la documentation de Mistral AI vous permettra d’avoir un aperçu de tout ce qu’il est possible de faire, et avec des exemples de codes ! 

• Documentation de Mistral AI

Nous ne nous sommes pas vraiment attardés sur la notion de rôle que nous avons utilisé dans nos scripts ("role": "user"), mais il s’agit là aussi d’un point intéressant à creuser. Cet attribut permet de spécifier le rôle de celui qui envoie le message, on peut y insérer les valeurs user, system ou assistant et le contenu qu’on indique dans le message associé peut alors avoir une importance et un impact tout autre sur la conversation (une instruction du rôle system ne peut être contournée par celle d’un rôle user par exemple).

Enfin, j’ai évoqué la possibilité d’envoyer à l’API le contenu de notre historique de conversation pour que le modèle la prenne en compte dans ses prochaines réponses. Cela se fait à l’aide de la liste de messages, et c’est d’ailleurs pour cela qu’il s’agit d’une liste. Les questions envoyées et les réponses reçues sont ajoutées à la conversation, que l’on maintient donc côté client et que l’on renvoie à chaque nouvel appel à l’API. Je vous invite à tester cela par vous-même ! Il s’agit de la prochaine étape logique pour améliorer nos premiers scripts. 

Dans ce contexte des conversations, le rôle “assistant” permet d’ailleurs d’indiquer que la réponse provient du modèle lui-même.

IV. Conclusion

Cette première rencontre avec l’API de Mistral, en version gratuite, se termine ici. Il faut retenir que cette utilisation est très simple et rapide, tout en permettant de faire des choses plus complexes avec souscription. La documentation est claire et assez complète et les premiers tests très convaincants.

Pour ma part, je ne suis pas encore passé à la version payante, car je souhaite faire le tour des capacités des modèles gratuits avant. Mais, je dois dire que le service Mistral AI est intéressant et l’utilisation de l’API est très sympathique, surtout car on peut commencer à expérimenter gratuitement.

Pour continuer sur la thématique de l’IA générative et des LLM, consultez nos nombreux articles et tutoriels à ce sujet : 

• IT-Connect - Articles et tutoriels IA générative/LLM

N’hésitez pas à partager vos expériences et avis avec nous dans les commentaires ou sur notre serveur Discord. Notamment si vous avez déjà pu expérimenter l’API en version payante ou des cas d’utilisations plus avancés que ceux présentés ici.