Aller au contenu principal

Utiliser une IA avec Python

Comprendre comment interroger une IA, via une API REST, avec Python

Notions théoriques​

Une API, c'est quoi ?​

Python, c'est quoi ?​

API et intelligence artificielle​

Une API (Application Programming Interface) est un ensemble de règles qui permet à 2 logiciels de communiquer entre eux.

info

L’IA utilisée ici est de type LLM (Large Language Model), un modèle de traitement du langage naturel entraîné à comprendre et générer du texte.

L’API permet d’envoyer une requête à un modèle d’IA et de recevoir une réponse générée automatiquement.

Quelle API utiliser ?​

Nous allons utiliser OpenRouter, une alternative gratuite à OpenAI.

OpenRouter est une plateforme qui permet d’accéder à plusieurs modèles d'IA à travers une API unique :

  • OpenRouter est gratuit dans sa version de base
  • OpenRouter fonctionne avec une clé API que vous pouvez obtenir facilement
  • OpenRouter permet d’accéder à des modèles de fournisseurs populaires tels que OpenAI, Google, Mistral, etc.

    OpenRouter propose par exemple Mistral 7B Instruct, qui est très performants et gratuits à utiliser.

https://openrouter.ai/

astuce

Avec OpenRouter, vous n'avez pas besoin de créer un compte et une configuration spécifique pour chaque fournisseur d'IA.

OpenRouter joue un rôle d’intermédiaire entre les développeurs et les différents fournisseurs de modèles d’IA (comme OpenAI, Anthropic, Mistral, Cohere, etc.).

Comment fonctionne l’API OpenRouter ?​

L’API d’OpenRouter fonctionne comme celle d’OpenAI :

  • Vous envoyez un prompt (texte d’instruction)
  • Vous recevez une réponse générée par l’IA
remarque

Voici la liste des modèles de génération de textes, gratuits, à faibles latences, disponibles sur OpenRouter :

https://openrouter.ai/models?fmt=cards&input_modalities=text&max_price=0&output_modalities=text&order=latency-low-to-high

Quelques exemples de modèles gratuits er rapides disponibles :

  • arcee-ai/trinity-mini:free
  • nvidia/nemotron-3-nano-30b-a3b:free
  • google/gemma-3n-e2b-it:free

Pourquoi utiliser Python ?​

Python est un langage simple, lisible, et très utilisé dans le domaine de l’IA.

Python permet d’envoyer des requêtes HTTP facilement, de traiter les réponses, et de construire rapidement des scripts pour interagir avec des modèles d’IA.

Fonctionnement général​

Voici les grandes étapes pour utiliser OpenRouter avec Python :

  1. S’inscrire sur https://openrouter.ai pour obtenir une clé API (token ou jeton en français).
  2. Choisir un modèle (par exemple : openai/gpt-3.5-turbo, mistralai/mistral-7b-instruct…).
  3. Envoyer une requête POST en JSON (avec le token et la question) à l’URL de l’API.
  4. Lire la réponse et l’utiliser dans le programme.
info

OpenRouter est compatible avec la spécification de l’API d’OpenAI (https://platform.openai.com/docs/api-reference).

Format d’une requête à l’API​

L’URL de l’API est :

https://openrouter.ai/api/v1/chat/completions

Le corps de la requête est un objet JSON contenant :

  • model : le nom du modèle à utiliser
  • messages : une liste de messages simulant une conversation (avec les rôles system, user, assistant)
  • temperature : un paramètre pour ajuster la créativité de la réponse

Exemple de corps JSON :

{
  "model": "openai/gpt-3.5",
  "messages": [
    {"role": "user", "content": "Quelle différence majeure existe entre un virus et un cheval de Troie ?"}
  ],
  "temperature": 0.7
}

Gestion de la clé API​

La clé API est une chaîne secrète qui doit être transmise dans l’en-tête HTTP Authorization :

Authorization: Bearer VOTRE_CLE_API
attention

Ne jamais publier une clé API sur Internet ou dans un dépôt public.

Avantages de l’API OpenRouter​

  • Accès unifié à plusieurs modèles
  • Facilité d’utilisation avec Python
  • Gratuit ou coût réduit selon le modèle choisi
  • Documentation claire et rapide à prendre en main

Exemple pratique​

Il est possible de créer un petit script Python qui envoie une question à un modèle d’IA via OpenRouter et affiche la réponse.

Voici un exemple complet :

import requests
import json

# Clé API personnelle (à remplacer par la vôtre)
API_KEY = "sk-xxxxxxxxxxxxxxxxxxxxxxxx"

# En-têtes HTTP
headers = {
    "Authorization": f"Bearer {API_KEY}",
    "Content-Type": "application/json"
}

# Corps de la requête
data = {
    "model": "openai/gpt-3.5",
    "messages": [
        {"role": "user", "content": "Quelle différence majeure existe entre un virus et un cheval de Troie ?"}
    ],
    "temperature": 0.7
}

# Envoi de la requête
response = requests.post(
    "https://openrouter.ai/api/v1/chat/completions",
    headers=headers,
    data=json.dumps(data)
)

# Affichage de la réponse
if response.status_code == 200:
    result = response.json()
    print("Réponse de l'IA :")
    print(result["choices"][0]["message"]["content"])
else:
    print("Erreur :", response.status_code)
    print(response.text)

Ce script permet :

  • d’envoyer une question à l’IA
  • de recevoir une réponse textuelle
  • de comprendre comment structurer les requêtes
Explications détaillées du code

1. Importation des bibliothèques​

import requests
import json
  • import requests : Cette ligne importe la bibliothèque externe requests. C'est un outil très populaire en Python pour effectuer des requêtes HTTP (demander des informations à un serveur web, comme on le fait avec un navigateur, mais ici de manière programmatique).
  • import json : Cette ligne importe la bibliothèque standard json. Elle sert à convertir des objets Python (comme des dictionnaires) en format texte JSON (que les API comprennent) et inversement.

2. Configuration de l'authentification​

# Clé API personnelle (à remplacer par la vôtre)
API_KEY = "sk-xxxxxxxxxxxxxxxxxxxxxxxx"
  • API_KEY = ... : On définit une variable qui contient la "clé API". C'est un mot de passe technique qui prouve au serveur que vous êtes autorisé à utiliser le service.
    • Note : La valeur "sk-..." est une fausse clé. Pour que le code fonctionne réellement, il faut la remplacer par une vraie clé valide.

3. En-têtes HTTP (Headers)​

# En-têtes HTTP
headers = {
    "Authorization": f"Bearer {API_KEY}",
    "Content-Type": "application/json"
}
  • headers = {...} : On crée un dictionnaire Python pour contenir les métadonnées de la requête.
  • "Authorization": f"Bearer {API_KEY}" : Cette ligne dit au serveur "C'est moi et voici ma preuve".
    • f"..." : C'est une f-string (chaîne formatée pour l'interpolation) en Python, qui permet d'insérer la variable API_KEY directement à l'intérieur du texte.
    • Bearer : Un standard de sécurité qui indique que la clé qui suit est un jeton d'accès (Bearer se traduit par Porteur en français).
  • "Content-Type": "application/json" : On informe le serveur que les données qu'on lui envoie (le corps de la requête) sont au format JSON.

4. Préparation des données (Payload)​

# Corps de la requête
data = {
    "model": "openai/gpt-3.5",
    "messages": [
        {"role": "user", "content": "Quelle différence majeure existe entre un virus et un cheval de Troie ?"}
    ],
    "temperature": 0.7
}
  • data = {...} : Ce dictionnaire contient les instructions et le contenu de ce qu'on envoie à l'IA.
  • "model": "openai/gpt-3.5" : On précise quel model d'IA utiliser. Ici, on demande au serveur OpenRouter de nous connecter au modèle GPT-3.5 d'OpenAI.
  • "messages": [...] : C'est la liste des messages de la conversation.
    • "role": "user" : Indique que c'est l'utilisateur humain qui parle.
    • "content": "..." : C'est la question ou la consigne texte.
  • "temperature": 0.7 : Ce paramètre contrôle la "créativité" de l'IA.
    • 0.0 = Réponses très rigides et déterministes.
    • 1.0 = Réponses très aléatoires et créatives.
    • 0.7 est un bon équilibre pour du texte naturel.

5. Envoi de la requête​

# Envoi de la requête
response = requests.post(
    "https://openrouter.ai/api/v1/chat/completions",
    headers=headers,
    data=json.dumps(data)
)
  • requests.post(...) : Le verbe POST est utilisé en HTTP pour envoyer des données complexes au serveur dans le corps de la requête (le payload), contrairement au verbe GET qui peut envoyer des paramètres simples mais sert principalement à récupérer des ressources avec des paramètres qui transitent de manière visible dans l'URL.
  • "https://..." : L'URL (adresse web) du point de terminaison (endpoint) de l'API. C'est la "boîte aux lettres" où on dépose notre demande.
  • headers=headers : On attache les en-têtes (authentification, format) définis plus haut.
  • data=json.dumps(data) :
    • data (notre dictionnaire Python) ne peut pas être envoyé tel quel sur le réseau.
    • json.dumps(data) transforme ce dictionnaire en une chaîne de caractères texte au format JSON.
    • Le résultat est stocké dans la variable response, qui contiendra la réponse du serveur.

6. Traitement de la réponse​

# Affichage de la réponse
if response.status_code == 200:
  • response.status_code : Tout serveur HTTP renvoie un code numérique pour dire si ça a marché.
    • 200 signifie "OK" (Succès).
    • 401 signifie "Non autorisé" (Mauvaise clé API).
    • 500 signifie "Erreur serveur".
  • Cette ligne vérifie donc : "Si tout s'est bien passé...".
    result = response.json()
    print("Réponse de l'IA :")
    print(result["choices"][0]["message"]["content"])
  • result = response.json() : Le serveur nous a renvoyé du texte JSON. Cette fonction le convertit à nouveau en dictionnaire Python exploitable.
  • print("Réponse de l'IA :") : Affiche simplement une légende dans la console.
  • result["choices"][0]["message"]["content"] : C'est ici qu'on va chercher le texte précis généré par l'IA. Les réponses des API modernes sont structurées ainsi :
    • choices : Une liste de réponses possibles (généralement une seule).
    • [0] : On prend le premier élément de la liste.
    • message : L'objet contenant le message.
    • content : Le texte brut de la réponse.
else:
    print("Erreur :", response.status_code)
    print(response.text)
  • else : Si le code de statut n'était pas 200 (donc qu'il y a une erreur).
  • print(...) : On affiche le code d'erreur.
  • print(response.text) : On affiche le contenu brut de la réponse du serveur, qui contient souvent un message explicatif sur l'origine du problème (ex: "Invalid API Key").
astuce

Il est recommandé d’utiliser une bibliothèque comme python-dotenv pour stocker la clé API dans un fichier .env et éviter de l’écrire en dur dans le code.

Test de mémorisation/compréhension​


Quel est le rôle principal d’OpenRouter ?


Quel est le format des messages envoyés à l’API ?


Quel rôle est utilisé pour envoyer une question dans une conversation ?


Quelle bibliothèque Python est utilisée pour envoyer une requête HTTP ?


Quel en-tête HTTP contient la clé API ?


Quelle URL permet d’envoyer une requête à OpenRouter ?


Le paramètre 'temperature' sert à :


Quel est le format attendu pour l’envoi des données dans la requête ?


Que contient la clé 'choices' dans la réponse JSON ?


Quel est le rôle du champ 'model' dans la requête ?


Pourquoi utilise-t-on la fonction `json.dumps(data)` lors de l'envoi de la requête ?


Quel est le rôle précis de l'en-tête HTTP `'Content-Type': 'application/json'` ?


Quelle est la fonction principale de la bibliothèque `requests` importée dans ce script ?


Pour extraire le texte de la réponse de l'IA, on utilise la syntaxe `result["choices"][0]["message"]["content"]`. À quoi correspond l'index `[0]` ?


Concernant l'en-tête d'authorisation, quelle est la bonne formulation pour la valeur associée à la clé 'Authorization' ?


Dans le dictionnaire `data`, que signifie la paire clé-valeur `'role': 'user'` ?


Dans le bloc de gestion d'erreur (`else`), quelle instruction permet d'obtenir des détails sur l'origine du problème depuis le serveur ?


Pourquoi utilise-t-on `requests.post` et non pas `requests.get` ?


TP pour réfléchir et résoudre des problèmes​

Préparation​

  1. Créer un compte sur OpenRouter : https://openrouter.ai/
  2. Obtenir une clé API (token) depuis la page des paramètres : https://openrouter.ai/settings/keys

  1. Installer Python 3.x sur votre machine si ce n’est pas déjà fait : https://www.python.org/downloads/
  2. Installer un éditeur de code (par exemple : VSCode)
  3. Installer les bibliothèques Python nécessaires : requests et python-dotenv
pip install requests python-dotenv

Étape 1 : Créer un environnement de travail propre​

  1. Dans le dossier Documents, créer un nouveau dossier nommé tp_openrouter.
  2. Initialiser un projet Python dans ce dossier.
  3. Créer un fichier main.py.
  4. Créer un fichier .env pour stocker la clé API.
  5. Installer les bibliothèques nécessaires (requests et python-dotenv).
Une solution

Étape 2 : Charger la clé API depuis le fichier .env​

  1. Modifier le fichier main.py pour lire la clé API depuis le fichier .env à l’aide de python-dotenv.
Une solution

Exécuter le script pour vérifier que la clé est bien chargée :

python main.py

Étape 3 : Construire le corps de la requête à envoyer à l’API​

  1. Créer un dictionnaire Python nommé data contenant :
    • le modèle arcee-ai/trinity-mini:free ou nvidia/nemotron-3-nano-30b-a3b:free ou google/gemma-3n-e2b-it:free
    • un message de type user avec une question libre (ex. : "Quelle différence majeure existe entre un virus et un cheval de Troie ?")
    • une température de 0.7
Une solution

Étape 4 : Préparer les en-têtes HTTP de la requête​

  1. Créer un dictionnaire headers contenant :
    • l’en-tête Authorization avec la clé API
    • l’en-tête Content-Type avec la valeur application/json
Une solution

Étape 5 : Envoyer la requête POST à l’API OpenRouter​

  1. Envoyer une requête HTTP POST à l’URL https://openrouter.ai/api/v1/chat/completions
  2. Utiliser la bibliothèque requests pour envoyer cette requête avec les en-têtes et le corps JSON
  3. Stocker la réponse dans une variable response
Une solution

Étape 6 : Analyser la réponse de l’API​

  1. Vérifier que le code de réponse HTTP est 200
  2. Extraire le contenu généré par l’IA
  3. Afficher ce contenu dans la console
Une solution

Exécuter le script pour vérifier que tout fonctionne toujours et afficher la réponse de l’IA :

python main.py

Étape 7 : Tester avec plusieurs questions​

  1. Modifier le contenu du message pour poser trois questions différentes à l’IA
  2. Exécuter le programme à chaque fois et observer les réponses
Une solution

Exécuter le script pour vérifier que tout fonctionne toujours et poser chaque question :

python main.py

Étape 8 : Ajouter une saisie utilisateur pour interagir avec l’IA​

  1. Modifier le script pour que l’utilisateur puisse taper sa question dans le terminal
  2. Utiliser input() pour lire la question
  3. Injecter cette question dans data["messages"]
Une solution

Exécuter le script pour vérifier que tout fonctionne toujours et poser une question personnalisée :

python main.py

Étape 9 : Ajouter une boucle pour poser plusieurs questions à la suite​

  1. Ajouter une boucle while qui permet à l’utilisateur de poser plusieurs questions
  2. Quitter la boucle si l’utilisateur tape exit ou quit
Une solution

Exécuter le script pour vérifier que tout fonctionne toujours et poser plusieurs questions :

python main.py

Étape 10 : Enregistrer les échanges dans un fichier texte​

  1. Ajouter une fonctionnalité pour sauvegarder chaque question et réponse dans un fichier log.md
  2. Ajouter un horodatage pour chaque échange
Une solution

Exécuter le script pour vérifier que tout fonctionne toujours et enregistrer les échanges :

python main.py

TP Bonus : Résumer un texte avec l’IA​

  1. Modifier le script pour lire un texte depuis un fichier input.txt
  2. Envoyer ce texte à l’IA en demandant un résumé
Une solution

Exécuter le script pour vérifier que tout fonctionne toujours bien et obtenir le résumé :

python main.py