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 HTTP | Objectif | Exemple dans les API d'IA |
|---|---|---|
| POST | Créer une ressource | Envoyer des requêtes de chat, générer des images |
| GET | Récupérer une ressource | Interroger les listes de modèles, obtenir des informations de facturation |
| DELETE | Supprimer une ressource | Supprimer 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 :
| Éditeur | Fonctionnalités | Utilisateurs cibles |
|---|---|---|
| VS Code | Gratuit, riche écosystème de plugins, léger | La plupart des développeurs |
| Cursor | Assistance IA intégrée, peut générer directement du code | Pour ceux qui veulent que l'IA les aide à écrire du code |
| PyCharm | Le plus riche en fonctionnalités, meilleur support de Python | Dé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
# 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
# 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ètre | Type | Requis | Description | Valeur par défaut |
|---|---|---|---|---|
| model | string | Oui | L'ID du modèle à utiliser, tel que gpt-3.5-turbo, gpt-4 | Aucune |
| messages | array | Oui | Liste des messages de l'historique de conversation | Aucune |
| temperature | nombre | non | Tempé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_tokens | entier | non | Nombre maximal de tokens à générer | Illimité |
| top_p | nombre | non | Paramètre d'échantillonnage du noyau, entre 0-1 | 1.0 |
| stop | chaîne/tableau | non | Séquence d'arrêt ; arrêter la génération lorsque ces caractères sont rencontrés | null |
Concentrons-nous sur la température, qui est le paramètre d'ajustement le plus couramment utilisé :
Exemples
# 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 comparaison | API OpenAI | API Claude |
|---|---|---|
| Structure des messages | system, user, assistant alternent | system est défini séparément, user et assistant alternent |
| Longueur du contexte | 16k-128k varie | La série Claude 3 prend en charge 200k |
| Conception des paramètres | temperature, 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
# 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
# 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
# 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
# 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
# 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égie | Avantages | Inconvénients | Scénarios applicables |
|---|---|---|---|
| Ne garder que les N entrées les plus récentes | Simple, rapide | Peut perdre des informations importantes | Conversations courtes, scénarios de chat décontracté |
| Utiliser l'IA pour résumer l'historique | Préserve les informations sémantiques | Nécessite des appels API supplémentaires | De longues conversations, de nombreuses informations importantes |
| Fenêtre glissante | Concilie simplicité et exhaustivité | Légèrement plus complexe à implémenter | Usage 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
# 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
# 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
# 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 :
| Astuce | Comment procéder | Taux d'économie |
|---|---|---|
| Choisissez le bon modèle | Utilisez gpt-3.5-turbo pour les tâches simples, pas gpt-4 | 90%+ |
| Limitez max_tokens | Définissez une limite supérieure raisonnable pour éviter que l'IA ne parle trop | Cela dépend de la situation |
| Réduisez le contexte | Ne conservez que l'historique de conversation nécessaire | 50%+ |
| Gardez les prompts concis | Ne rendez pas le prompt système trop long | Cela dépend de la situation |
| Mise en cache des résultats | Renvoyez directement les résultats mis en cache pour les questions identiques | Cela 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
# 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'erreur | Code de statut HTTP | Cause | Méthode de gestion |
|---|---|---|---|
| Échec d'authentification | 401 | Clé API incorrecte ou expirée | Vérifier la clé API |
| Quota insuffisant | 402 | Le compte n'a pas d'argent | Recharger ou changer de compte |
| Limite dépassée | 429 | Requête trop rapide ou quota épuisé | Patientez un moment et réessayez |
| Erreur serveur | 5xx | Problème côté serveur d'IA | Ré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
# 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
# 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
# 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