Développement d'API d'IA

Il est pratique d'utiliser des outils de chat IA dans une interface web, mais pour vraiment intégrer les capacités de l'IA dans vos propres produits, flux de travail et scripts d'automatisation, vous avez besoin d'une API.

Une API (interface de programmation d'application) est un pont de communication entre les applications. Grâce à une API, votre code peut envoyer directement des requêtes à un modèle d'IA et recevoir des réponses, sans avoir besoin d'ouvrir manuellement une page web et de copier-coller.

Imaginez ces scénarios :

  • Votre site e-commerce génère automatiquement un texte descriptif pour chaque produit.

  • Votre application de prise de notes résume automatiquement les longs textes saisis par les utilisateurs.

  • Votre système de service client catégorise et répond automatiquement aux demandes des utilisateurs.

  • Toutes ces fonctionnalités peuvent être implémentées via des API d'IA.

L'objectif de ce module est de vous faire passer de « pouvoir uniquement discuter avec l'IA » à « pouvoir faire fonctionner l'IA dans votre code ».


Concepts de base des API

Avant d'écrire du code, comprenez d'abord quelques concepts clés.

Qu'est-ce qu'une API

Une API est un ensemble de protocoles de communication convenus. Nous envoyons des requêtes dans un format spécifique, et l'autre partie renvoie les résultats dans un format spécifique.

Prenons l'analogie de la commande de nourriture :

  • Vous entrez dans un restaurant, consultez le menu (documentation de l'API) et savez ce que vous pouvez commander et comment le commander (format de requête).

  • Vous dites au serveur : « Un poulet Kung Pao, moins épicé » (envoi d'une requête API).

  • La cuisine prépare le plat et vous l'apporte (retour de la réponse API).

Dans ce processus, vous n'avez pas besoin d'entrer dans la cuisine, et vous n'avez pas besoin de savoir comment le plat est préparé—c'est la valeur d'une API:Encapsuler les détails complexes, n'exposer qu'une interface simple。

Fondamentaux des API REST

REST (Representational State Transfer) est actuellement le style de conception d'API le plus populaire.

En termes simples, il utilise le protocole HTTP pour la communication :

Méthode HTTPObjectifExemple dans les API d'IA
POSTCréer une ressourceEnvoyer des requêtes de chat, générer des images
GETRécupérer une ressourceInterroger les listes de modèles, obtenir des informations de facturation
DELETESupprimer une ressourceSupprimer l'historique des conversations

La grande majorité des API d'IA utilisent des requêtes POST, car nous devons « envoyer du contenu à l'IA pour traitement ».

Bases du format JSON

JSON (JavaScript Object Notation) est le format de données le plus couramment utilisé dans la communication avec les API.

La syntaxe de JSON est très simple ; c'est une combinaison de paires clé-valeur.

Exemples

{
    "model": "gpt-4",
    "messages": [
        {
            "role": "user",
            "content": "Bonjour, veuillez présenter EXAMPLE"
        }
    ],
    "temperature": 0.7,
    "max_tokens": 1000
}

Ceci est un corps de requête typique d'une API d'IA.

Quelques règles essentielles :

  • Pour les objets, utilisez{ }pour les encadrer, pour les tableaux utilisez[ ]pour les encadrer.

  • Les chaînes de caractères utilisent des guillemets doubles", on ne peut pas utiliser de guillemets simples.

  • Les paires clé-valeur utilisent un deux-points:pour séparer, les clés doivent être des chaînes de caractères.

  • Plusieurs paires clé-valeur utilisent une virgule,pour séparer.

JSON ressemble beaucoup aux dictionnaires Python, mais il y a des différences syntaxiques ; faites attention lorsque vous écrivez du code.


Configuration de l'environnement de développement

Pour faire du bon travail, il faut d'abord aiguiser ses outils.

Installation et configuration de Python

Python est le langage le plus couramment utilisé pour appeler des API d'IA, avec un écosystème mature et des bibliothèques riches.

Tout d'abord, vérifiez si Python est installé sur votre ordinateur :

# 检查 Python 版本(Windows、macOS、Linux 通用)
python --version
# 或者
python3 --version

Il est recommandé d'utiliser Python 3.9 ou une version supérieure.

Si ce n'est pas installé, rendez-vous surpython.orgTéléchargez la dernière version stable.

Gestion des paquets pip

pip est le gestionnaire de paquets de Python, utilisé pour installer des bibliothèques tierces.

# 检查 pip 版本
pip --version
# 或者
pip3 --version

# 升级 pip 到最新版本
pip install --upgrade pip

# 配置国内镜像源(可选,提升下载速度)
pip config set global.index-url https://pypi.tuna.tsinghua.edu.cn/simple

Sélection de l'éditeur de code

Pour écrire du code d'API IA, nous recommandons l'un des éditeurs suivants :

ÉditeurFonctionnalitésUtilisateurs cibles
VS CodeGratuit, riche écosystème de plugins, légerLa plupart des développeurs
CursorAssistance IA intégrée, peut générer directement du codePour ceux qui veulent que l'IA les aide à écrire du code
PyCharmLe plus riche en fonctionnalités, meilleur support de PythonDéveloppeurs Python professionnels

Le code d'exemple de ce tutoriel peut s'exécuter dans n'importe quel éditeur.


Bases de l'API OpenAI

L'API OpenAI est l'API d'IA la plus classique et la mieux établie, et de nombreux autres fournisseurs sont compatibles avec son format.

Inscription et obtention d'une clé API

La clé API est votre laissez-passer, elle prouve votre identité et enregistre votre utilisation. Étapes pour en obtenir une :

  • 1. Visitezplatform.openai.comCréez un compte

  • 2. Accédez à la page des clés API

  • 3. Cliquez sur « Créer une nouvelle clé secrète »

  • 4. Copiez et enregistrez cette clé (elle n'est affichée qu'une seule fois !)

Important :Ne committez jamais votre clé API dans un dépôt de code public. En cas de fuite, d'autres personnes peuvent utiliser votre quota et entraîner des frais.

Premier appel à l'API

Tout d'abord, installez le SDK OpenAI officiel :

pip install openai

Maintenant, écrivez votre premier programme d'appel à l'API :

Exemples

# Chemin du fichier : first_api_call.py
# Premier exemple d'appel à l'API OpenAI

from openai import OpenAI

# Initialiser le client
# Remarque : Il est recommandé de lire la clé API à partir des variables d'environnement ; ne la codez pas en dur dans le code
# À des fins de démonstration, elle est écrite directement ici. Dans de vrais projets, utilisez des variables d'environnement.
client = OpenAI(
    api_key="your-api-key-here"  # Remplacez par votre clé API
)

# Envoyer une requête de chat
response = client.chat.completions.create(
    model="gpt-3.5-turbo",  # Sélectionnez le modèle
    messages=[
        {
            "role": "user",  # Rôle : user représente l'utilisateur
            "content": "Veuillez présenter le Rookie Tutorial d'EXAMPLE en une phrase."  # Contenu saisi par l'utilisateur
        }
    ]
)

# Afficher la réponse complète (voir ce qui a été renvoyé)
print("Réponse complète :")
print(response)
print("\n" + "="*50 + "\n")

# Extraire la réponse de l'IA
ai_reply = response.choices[0].message.content
print("Réponse de l'IA :")
print(ai_reply)

Si vous n'avez pas d'api_key OpenAI, vous pouvez aussi utiliser des alternatives locales. De nombreux modèles locaux sont compatibles avec OpenAI, comme DeepSeek. Vous pouvez vous rendre surhttps://platform.deepseek.com/api_keysdemandez une api_key puis remplacez la vôtre par le code suivantapi_keyetmodel, DeepSeek prend en charge les modèles deepseek-v4-flash et deepseek-v4-pro (mode réflexion), et vous pouvez utiliser l'API pour appeler de grands modèles :

Exemples

from openai import OpenAI

# Initialiser le client
# Remarque : il est recommandé de lire la clé API à partir d'une variable d'environnement, ne la codez pas en dur dans le code
# Pour les besoins de la démonstration, elle est écrite directement ici. Dans les projets réels, veuillez utiliser des variables d'environnement
client = OpenAI(
    api_key="sk-xxxx",  # Définir l'api_key
    base_url="https://api.deepseek.com")  # Définir l'adresse de la requête


# Envoyer une requête de chat
response = client.chat.completions.create(
    model="deepseek-v4-flash",  # Sélectionner le modèle
    messages=[
        {
            "role": "user",  # Rôle : user représente l'utilisateur
            "content": "Veuillez présenter le Rookie Tutorial d'EXAMPLE en une phrase."  # Contenu saisi par l'utilisateur
        }
    ]
)

# Afficher la réponse complète (voir ce qui a été renvoyé)
print("Réponse complète :")
print(response)
print("\n" + "="*50 + "\n")

# Extraire la réponse de l'IA
ai_reply = response.choices[0].message.content
print("Réponse de l'IA :")
print(ai_reply)

Exécutez ce programme :

python first_api_call.py

Si tout fonctionne normalement, vous verrez une sortie similaire à ceci :

完整响应:
ChatCompletion(
  id='chatcmpl-xxx',
  choices=[Choice(finish_reason='stop', index=0, message=ChatMessage(content='Example是一个专注于提供编程技术教程的学习平台...', role='assistant'))],
  model='gpt-3.5-turbo',
  usage=CompletionUsage(completion_tokens=30, prompt_tokens=18, total_tokens=48)
)

==================================================

AI 回复:
Example是一个专注于提供编程技术教程的学习平台,涵盖多种编程语言和技术领域。

Félicitations ! Vous avez appelé avec succès une API d'IA.

Explication des paramètres de requête

L'API OpenAI dispose de nombreux paramètres qui peuvent être ajustés. Voici les plus couramment utilisés :

Nom du paramètreTypeRequisDescriptionValeur par défaut
modelstringOuiL'ID du modèle à utiliser, tel que gpt-3.5-turbo, gpt-4Aucune
messagesarrayOuiListe des messages de l'historique de conversationAucune
temperaturenombrenonTempérature d'échantillonnage, entre 0 et 2. Plus elle est élevée, plus le résultat est aléatoire ; plus elle est basse, plus il est déterministe.1.0
max_tokensentiernonNombre maximal de tokens à générerIllimité
top_pnombrenonParamètre d'échantillonnage du noyau, entre 0-11.0
stopchaîne/tableaunonSéquence d'arrêt ; arrêter la génération lorsque ces caractères sont rencontrésnull

Concentrons-nous sur la température, qui est le paramètre d'ajustement le plus couramment utilisé :

Exemples

# Chemin du fichier : temperature_demo.py
# Démontrer l'effet du paramètre de température sur la sortie

from openai import OpenAI

client = OpenAI(api_key="your-api-key-here")

def ask_ai(temperature_value: float, question: str) -> str:
    """Spécifiez la température pour la question"""
    response = client.chat.completions.create(
        model="gpt-3.5-turbo",
        messages=[{"role": "user", "content": question}],
        temperature=temperature_value,
        max_tokens=200
    )
    return response.choices[0].message.content

# Posez la même question trois fois avec une température différente
question = "Donnez un slogan à EXAMPLE"

print("--- temperature=0 (le plus déterministe, les résultats sont similaires à chaque fois) ---")
print(ask_ai(0.0, question))
print("\n--- temperature=0.7 (équilibré, recommandé pour un usage quotidien) ---")
print(ask_ai(0.7, question))
print("\n--- temperature=1.8 (le plus aléatoire, les résultats varient beaucoup à chaque fois) ---")
print(ask_ai(1.8, question))

Une règle empirique:

  • temperature=0: réponses factuelles, génération de code, scénarios nécessitant des résultats précis

  • temperature=0.7: conversation quotidienne, tâches générales

  • temperature>1.0 : écriture créative, brainstorming


API Anthropic Claude

Claude est le grand modèle de langage d’Anthropic, connu pour sa sécurité et ses capacités de traitement de textes longs.

Similitudes et différences avec l’API OpenAI

Tous deux peuvent générer du texte, mais il existe quelques différences dans la philosophie de conception :

Élément de comparaisonAPI OpenAIAPI Claude
Structure des messagessystem, user, assistant alternentsystem est défini séparément, user et assistant alternent
Longueur du contexte16k-128k varieLa série Claude 3 prend en charge 200k
Conception des paramètrestemperature, top_p, etc.temperature, top_p, etc., concepts similaires

Structure de l'API Claude Messages

Installez d'abord le SDK Claude :

pip install anthropic

Appels de base à l'API Claude :

Exemples

# Chemin du fichier : claude_first_call.py
# Exemple d'appel de base à l'API Claude

import anthropic

# Initialiser le client
client = anthropic.Anthropic(
    api_key="your-api-key-here"  # Remplacez par votre clé API Claude
)

# Envoyer une requête de message
response = client.messages.create(
    model="claude-3-sonnet-20240229",  # Sélectionnez le modèle Claude
    max_tokens=1024,  # Claude nécessite que max_tokens soit défini
    messages=[
        {
            "role": "user",
            "content": "Veuillez présenter EXAMPLE Rookie Tutorial en trois phrases"
        }
    ]
)

# Afficher la réponse
print("Réponse complète :")
print(response)
print("\n" + "="*50 + "\n")

# Extraire la réponse
print("Réponse de Claude :")
print(response.content[0].text)

De même, nous pouvons le remplacer par un grand modèle compatible domestique, tel que DeepSeek, en spécifiantapi_key 、 base_url、modelCes trois paramètres :

Exemples

import anthropic

# Initialiser le client
client = anthropic.Anthropic(
    api_key="sk-xxx",  # Remplacez par votre clé API
    base_url="https://api.deepseek.com/anthropic"  # URL de base pour l'API Claude
)

# Envoyer une requête de message
response = client.messages.create(
    model="deepseek-v4-flash",  # Choisir le modèle Claude
    max_tokens=1024,  # Claude nécessite que max_tokens soit défini
    messages=[
        {
            "role": "user",
            "content": "Veuillez présenter le tutoriel EXAMPLE en trois phrases."
        }
    ]
)

# Afficher la réponse
print("Réponse complète :")
print(response)
print("\n" + "="*50 + "\n")

# Extraire la réponse
print("Réponse de Claude :")
print(response.content[0].thinking)

Paramètres du prompt système

Dans l'API Claude, le prompt système est un paramètre indépendant, qui n'est pas placé dans le tableau messages :

Exemples

# Chemin du fichier : claude_system_prompt.py
# Exemple d'utilisation du prompt système de Claude

import anthropic

client = anthropic.Anthropic(api_key="your-api-key-here")

response = client.messages.create(
    model="claude-3-sonnet-20240229",
    max_tokens=1024,
    # Le prompt système est défini ici
    system="Vous êtes un éditeur de documentation technique professionnel. Gardez des réponses concises et précises, et utilisez des listes lorsque cela est approprié.",
    messages=[
        {
            "role": "user",
            "content": "Quels points de connaissance essentiels faut-il maîtriser lors de l'apprentissage de Python ?"
        }
    ]
)

print(response.content[0].text)

Gestion des conversations multi-tours

Les conversations à un seul tour sont simples, mais les applications vraiment utiles doivent "se souvenir du contexte."

Moyens de conserver l'historique des conversations

L'approche est simple :Stockez toutes les conversations précédentes et envoyez-les à l'IA à chaque requête。

Exemples

# Chemin du fichier : multi_turn_chat.py
# Exemple de gestion de conversation multi-tours

from openai import OpenAI

client = OpenAI(api_key="your-api-key-here")

class ChatBot:
    """Un simple bot de conversation multi-tours"""

    def __init__(self, system_prompt: str = "Vous êtes un assistant serviable"):
        self.messages = []  # Utiliser une liste pour stocker l'historique de conversation
        # Ajouter d'abord le prompt système
        self.messages.append({
            "role": "system",
            "content": system_prompt
        })

    def chat(self, user_input: str) -> str:
        """Envoyer un message et obtenir une réponse"""
        # Ajouter le message de l'utilisateur à l'historique
        self.messages.append({
            "role": "user",
            "content": user_input
        })

        # Appeler l'API
        response = client.chat.completions.create(
            model="gpt-3.5-turbo",
            messages=self.messages
        )

        # Obtenir la réponse de l'IA
        ai_reply = response.choices[0].message.content

        # Ajouter aussi la réponse de l'IA à l'historique
        self.messages.append({
            "role": "assistant",
            "content": ai_reply
        })

        return ai_reply

    def get_history(self) -> list:
        """Obtenir l'historique de la conversation"""
        return self.messages


# Exemple d'utilisation
if __name__ == "__main__":
    bot = ChatBot(system_prompt="Vous êtes un assistant de programmation spécialisé dans la réponse aux questions sur EXAMPLE et Python")

    print("=== Démo de conversation multitour ===")

    # Premier tour
    r1 = bot.chat("Qu'est-ce que Python ?")
    print(Utilisateur : Qu'est-ce que Python ?)
    print("IA :", r1)
    print()

    # Deuxième tour (l'IA peut se souvenir du sujet précédent)
    r2 = bot.chat(Quelles sont ses fonctionnalités ?)
    print(Utilisateur : Quelles sont ses fonctionnalités ?)
    print("IA :", r2)
    print()

    # Troisième tour
    r3 = bot.chat(Y a-t-il des tutoriels Python sur EXAMPLE ?)
    print(Utilisateur : Y a-t-il des tutoriels Python sur EXAMPLE ?)
    print("IA :", r3)

Point clé : L'historique de conversation est une liste ordonnée, alternant strictement entre utilisateur-assistant-utilisateur-assistant. Chaque requête doit envoyer l'historique complet afin que l'IA puisse comprendre le contexte. L'historique consomme des tokens, il doit donc être nettoyé régulièrement.

Gestion du dépassement de la fenêtre de contexte

Chaque modèle a une limite de fenêtre de contexte, par exemple, gpt-3.5-turbo est de 16k, gpt-4 est de 8k ou 32k.

Lorsque l'historique de conversation est trop long, une erreur est déclenchée.

Plusieurs stratégies de gestion courantes :

Exemples

# Chemin du fichier : context_management.py
# Exemple de stratégies de gestion de la fenêtre de contexte

from openai import OpenAI

client = OpenAI(api_key="your-api-key-here")


class ChatBotWithContextLimit:
    """Robot conversationnel avec limite de contexte"""

    def __init__(self, system_prompt: str, max_messages: int = 10):
        self.system_prompt = system_prompt
        self.max_messages = max_messages  # Nombre maximal de messages à conserver
        self.messages = []

    def _trim_messages(self):
        """Tronquer la liste des messages, conserver les messages les plus récents"""
        # Toujours conserver l'invite système, puis ne conserver que les max_messages les plus récents
        if len(self.messages) > self.max_messages:
            # Conserver les N messages les plus récents
            self.messages = self.messages[-self.max_messages:]

    def chat(self, user_input: str) -> str:
        # 添加用户消息
        self.messages.append({
            "role": "user",
            "content": user_input
        })

        # 修剪历史记录
        self._trim_messages()

        # 构造完整请求(系统提示词 + 历史记录)
        full_messages = [
            {"role": "system", "content": self.system_prompt}
        ] + self.messages

        try:
            response = client.chat.completions.create(
                model="gpt-3.5-turbo",
                messages=full_messages
            )
            ai_reply = response.choices[0].message.content

            self.messages.append({
                "role": "assistant",
                "content": ai_reply
            })

            return ai_reply

        except Exception as e:
            # 如果仍然报错,可能需要更激进的裁剪
            return f"错误:{str(e)}"


# 策略 2:使用 AI 总结对话历史
def summarize_conversation(messages: list) -> str:
    """使用 AI 总结对话历史,替换原始历史记录"""
    history = "\n".join([
        f"{m['role']}: {m['content']}"
        for m in messages
    ])

    prompt = f"""Veuillez résumer la conversation suivante en un résumé concis, en conservant les informations clés :

{history_text}

Résumé : """


    response = client.chat.completions.create(
        model="gpt-3.5-turbo",
        messages=[{"role": "user", "content": prompt}],
        temperature=0
    )

    return response.choices[0].message.content


# Utiliser la stratégie de résumé
print("--- Exemple de résumé de l'historique de conversation ---")
sample_history = [
    {"role": "user", "content": "Quel est mon nom ?"},
    {"role": "assistant", "content": "Désolé, je ne connais pas votre nom. Vous pouvez me le dire."},
    {"role": "user", "content": "Je m'appelle Xiao Ming, j'apprends Python sur EXAMPLE."},
    {"role": "assistant", "content": "Bonjour Xiao Ming ! Ravi de vous rencontrer. EXAMPLE est une excellente plateforme d'apprentissage."},
    {"role": "user", "content": "Je veux apprendre les listes, peux-tu m'apprendre ?"},
    {"role": "assistant", "content": "Bien sûr ! Les listes Python sont..."},
]

summary = summarize_conversation(sample_history)
print("Résumé de la conversation :", summary)

Résumez les méthodes de gestion du contexte :

StratégieAvantagesInconvénientsScénarios applicables
Ne garder que les N entrées les plus récentesSimple, rapidePeut perdre des informations importantesConversations courtes, scénarios de chat décontracté
Utiliser l'IA pour résumer l'historiquePréserve les informations sémantiquesNécessite des appels API supplémentairesDe longues conversations, de nombreuses informations importantes
Fenêtre glissanteConcilie simplicité et exhaustivitéLégèrement plus complexe à implémenterUsage général pour les scénarios courants

Sortie en streaming

Lorsque vous discutez avec une IA sur une page web, vous voyez le texte apparaître mot par mot — c'est la sortie en streaming.

Qu'est-ce que la sortie en streaming ?

  • Mode normal : l'IA renvoie la réponse complète en une seule fois après l'avoir générée ; vous devrez peut-être attendre plusieurs secondes, voire des dizaines de secondes.

  • Mode streaming : l'IA envoie chaque jeton dès qu'il est généré, offrant une meilleure expérience utilisateur.

Techniquement, la sortie en streaming utilise le protocole SSE (Server-Sent Events), où le serveur pousse les données en continu.

Implémenter l'effet machine à écrire

Exemples

# Chemin du fichier : streaming_demo.py
# Démo de sortie en streaming (effet machine à écrire)

from openai import OpenAI

client = OpenAI(api_key="your-api-key-here")

print("=== Démo de sortie en streaming ===")
print("Q: Veuillez écrire une introduction à EXAMPLE\n")
print("A:", end="", flush=True)

# Paramètre clé : stream=True
response = client.chat.completions.create(
    model="gpt-3.5-turbo",
    messages=[
        {"role": "user", "content": "Veuillez rédiger une introduction au tutoriel EXAMPLE"}
    ],
    stream=True  # Activer la sortie en streaming
)

collected_reply = []

for chunk in response:
    # Extraire le contenu du chunk actuel
    if chunk.choices[0].delta.content:
        content = chunk.choices[0].delta.content
        print(content, end="", flush=True)  # Afficher en temps réel sans sauts de ligne
        collected_reply.append(content)

print()  # Afficher un saut de ligne à la fin
print("\n" + "="*50)
print("Réponse complète :", "".join(collected_reply))

Exécutez ce programme, et vous verrez le texte apparaître mot par mot.

L'utilisation de la sortie en flux de Claude est similaire :

Exemples

# Chemin du fichier : claude_streaming.py
# Exemple de sortie en flux de Claude

import anthropic

client = anthropic.Anthropic(api_key="your-api-key-here")

print("=== Sortie en flux de Claude ===")
print("Q : Comment apprendre à programmer ?\n")
print("A:", end="", flush=True)

with client.messages.stream(
    model="claude-3-sonnet-20240229",
    max_tokens=1024,
    messages=[{"role": "user", "content": "Comment apprendre la programmation de manière systématique ?"}]
) as stream:
    for text in stream.text_stream:
        print(text, end="", flush=True)

print()

Conseil d'expérience utilisateur : tant que le scénario n'exige pas "d'attendre le résultat complet", privilégiez la sortie en streaming. Permettre aux utilisateurs de voir la progression peut considérablement améliorer l'expérience.


Calcul et optimisation des coûts d'API

Les API d'IA sont facturées en fonction de l'utilisation ; plus vous en utilisez, plus vous dépensez.

Principes de facturation des tokens

L'API d'IA n'est pas facturée au nombre de mots ou de conversations, mais parToken,Tokenest l'unité de base du traitement de texte de l'IA.

Un token équivaut approximativement à :

  • Anglais : 0.75 mot (ou 4 lettres)

  • Chinois : 1-2 caractères chinois

Par exemple :

  • "Bonjour, le monde" — environ 3-4 tokens

  • "EXEMPLE Rookie Tutorial est génial" — environ 6-8 tokens

Mode de facturation :

Prompt tokens(你发给 AI 的) + Completion tokens(AI 返回给你的)= 总 tokens

Les différents modèles ont des prix différents, par exemple gpt-3.5-turbo est $0.0015/1k tokens de prompt, $0.002/1k tokens de complétion.

Comment contrôler les coûts de l'API

Exemples

# Chemin du fichier : cost_tracking.py
# Exemple de suivi et de contrôle des coûts de l'API

from openai import OpenAI

client = OpenAI(api_key="your-api-key-here")

# Liste des prix des modèles (exemple, pour les prix réels, veuillez consulter la documentation officielle)
# Unité : USD / 1k tokens
MODEL_PRICES = {
    "gpt-3.5-turbo": {
        "prompt": 0.0015,
        "completion": 0.002
    },
    "gpt-4": {
        "prompt": 0.03,
        "completion": 0.06
    }
}


def chat_with_cost_tracking(model: str, messages: list):
    """Discuter avec statistiques de coût"""
    response = client.chat.completions.create(
        model=model,
        messages=messages
    )

    # Obtenir l'utilisation des tokens à partir de la réponse
    usage = response.usage
    prompt_tokens = usage.prompt_tokens
    completion_tokens = usage.completion_tokens
    total_tokens = usage.total_tokens

    # Calculer le coût
    price = MODEL_PRICES.get(model, {"prompt": 0, "completion": 0})
    prompt_cost = (prompt_tokens / 1000) * price["prompt"]
    completion_cost = (completion_tokens / 1000) * price["completion"]
    total_cost = prompt_cost + completion_cost

    return {
        "reply": response.choices[0].message.content,
        "usage": {
            "prompt_tokens": prompt_tokens,
            "completion_tokens": completion_tokens,
            "total_tokens": total_tokens
        },
        "cost": {
            "prompt_cost": prompt_cost,
            "completion_cost": completion_cost,
            "total_cost": total_cost
        }
    }


# Exemple d'utilisation
if __name__ == "__main__":
    result = chat_with_cost_tracking(
        model="gpt-3.5-turbo",
        messages=[{"role": "user", "content": "Présentez Python"}]
    )

    print("Réponse de l'IA :", result["reply"])
    print()
    print("Statistiques d'utilisation :")
    print(f" Jetons d'invite : {result['usage']['prompt_tokens']}")
    print(f" Jetons de complétion : {result['usage']['completion_tokens']}")
    print(f" Jetons totaux : {result['usage']['total_tokens']}")
    print()
    print("Statistiques de coût (USD) :")
    print(f" Coût de l'invite : ${result['cost']['prompt_cost']:.6f}")
    print(f" Coût de complétion : ${result['cost']['completion_cost']:.6f}")
    print(f" Coût total : ${result['cost']['total_cost']:.6f}")

Quelques conseils pratiques pour l'optimisation des coûts :

AstuceComment procéderTaux d'économie
Choisissez le bon modèleUtilisez gpt-3.5-turbo pour les tâches simples, pas gpt-490%+
Limitez max_tokensDéfinissez une limite supérieure raisonnable pour éviter que l'IA ne parle tropCela dépend de la situation
Réduisez le contexteNe conservez que l'historique de conversation nécessaire50%+
Gardez les prompts concisNe rendez pas le prompt système trop longCela dépend de la situation
Mise en cache des résultatsRenvoyez directement les résultats mis en cache pour les questions identiquesCela dépend de la situation

Stratégies de mise en cache

Pour les questions répétées, la mise en cache des résultats peut permettre d'économiser beaucoup d'argent :

Exemples

# Chemin du fichier : response_cache.py
# Implémentation simple d'un cache de réponses

import hashlib
import json
from openai import OpenAI

client = OpenAI(api_key="your-api-key-here")


class SimpleCache:
    """Cache simple en mémoire"""

    def __init__(self):
        self.cache = {}

    def _make_key(self, model: str, messages: list) -> str:
        """Générer une clé de cache en fonction du contenu de la requête"""
        # Sérialiser les informations de clé et calculer un hachage
        key_data = {
            "model": model,
            "messages": messages
        }
        key_str = json.dumps(key_data, sort_keys=True)
        return hashlib.md5(key_str.encode()).hexdigest()

    def get(self, model: str, messages: liste):
        """Obtenir le cache"""
        key = self._make_key(model, messages)
        return self.cache.get(key)

    def set(self, model: str, messages: list, value: str):
        """Définir le cache"""
        key = self._make_key(model, messages)
        self.cache[key] = value


# Fonction de chat avec cache
cache = SimpleCache()

def chat_with_cache(model: str, messages: list):
    # Vérifier d'abord le cache
    cached = cache.get(model, messages)
    if cached:
        print("(Cache trouvé, renvoyer directement)")
        return cached

    # Cache manqué, appeler l'API
    response = client.chat.completions.create(
        model=model,
        messages=messages
    )
    reply = response.choices[0].message.content

    # Stocker dans le cache
    cache.set(model, messages, reply)

    return reply


# Test
if __name__ == "__main__":
    messages = [{"role": "user", "content": "Quel type de site web est EXAMPLE ?"}]

    print("Premier appel...")
    r1 = chat_with_cache("gpt-3.5-turbo", messages)
    print(r1)
    print()

    print("Deuxième appel (même question)...")
    r2 = chat_with_cache("gpt-3.5-turbo", messages)
    print(r2)

Gestion des erreurs et mécanismes de nouvelle tentative

Les requêtes réseau peuvent échouer à tout moment, et les API ne font pas exception. Un code robuste doit gérer divers scénarios d'exception.

Types d'erreurs courantes

Type d'erreurCode de statut HTTPCauseMéthode de gestion
Échec d'authentification401Clé API incorrecte ou expiréeVérifier la clé API
Quota insuffisant402Le compte n'a pas d'argentRecharger ou changer de compte
Limite dépassée429Requête trop rapide ou quota épuiséPatientez un moment et réessayez
Erreur serveur5xxProblème côté serveur d'IARéessayer

Nouvelle tentative avec backoff exponentiel

Lorsque vous rencontrez des erreurs transitoires (telles que 429, 5xx), la stratégie la plus courante est la nouvelle tentative avec backoff exponentiel :

  • Premier échec → attendre 1 seconde → réessayer

  • Deuxième échec → attendre 2 secondes → réessayer

  • Troisième échec → attendre 4 secondes → réessayer

  • Quatrième échec → attendre 8 secondes → réessayer

Chaque durée d'attente double, donnant au service une chance de se rétablir.

Exemples

# Chemin du fichier : error_handling.py
# Gestion des erreurs et réessai avec backoff exponentiel

import time
from openai import OpenAI, APIError, RateLimitError, APIConnectionError

client = OpenAI(api_key="your-api-key-here")


def chat_with_retry(
    model: str,
    messages: list,
    max_retries: int = 3,
    initial_wait: float = 1.0
):
    """Fonction de chat avec mécanisme de réessai"""

    retries = 0

    while retries <= max_retries:
        try:
            response = client.chat.completions.create(
                model=model,
                messages=messages
            )
            return {
                "success": True,
                "reply": response.choices[0].message.content
            }

        except RateLimitError as e:
            # Erreur de limite de débit : attendre un moment et réessayer
            retries += 1
            if retries > max_retries:
                return {
                    "success": False,
                    "error": f"Tentatives de réessai épuisées : {str(e)}"
                }
            wait_time = initial_wait * (2 ** (retries - 1))
            print(f"Limite de débit déclenchée, attente de {wait_time} secondes avant de réessayer...")
            time.sleep(wait_time)

        except APIConnectionError as e:
            # Erreur de connexion réseau : réessayer
            retries += 1
            if retries > max_retries:
                return {
                    "success": False,
                    "error": f"Échec de la connexion réseau : {str(e)}"
                }
            wait_time = initial_wait * (2 ** (retries - 1))
            print(f"Erreur réseau, attente de {wait_time} secondes avant de réessayer...")
            time.sleep(wait_time)

        except APIError as e:
            # Erreur API : réessayer selon la situation
            if e.status_code and 500 <= e.status_code < 600:
                retries += 1
                if retries > max_retries:
                    return {
                        "success": False,
                        "error": f"Erreur serveur : {str(e)}"
                    }
                wait_time = initial_wait * (2 ** (retries - 1))
                print(f"Erreur serveur, attente de {wait_time} secondes avant de réessayer...")
                time.sleep(wait_time)
            else:
                # Erreurs non-5xx, ne pas réessayer
                return {
                    "success": False,
                    "error": fErreur API : {str(e)}
                }

        except Exception as e:
            # Autres erreurs, ne pas réessayer
            return {
                "success": False,
                "error": fErreur inconnue : {str(e)}
            }


# Exemple d'utilisation
if __name__ == "__main__":
    result = chat_with_retry(
        model="gpt-3.5-turbo",
        messages=[{"role": "user", "content": "Hello, EXAMPLE"}]
    )

    if result["success"]:
        print(Succès :, result["reply"])
    else:
        print(Échec :, result["error"])

Vous pouvez également utiliser une bibliothèque existante pour simplifier la logique de réessai, comme tenacity, installez-la avec la commande suivante :

pip install tenacity

Exemples

# Chemin du fichier : tenacity_demo.py
# Utiliser la bibliothèque tenacity pour simplifier la logique de réessai

from tenacity import retry, stop_after_attempt, wait_exponential, retry_if_exception_type
from openai import OpenAI, RateLimitError, APIError

client = OpenAI(api_key="your-api-key-here")


@retry(
    stop=stop_after_attempt(3),  # Réessayer jusqu'à 3 fois
    wait=wait_exponential(multiplier=1, min=1, max=10),  # Backoff exponentiel : 1, 2, 4... jusqu'à 10 secondes
    retry=retry_if_exception_type((RateLimitError, APIError))  # Ne réessayer que sur des exceptions spécifiques
)
def chat_with_tenacity(model: str, messages: list):
    """Utiliser le décorateur tenacity pour implémenter la nouvelle tentative"""
    response = client.chat.completions.create(
        model=model,
        messages=messages
    )
    return response.choices[0].message.content


# Utilisation
try:
    reply = chat_with_tenacity(
        "gpt-3.5-turbo",
        [{"role": "user", "content": "Présentez Python"}]
    )
    print(reply)
except Exception as e:
    print(fÉchec final : {e})

Projet pratique : Outil de chat IA en ligne de commande

Maintenant, intégrons ce que nous avons appris précédemment et créons un outil de chat en ligne de commande complet.

Exemples

# Chemin du fichier : example_chatbot.py
# EXEMPLE de chatbot IA - Outil complet en ligne de commande

import sys
import json
import os
from datetime import datetime
from openai import OpenAI


class ExampleChatBot:
    """Un chatbot en ligne de commande entièrement fonctionnel"""

    def __init__(self, config_file: str = "config.json"):
        # Charger la configuration
        self.config = self._load_config(config_file)
        self.client = OpenAI(api_key=self.config["api_key"])

        # État de la conversation
        self.messages = []
        self.total_tokens = 0
        self.total_cost = 0.0

        # Initialiser le prompt système
        self._init_system_prompt()

    def _load_config(self, config_file: str) -> dict:
        """Charger le fichier de configuration"""
        default_config = {
            "api_key": "votre-clé-api-ici",
            "model": "gpt-3.5-turbo",
            "system_prompt": "Vous êtes un assistant IA utile propulsé par EXAMPLE.",
            "max_history": 20,
            "stream": True,
            "temperature": 0.7
        }

        if os.path.exists(config_file):
            with open(config_file, "r", encoding="utf-8") as f:
                user_config = json.load(f)
                default_config.update(user_config)

        return default_config

    def _save_config(self, config_file: str = "config.json"):
        """Enregistrer le fichier de configuration"""
        with open(config_file, "w", encoding="utf-8") as f:
            json.dump(self.config, f, indent=2, ensure_ascii=False)

    def _init_system_prompt(self):
        """Initialiser le prompt système"""
        self.messages = [
            {
                "role": "system",
                "content": self.config["system_prompt"]
            }
        ]

    def _trim_history(self):
        """Tronquer l'historique de conversation"""
        # Conserver le prompt système + les N conversations les plus récentes
        max_messages = self.config["max_history"]
        if len(self.messages) > max_messages + 1:
            self.messages = [self.messages[0]] + self.messages[-max_messages:]

    def chat(self, user_input: str) -> str:
        """Envoyer un message et obtenir une réponse"""
        # 添加用户消息
        self.messages.append({
            "role": "user",
            "content": user_input
        })

        # 修剪历史记录
        self._trim_history()

        if self.config["stream"]:
            return self._chat_stream()
        else:
            return self._chat_normal()

    def _chat_normal(self) -> str:
        """Mode normal (sans streaming)"""
        response = self.client.chat.completions.create(
            model=self.config["model"],
            messages=self.messages,
            temperature=self.config["temperature"]
        )

        ai_reply = response.choices[0].message.content

        # Compter l'utilisation
        if hasattr(response, "usage"):
            self.total_tokens += response.usage.total_tokens
            # Estimation approximative du coût (prix gpt-3.5-turbo)
            self.total_cost += (response.usage.total_tokens / 1000) * 0.002

        self.messages.append({
            "role": "assistant",
            "content": ai_reply
        })

        return ai_reply

    def _chat_stream(self) -> str:
        """Mode streaming"""
        response = self.client.chat.completions.create(
            model=self.config["model"],
            messages=self.messages,
            temperature=self.config["temperature"],
            stream=True
        )

        collected_chunks = []
        print("IA:", end="", flush=True)

        for chunk in response:
            if chunk.choices[0].delta.content:
                content = chunk.choices[0].delta.content
                print(content, end="", flush=True)
                collected_chunks.append(content)

        print()

        ai_reply = "".join(collected_chunks)

        self.messages.append({
            "role": "assistant",
            "content": ai_reply
        })

        # Le comptage des tokens en mode streaming nécessite un traitement supplémentaire, simplifié ici
        # Dans des projets réels, vous pouvez appeler l'API usage ou estimer
        self.total_tokens += len(ai_reply) // 2  # Estimation approximative

        return ai_reply

    def save_conversation(self, filename: str = None):
        """Enregistrer l'historique de la conversation"""
        if not filename:
            timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
            filename = f"conversation_{timestamp}.json"

        data = {
            "model": self.config["model"],
            "total_tokens": self.total_tokens,
            "estimated_cost": self.total_cost,
            "messages": self.messages,
            "saved_at": datetime.now().isoformat()
        }

        with open(filename, "w", encoding="utf-8") as f:
            json.dump(data, f, indent=2, ensure_ascii=False)

        return filename

    def clear_history(self):
        """Effacer l'historique de conversation"""
        self._init_system_prompt()
        self.total_tokens = 0
        self.total_cost = 0.0

    def show_stats(self):
        """Afficher les statistiques"""
        print("\n" + "="*40)
        print(Statistiques de la conversation)
        print("="*40)
        print(fModèle : {self.config['model']})
        print(fNombre de messages : {len(self.messages) - 1})
        print(fTotal des jetons : {self.total_tokens})
        print(fCoût estimé : ${self.total_cost:.4f})
        print("="*40 + "\n")


def print_help():
    """Afficher les informations d'aide"""
    print("\n" + "="*40)
    print(EXEMPLE Outil de chat IA - Liste des commandes)
    print("="*40)
    print(/help - Afficher l'aide)
    print(/clear - Effacer l'historique de la conversation)
    print(/stats - Afficher les statistiques)
    print(/save - Enregistrer l'historique de conversation)
    print(/model - Changer de modèle)
    print(/temp - Ajuster la température)
    print(/system - Modifier le prompt système)
    print(/quit - Quitter le programme)
    print("="*40 + "\n")


def main():
    print("="*40)
    print(EXEMPLE D'OUTIL DE CHAT IA)
    print("="*40)
    print(Entrez /help pour afficher les commandes, ou saisissez du texte directement pour commencer à discuter\n")

    bot = ExampleChatBot()

    while True:
        try:
            user_input = input(Vous :).strip()

            if not user_input:
                continue

            # Gérer les commandes
            if user_input.startswith("/"):
                cmd = user_input.lower()

                if cmd in ["/quit", "/exit", "/q"]:
                    print(Au revoir !)
                    break

                elif cmd == "/help":
                    print_help()

                elif cmd == "/clear":
                    bot.clear_history()
                    print(Historique de conversation effacé)

                elif cmd == "/stats":
                    bot.show_stats()

                elif cmd == "/save":
                    filename = bot.save_conversation()
                    print(fConversation enregistrée dans : {filename})

                elif cmd.startswith("/model "):
                    model = user_input[7:].strip()
                    bot.config["model"] = model
                    bot._save_config()
                    print(fModèle basculé vers : {model})

                elif cmd.startswith("/temp "):
                    try:
                        temp = float(user_input[6:].strip())
                        if 0 <= temp <= 2:
                            bot.config["temperature"] = temp
                            bot._save_config()
                            print(fTempérature définie sur : {temp})
                        else:
                            print(La température doit être comprise entre 0-2)
                    except ValueError:
                        print(Veuillez saisir un nombre valide)

                elif cmd.startswith("/system "):
                    system_prompt = user_input[8:].strip()
                    bot.config["system_prompt"] = system_prompt
                    bot.clear_history()
                    bot._save_config()
                    print(Prompt système mis à jour, conversation réinitialisée)

                else:
                    print(Commande inconnue, saisissez /help pour obtenir de l'aide)

            else:
                # Discussion normale
                if not bot.config["stream"]:
                    print("IA:", end="")

                bot.chat(user_input)
                print()

        except KeyboardInterrupt:
            print("\nEntrez /quit pour quitter, ou continuez à discuter)

        except Exception as e:
            print(fErreur : {e})


if __name__ == "__main__":
    main()

Créez un fichier de configuration :

{
    "api_key": "your-api-key-here",
    "model": "gpt-3.5-turbo",
    "system_prompt": "你是一个乐于助人的 AI 助手,由 EXAMPLE 提供技术支持。",
    "max_history": 20,
    "stream": true,
    "temperature": 0.7
}

Vous pouvez maintenant exécuter cet outil de chat :

python example_chatbot.py

Vous verrez :

========================================
  EXAMPLE AI 聊天工具
========================================
输入 /help 查看命令,直接输入文字开始聊天

你:你好
AI:你好!很高兴见到你。我是由 EXAMPLE 提供技术支持的 AI 助手,有什么可以帮你的吗?

你:/stats

========================================
对话统计
========================================
模型:gpt-3.5-turbo
消息数:2
总 tokens:50
估算费用:$0.0001
========================================

你:/quit
再见!
Autres extensions