Utilisation pratique de l'API OpenAI

Utilisation pratique de l’API OpenAI

Introduction

L’API OpenAI fournit un accès simple et puissant aux modèles de langage les plus avancés. Ce tutoriel vous guidera à travers les étapes nécessaires pour commencer à utiliser l’API dans vos projets.

Configuration initiale

1. Installation

Pour Python :

pip install openai

Pour Node.js :

npm install openai

2. Configuration de l’API Key

Créez un fichier .env à la racine de votre projet :

OPENAI_API_KEY=votre_clé_api_ici

En Python :

import os
from dotenv import load_dotenv
from openai import OpenAI

load_dotenv()
client = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))

En JavaScript :

import OpenAI from 'openai';
import dotenv from 'dotenv';

dotenv.config();
const openai = new OpenAI({
  apiKey: process.env.OPENAI_API_KEY
});

Utilisation de base

1. Génération de texte simple

Python :

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

JavaScript :

async function generateText(prompt) {
    const response = await openai.chat.completions.create({
        model: "gpt-3.5-turbo",
        messages: [
            { role: "user", content: prompt }
        ]
    });
    return response.choices[0].message.content;
}

2. Conversation avec contexte

Python :

def chat_with_context(messages):
    response = client.chat.completions.create(
        model="gpt-3.5-turbo",
        messages=messages,
        temperature=0.7,
        max_tokens=150
    )
    return response.choices[0].message.content

# Exemple d'utilisation
messages = [
    {"role": "system", "content": "Tu es un assistant expert en programmation Python."},
    {"role": "user", "content": "Comment créer une liste en Python ?"},
    {"role": "assistant", "content": "Pour créer une liste en Python, utilisez des crochets : ma_liste = [1, 2, 3]"},
    {"role": "user", "content": "Comment ajouter un élément à cette liste ?"}
]

JavaScript :

async function chatWithContext(messages) {
    const response = await openai.chat.completions.create({
        model: "gpt-3.5-turbo",
        messages: messages,
        temperature: 0.7,
        max_tokens: 150
    });
    return response.choices[0].message.content;
}

// Exemple d'utilisation
const messages = [
    { role: "system", content: "Tu es un assistant expert en JavaScript." },
    { role: "user", content: "Comment créer un tableau en JavaScript ?" },
    { role: "assistant", content: "Pour créer un tableau en JavaScript, utilisez des crochets : const monTableau = [1, 2, 3];" },
    { role: "user", content: "Comment ajouter un élément à ce tableau ?" }
];

Paramètres avancés

1. Contrôle de la créativité

Le paramètre temperature contrôle la créativité des réponses :

• 0.0 : Réponses déterministes et cohérentes
• 0.7 : Bon équilibre entre créativité et cohérence
• 1.0 : Réponses très créatives et variées

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

2. Limitation de la longueur

Le paramètre max_tokens contrôle la longueur maximale de la réponse :

def generate_concise_text(prompt, max_tokens=100):
    response = client.chat.completions.create(
        model="gpt-3.5-turbo",
        messages=[{"role": "user", "content": prompt}],
        max_tokens=max_tokens
    )
    return response.choices[0].message.content

Gestion des erreurs

1. Gestion basique

Python :

from openai import OpenAIError

def safe_api_call(prompt):
    try:
        response = client.chat.completions.create(
            model="gpt-3.5-turbo",
            messages=[{"role": "user", "content": prompt}]
        )
        return response.choices[0].message.content
    except OpenAIError as e:
        print(f"Erreur API OpenAI : {str(e)}")
        return None

JavaScript :

async function safeApiCall(prompt) {
    try {
        const response = await openai.chat.completions.create({
            model: "gpt-3.5-turbo",
            messages: [{ role: "user", content: prompt }]
        });
        return response.choices[0].message.content;
    } catch (error) {
        console.error("Erreur API OpenAI :", error);
        return null;
    }
}

2. Gestion avancée avec retry

Python :

import time
from tenacity import retry, stop_after_attempt, wait_exponential

@retry(stop=stop_after_attempt(3), wait=wait_exponential(multiplier=1, min=4, max=10))
def robust_api_call(prompt):
    try:
        response = client.chat.completions.create(
            model="gpt-3.5-turbo",
            messages=[{"role": "user", "content": prompt}]
        )
        return response.choices[0].message.content
    except OpenAIError as e:
        print(f"Tentative échouée : {str(e)}")
        raise

Exemples d’applications pratiques

1. Assistant de rédaction

def writing_assistant(text, instruction):
    prompt = f"""
    Texte original : {text}
    Instruction : {instruction}
    Veuillez améliorer ce texte en suivant l'instruction donnée.
    """
    
    response = client.chat.completions.create(
        model="gpt-3.5-turbo",
        messages=[
            {"role": "system", "content": "Tu es un assistant de rédaction expert."},
            {"role": "user", "content": prompt}
        ],
        temperature=0.7
    )
    return response.choices[0].message.content

2. Générateur de code

def code_generator(description, language):
    prompt = f"""
    Langage : {language}
    Description : {description}
    Génère le code correspondant à cette description.
    """
    
    response = client.chat.completions.create(
        model="gpt-3.5-turbo",
        messages=[
            {"role": "system", "content": f"Tu es un expert en programmation {language}."},
            {"role": "user", "content": prompt}
        ],
        temperature=0.2
    )
    return response.choices[0].message.content

Bonnes pratiques

1. Gestion des coûts

   • Surveillez votre utilisation de l’API
   • Utilisez des limites de tokens appropriées
   • Mettez en cache les réponses fréquentes

2. Sécurité

   • Ne partagez jamais votre clé API
   • Utilisez des variables d’environnement
   • Validez les entrées utilisateur

3. Performance

   • Utilisez des appels asynchrones quand possible
   • Implémentez un système de mise en cache
   • Gérez les timeouts appropriément

Ressources supplémentaires

• Documentation officielle OpenAI
• Guide des meilleures pratiques
• Prix et limites
• Exemples de code

Conclusion

L’API OpenAI offre un accès puissant aux modèles de langage. En suivant ce tutoriel, vous avez appris à :

• Configurer l’API
• Effectuer des appels de base
• Gérer les paramètres avancés
• Implémenter la gestion des erreurs
• Créer des applications pratiques

Dans le prochain tutoriel, nous explorerons des cas d’utilisation plus avancés et des techniques d’optimisation pour des scénarios spécifiques.