Créer son premier chatbot IA avec Python et l’API OpenAI — Guide complet 2026

# Vérifier la version de Python installée
python3 --version

# Sur Windows, essayez aussi :
python --version

# Installer Homebrew si ce n'est pas déjà fait
/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"

# Installer Python 3.13
brew install python@3.13

# Mettre à jour les paquets
sudo apt update && sudo apt upgrade -y

# Installer Python 3.13 et pip
sudo apt install python3.13 python3.13-venv python3-pip -y

# Créer un dossier pour votre projet
mkdir mon-chatbot-ia
cd mon-chatbot-ia

# Créer l'environnement virtuel (nommé "venv")
python3 -m venv venv

# Activer l'environnement virtuel
# Sur macOS/Linux :
source venv/bin/activate

# Sur Windows (PowerShell) :
.\venv\Scripts\Activate.ps1

# Vous devriez voir (venv) au début de votre prompt
# Exemple : (venv) user@machine:~/mon-chatbot-ia$

# Installer le SDK OpenAI (dernière version)
pip install openai

# Vérifier l'installation
pip show openai

# Créer un fichier requirements.txt pour la reproductibilité
pip freeze > requirements.txt

# Sur macOS/Linux - ajoutez à votre ~/.bashrc ou ~/.zshrc
export OPENAI_API_KEY="sk-votre-cle-api-ici"

# Recharger la configuration
source ~/.bashrc  # ou source ~/.zshrc

# Sur Windows (PowerShell)
$env:OPENAI_API_KEY = "sk-votre-cle-api-ici"

# Alternative : créer un fichier .env (nécessite python-dotenv)
echo "OPENAI_API_KEY=sk-votre-cle-api-ici" > .env

pip install python-dotenv

"""
chatbot.py - Premier appel à l'API OpenAI
Auteur : Votre nom
Date : Février 2026
"""

import os
from openai import OpenAI
from dotenv import load_dotenv

# Charger les variables d'environnement depuis le fichier .env
load_dotenv()

# Créer le client OpenAI
# Le SDK cherche automatiquement la variable OPENAI_API_KEY
client = OpenAI()

# Faire un premier appel simple à l'API
response = client.chat.completions.create(
    model="gpt-4o",          # Le modèle à utiliser
    messages=[
        {
            "role": "user",   # Le rôle : "user" pour l'utilisateur
            "content": "Bonjour ! Explique-moi ce qu'est un LLM en 3 phrases simples."
        }
    ],
    temperature=0.7,          # Contrôle la créativité (0=déterministe, 2=très créatif)
    max_tokens=500            # Limite la longueur de la réponse
)

# Extraire et afficher la réponse
reply = response.choices[0].message.content
print(f"🤖 Assistant : {reply}")

# Afficher les informations d'utilisation (tokens consommés)
print(f"\n📊 Tokens utilisés : {response.usage.total_tokens}")
print(f"   - Prompt : {response.usage.prompt_tokens}")
print(f"   - Réponse : {response.usage.completion_tokens}")

python chatbot.py

"""
chatbot_context.py - Chatbot avec gestion du contexte
"""

import os
from openai import OpenAI
from dotenv import load_dotenv

load_dotenv()
client = OpenAI()

# L'historique de conversation est une liste de messages
# On commence avec un "system prompt" qui définit le comportement du bot
conversation_history = [
    {
        "role": "system",
        "content": (
            "Tu es un assistant IA amical et compétent. "
            "Tu réponds en français de manière claire et concise. "
            "Tu utilises des emojis avec parcimonie pour rendre "
            "la conversation agréable."
        )
    }
]

def get_ai_response(user_message: str) -> str:
    """
    Envoie un message à l'API et retourne la réponse.
    Gère automatiquement l'historique de conversation.
    """
    # Ajouter le message de l'utilisateur à l'historique
    conversation_history.append({
        "role": "user",
        "content": user_message
    })

    # Appel à l'API avec tout l'historique
    response = client.chat.completions.create(
        model="gpt-4o",
        messages=conversation_history,  # On envoie TOUT l'historique
        temperature=0.7,
        max_tokens=1000
    )

    # Extraire la réponse de l'assistant
    assistant_message = response.choices[0].message.content

    # Ajouter la réponse à l'historique pour le prochain tour
    conversation_history.append({
        "role": "assistant",
        "content": assistant_message
    })

    return assistant_message

# Test rapide
if __name__ == "__main__":
    # Premier message
    print("🤖", get_ai_response("Je m'appelle Alice et j'adore Python."))
    print()
    # Deuxième message - le bot devrait se souvenir du prénom
    print("🤖", get_ai_response("Quel est mon prénom ?"))
    print()
    # Troisième message - le bot devrait se souvenir du langage préféré
    print("🤖", get_ai_response("Et qu'est-ce que j'adore ?"))

"""
chatbot_interactive.py - Chatbot interactif en terminal
Un chatbot complet avec interface utilisateur en ligne de commande.
"""

import os
import sys
from datetime import datetime
from openai import OpenAI
from dotenv import load_dotenv

load_dotenv()
client = OpenAI()

# Configuration du chatbot
SYSTEM_PROMPT = """Tu es Nova, une assistante IA chaleureuse et experte en technologie.
Tes caractéristiques :
- Tu es passionnée par la vulgarisation technologique
- Tu donnes des exemples concrets et pratiques
- Tu admets quand tu ne sais pas quelque chose
- Tu réponds toujours en français
- Tu utilises un ton professionnel mais accessible"""

# Couleurs pour le terminal (codes ANSI)
class Colors:
    BLUE = '\033[94m'
    GREEN = '\033[92m'
    YELLOW = '\033[93m'
    RED = '\033[91m'
    BOLD = '\033[1m'
    RESET = '\033[0m'

def display_welcome():
    """Affiche le message de bienvenue."""
    print(f"""
{Colors.BOLD}{'='*60}
🤖 Nova - Votre Assistant IA Personnel
{'='*60}{Colors.RESET}
{Colors.GREEN}Bienvenue ! Je suis Nova, votre assistante IA.
Tapez votre message et appuyez sur Entrée.

Commandes spéciales :
  /quit   - Quitter le chatbot
  /reset  - Réinitialiser la conversation
  /help   - Afficher l'aide
  /save   - Sauvegarder la conversation
{'='*60}{Colors.RESET}
""")

def save_conversation(history: list, filename: str = None):
    """Sauvegarde la conversation dans un fichier texte."""
    if filename is None:
        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
        filename = f"conversation_{timestamp}.txt"
    
    with open(filename, 'w', encoding='utf-8') as f:
        f.write(f"Conversation sauvegardée le {datetime.now().strftime('%d/%m/%Y à %H:%M')}\n")
        f.write("=" * 60 + "\n\n")
        for msg in history:
            if msg['role'] == 'system':
                continue  # On ne sauvegarde pas le system prompt
            role = "👤 Vous" if msg['role'] == 'user' else "🤖 Nova"
            f.write(f"{role} :\n{msg['content']}\n\n")
    
    return filename

def chat():
    """Boucle principale du chatbot."""
    # Initialiser l'historique avec le system prompt
    history = [{"role": "system", "content": SYSTEM_PROMPT}]
    
    display_welcome()
    
    while True:
        try:
            # Lire l'input de l'utilisateur
            user_input = input(f"\n{Colors.BLUE}{Colors.BOLD}👤 Vous :{Colors.RESET} ").strip()
            
            # Ignorer les messages vides
            if not user_input:
                continue
            
            # Gérer les commandes spéciales
            if user_input.lower() == '/quit':
                print(f"\n{Colors.YELLOW}👋 Au revoir ! À bientôt !{Colors.RESET}")
                break
            
            elif user_input.lower() == '/reset':
                history = [{"role": "system", "content": SYSTEM_PROMPT}]
                print(f"{Colors.YELLOW}🔄 Conversation réinitialisée.{Colors.RESET}")
                continue
            
            elif user_input.lower() == '/help':
                display_welcome()
                continue
            
            elif user_input.lower() == '/save':
                filename = save_conversation(history)
                print(f"{Colors.GREEN}💾 Conversation sauvegardée dans {filename}{Colors.RESET}")
                continue
            
            # Ajouter le message utilisateur à l'historique
            history.append({"role": "user", "content": user_input})
            
            # Indicateur de chargement
            print(f"\n{Colors.GREEN}{Colors.BOLD}🤖 Nova :{Colors.RESET} ", end="", flush=True)
            
            # Appel à l'API
            response = client.chat.completions.create(
                model="gpt-4o",
                messages=history,
                temperature=0.7,
                max_tokens=1500
            )
            
            # Extraire et afficher la réponse
            assistant_reply = response.choices[0].message.content
            print(assistant_reply)
            
            # Ajouter la réponse à l'historique
            history.append({"role": "assistant", "content": assistant_reply})
            
        except KeyboardInterrupt:
            print(f"\n\n{Colors.YELLOW}👋 Interruption détectée. Au revoir !{Colors.RESET}")
            break

if __name__ == "__main__":
    chat()

"""
chatbot_streaming.py - Chatbot avec streaming en temps réel
Les réponses s'affichent mot par mot, comme sur ChatGPT.
"""

import os
import sys
from openai import OpenAI
from dotenv import load_dotenv

load_dotenv()
client = OpenAI()

SYSTEM_PROMPT = """Tu es un assistant IA expert et pédagogue.
Tu réponds en français avec clarté et précision."""

def stream_response(history: list) -> str:
    """
    Envoie la requête en mode streaming et affiche les tokens
    au fur et à mesure de leur génération.
    Retourne la réponse complète pour l'historique.
    """
    # Créer un stream au lieu d'une réponse complète
    stream = client.chat.completions.create(
        model="gpt-4o",
        messages=history,
        temperature=0.7,
        max_tokens=1500,
        stream=True  # ← C'est la seule différence !
    )
    
    full_response = ""
    
    # Itérer sur les chunks du stream
    for chunk in stream:
        # Chaque chunk contient un delta (fragment de texte)
        if chunk.choices[0].delta.content is not None:
            token = chunk.choices[0].delta.content
            print(token, end="", flush=True)  # Afficher sans retour à la ligne
            full_response += token
    
    print()  # Retour à la ligne final
    return full_response

def chat_with_streaming():
    """Boucle principale avec streaming."""
    history = [{"role": "system", "content": SYSTEM_PROMPT}]
    
    print("🤖 Chatbot avec streaming activé. Tapez /quit pour quitter.\n")
    
    while True:
        user_input = input("\n👤 Vous : ").strip()
        
        if user_input.lower() == '/quit':
            print("👋 Au revoir !")
            break
        
        if not user_input:
            continue
        
        history.append({"role": "user", "content": user_input})
        
        print("\n🤖 Assistant : ", end="", flush=True)
        
        # Utiliser le streaming pour la réponse
        assistant_reply = stream_response(history)
        
        # Ajouter la réponse complète à l'historique
        history.append({"role": "assistant", "content": assistant_reply})

if __name__ == "__main__":
    chat_with_streaming()

"""
chatbot_robust.py - Chatbot avec gestion complète des erreurs
"""

import os
import time
from openai import (
    OpenAI,
    APIConnectionError,
    RateLimitError,
    APIStatusError,
    AuthenticationError
)
from dotenv import load_dotenv

load_dotenv()
client = OpenAI()

def get_response_with_retry(
    messages: list,
    max_retries: int = 3,
    base_delay: float = 1.0
) -> str:
    """
    Appelle l'API avec retry automatique en cas d'erreur.
    Utilise un backoff exponentiel pour espacer les tentatives.
    
    Args:
        messages: L'historique de conversation
        max_retries: Nombre maximum de tentatives
        base_delay: Délai initial entre les tentatives (en secondes)
    
    Returns:
        La réponse de l'assistant
    
    Raises:
        Exception: Si toutes les tentatives échouent
    """
    for attempt in range(max_retries):
        try:
            response = client.chat.completions.create(
                model="gpt-4o",
                messages=messages,
                temperature=0.7,
                max_tokens=1500
            )
            return response.choices[0].message.content
            
        except AuthenticationError:
            # Clé API invalide - pas la peine de réessayer
            print("❌ Erreur d'authentification : vérifiez votre clé API.")
            print("   Assurez-vous que OPENAI_API_KEY est correctement définie.")
            raise
            
        except RateLimitError:
            # Trop de requêtes - attendre avant de réessayer
            delay = base_delay * (2 ** attempt)  # Backoff exponentiel
            print(f"⏳ Limite de requêtes atteinte. Attente de {delay}s...")
            time.sleep(delay)
            
        except APIConnectionError:
            # Problème de connexion réseau
            delay = base_delay * (2 ** attempt)
            print(f"🌐 Erreur de connexion. Tentative {attempt + 1}/{max_retries}...")
            time.sleep(delay)
            
        except APIStatusError as e:
            # Erreur serveur (500, 503, etc.)
            if e.status_code >= 500:
                delay = base_delay * (2 ** attempt)
                print(f"🔧 Erreur serveur ({e.status_code}). Retry dans {delay}s...")
                time.sleep(delay)
            else:
                print(f"❌ Erreur API : {e.status_code} - {e.message}")
                raise
    
    raise Exception("Toutes les tentatives ont échoué. Réessayez plus tard.")

# Fonction utilitaire pour valider la configuration
def validate_setup() -> bool:
    """Vérifie que l'environnement est correctement configuré."""
    api_key = os.getenv("OPENAI_API_KEY")
    
    if not api_key:
        print("❌ Variable OPENAI_API_KEY non définie.")
        print("   Créez un fichier .env avec : OPENAI_API_KEY=sk-...")
        return False
    
    if not api_key.startswith("sk-"):
        print("⚠️  La clé API semble invalide (ne commence pas par 'sk-').")
        return False
    
    # Test de connexion rapide
    try:
        client.models.list()
        print("✅ Connexion à l'API OpenAI réussie !")
        return True
    except Exception as e:
        print(f"❌ Impossible de se connecter à l'API : {e}")
        return False

# Exemple 1 : Assistant technique spécialisé
TECH_PROMPT = """Tu es un expert en développement Python avec 15 ans d'expérience.
Règles :
- Tu fournis toujours du code fonctionnel et commenté
- Tu expliques les concepts comme à un junior
- Tu mentionnes les bonnes pratiques et les pièges courants
- Tu proposes des alternatives quand c'est pertinent
- Format : utilise des blocs de code avec la syntaxe appropriée"""

# Exemple 2 : Assistant de support client
SUPPORT_PROMPT = """Tu es l'assistant virtuel de la société TechCorp.
Produits : logiciel de gestion (CRM Pro, Facture Express, Stock Manager)
Règles :
- Sois toujours poli et empathique
- Si tu ne connais pas la réponse, propose de transférer vers un humain
- Ne donne jamais d'informations sur la concurrence
- Collecte le numéro de ticket si le client a un problème technique
- Termine chaque réponse par "Puis-je vous aider avec autre chose ?"
"""

# Exemple 3 : Professeur de langues
LANGUAGE_PROMPT = """Tu es un professeur d'anglais natif patient et encourageant.
Règles :
- Corrige les erreurs de l'utilisateur avec bienveillance
- Explique pourquoi une formulation est incorrecte
- Donne des exemples d'usage naturel
- Adapte ton niveau au niveau de l'élève
- Propose des exercices pratiques quand c'est pertinent
- Mélange français et anglais dans tes explications"""

"""
chatbot_gradio.py - Interface web en 15 lignes avec Gradio
pip install gradio
"""

import gradio as gr
from openai import OpenAI
from dotenv import load_dotenv

load_dotenv()
client = OpenAI()

def respond(message, history):
    """Fonction de réponse pour Gradio."""
    # Convertir l'historique Gradio au format OpenAI
    messages = [{"role": "system", "content": "Tu es un assistant IA utile et amical."}]
    
    for user_msg, bot_msg in history:
        messages.append({"role": "user", "content": user_msg})
        messages.append({"role": "assistant", "content": bot_msg})
    
    messages.append({"role": "user", "content": message})
    
    # Appel à l'API avec streaming
    response = client.chat.completions.create(
        model="gpt-4o",
        messages=messages,
        stream=True
    )
    
    partial = ""
    for chunk in response:
        if chunk.choices[0].delta.content:
            partial += chunk.choices[0].delta.content
            yield partial

# Créer et lancer l'interface
demo = gr.ChatInterface(
    respond,
    title="🤖 Mon Chatbot IA",
    description="Posez-moi n'importe quelle question !",
    theme="soft"
)

# Lancer le serveur (accessible sur http://localhost:7860)
demo.launch(share=True)  # share=True crée un lien public temporaire

"""
chatbot_api.py - API REST basique avec Flask
pip install flask
"""

from flask import Flask, request, jsonify
from openai import OpenAI
from dotenv import load_dotenv

load_dotenv()
client = OpenAI()
app = Flask(__name__)

@app.route('/chat', methods=['POST'])
def chat():
    """Endpoint pour envoyer un message au chatbot."""
    data = request.json
    user_message = data.get('message', '')
    history = data.get('history', [])
    
    messages = [
        {"role": "system", "content": "Tu es un assistant IA utile."}
    ] + history + [
        {"role": "user", "content": user_message}
    ]
    
    response = client.chat.completions.create(
        model="gpt-4o",
        messages=messages,
        temperature=0.7
    )
    
    reply = response.choices[0].message.content
    return jsonify({"reply": reply})

if __name__ == '__main__':
    app.run(debug=True, port=5000)