Utiliser l'API OpenAI dans vos projets

Mise en place de votre environnement OpenAI : **1. Obtenir les clés API :** - Créez un compte sur platform.openai.com - Générez une clé API dans 'API Keys' - Configurez les limites de rate et budget - Activez les modèles souhaités (GPT-4, GPT-3.5-turbo) **2. Installation des SDKs :** ```bash # Python pip install openai # Node.js npm install openai # Configuration environnement export OPENAI_API_KEY="votre-clé-api" ``` **3. Premier test :** ```python import openai from openai import OpenAI client = OpenAI( api_key="votre-clé-api" ) # Test de connexion response = client.chat.completions.create( model="gpt-4", messages=[{"role": "user", "content": "Hello, world!"}], max_tokens=50 ) print(response.choices[0].message.content) ```

Maintenir des conversations cohérentes : ```python class ChatGPTManager: def __init__(self, model="gpt-4"): self.client = OpenAI() self.model = model self.conversation_history = [] self.system_prompt = None def set_system_prompt(self, prompt): """Définit le comportement du système""" self.system_prompt = prompt self.conversation_history = [ {"role": "system", "content": prompt} ] def send_message(self, user_message): """Envoie un message et maintient l'historique""" # Ajouter le message utilisateur self.conversation_history.append({ "role": "user", "content": user_message }) try: response = self.client.chat.completions.create( model=self.model, messages=self.conversation_history, temperature=0.7, max_tokens=1000 ) assistant_message = response.choices[0].message.content # Ajouter la réponse à l'historique self.conversation_history.append({ "role": "assistant", "content": assistant_message }) return assistant_message except Exception as e: return f"Erreur: {str(e)}" def clear_conversation(self): """Réinitialise la conversation""" if self.system_prompt: self.conversation_history = [ {"role": "system", "content": self.system_prompt} ] else: self.conversation_history = [] # Utilisation chat = ChatGPTManager() chat.set_system_prompt("Tu es un assistant expert en programmation Python.") response = chat.send_message("Explique-moi les décorateurs Python") ```

Code robuste pour la production : ```python import time import logging from openai import OpenAI, RateLimitError, APIError class RobustChatGPT: def __init__(self, max_retries=3, base_delay=1): self.client = OpenAI() self.max_retries = max_retries self.base_delay = base_delay # Configuration du logging logging.basicConfig(level=logging.INFO) self.logger = logging.getLogger(__name__) def call_with_retry(self, messages, **kwargs): """Appel API avec retry automatique""" for attempt in range(self.max_retries): try: response = self.client.chat.completions.create( messages=messages, **kwargs ) return response.choices[0].message.content except RateLimitError as e: if attempt < self.max_retries - 1: delay = self.base_delay * (2 ** attempt) # Backoff exponentiel self.logger.warning(f"Rate limit atteint. Retry dans {delay}s") time.sleep(delay) continue raise except APIError as e: self.logger.error(f"Erreur API OpenAI: {e}") if attempt < self.max_retries - 1: time.sleep(self.base_delay) continue return None except Exception as e: self.logger.error(f"Erreur inattendue: {e}") return None return None ```

Implémentations pratiques pour applications réelles : **1. Chatbot avec mémoire persistante :** ```python import json from datetime import datetime class PersistentChatbot: def __init__(self, user_id, storage_path="./conversations/"): self.user_id = user_id self.storage_path = storage_path self.conversation_file = f"{storage_path}/user_{user_id}.json" self.load_conversation() def load_conversation(self): try: with open(self.conversation_file, 'r') as f: data = json.load(f) self.messages = data.get('messages', []) self.metadata = data.get('metadata', {}) except FileNotFoundError: self.messages = [] self.metadata = {'created': datetime.now().isoformat()} ``` **2. Analyse de sentiment en temps réel :** ```python def analyze_sentiment_batch(texts): """Analyse le sentiment de plusieurs textes""" prompt = f"""Analyse le sentiment de ces textes et retourne un JSON : Textes : {texts} Format de réponse : {{ "results": [ {{ "text": "texte original", "sentiment": "positif|neutre|négatif", "confidence": 0.95, "keywords": ["mot1", "mot2"] }} ] }}""" response = client.chat.completions.create( model="gpt-4", messages=[{"role": "user", "content": prompt}], temperature=0.3 ) return json.loads(response.choices[0].message.content) ```