Intégrer l'API ChatGPT dans vos applications : Guide pratique

L’IA générative transforme la façon dont on développe des applications. Dans ce guide, on va voir comment intégrer l’API ChatGPT de manière professionnelle.

Prérequis

Un compte OpenAI avec des crédits API
Node.js 18+ ou Python 3.8+
Connaissances basiques en programmation

Configuration initiale

1. Obtenir une clé API

Rendez-vous sur platform.openai.com
Créez une nouvelle clé API
Important : Ne partagez jamais votre clé !

2. Installation du SDK

# Node.js
npm install openai

# Python
pip install openai

3. Configuration sécurisée

Stockez votre clé dans les variables d’environnement :

# .env (ne jamais committer ce fichier !)
OPENAI_API_KEY=sk-...votre-clé...

Premier appel API

Avec Node.js

import OpenAI from 'openai';

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

async function askGPT(prompt: string) {
  const completion = await openai.chat.completions.create({
    model: 'gpt-4-turbo-preview',
    messages: [
      {
        role: 'system',
        content: 'Tu es un assistant technique expert.',
      },
      {
        role: 'user',
        content: prompt,
      },
    ],
    max_tokens: 1000,
    temperature: 0.7,
  });

  return completion.choices[0].message.content;
}

Avec Python

from openai import OpenAI

client = OpenAI()

def ask_gpt(prompt: str) -> str:
    completion = client.chat.completions.create(
        model="gpt-4-turbo-preview",
        messages=[
            {"role": "system", "content": "Tu es un assistant technique expert."},
            {"role": "user", "content": prompt}
        ],
        max_tokens=1000,
        temperature=0.7
    )
    return completion.choices[0].message.content

Paramètres importants

Paramètre	Description	Valeur recommandée
`model`	Modèle à utiliser	gpt-4-turbo-preview
`temperature`	Créativité (0-2)	0.7 pour équilibré
`max_tokens`	Longueur max réponse	Selon besoin
`top_p`	Diversité vocabulaire	1.0 par défaut

Techniques avancées

Streaming des réponses

Pour une meilleure UX, streamer les réponses :

async function* streamGPT(prompt: string) {
  const stream = await openai.chat.completions.create({
    model: 'gpt-4-turbo-preview',
    messages: [{ role: 'user', content: prompt }],
    stream: true,
  });

  for await (const chunk of stream) {
    const content = chunk.choices[0]?.delta?.content;
    if (content) yield content;
  }
}

// Usage
for await (const text of streamGPT('Explique le machine learning')) {
  process.stdout.write(text);
}

Function Calling

GPT peut appeler vos fonctions :

const tools = [
  {
    type: 'function' as const,
    function: {
      name: 'get_weather',
      description: 'Obtenir la météo actuelle',
      parameters: {
        type: 'object',
        properties: {
          location: {
            type: 'string',
            description: 'La ville (ex: Paris)',
          },
        },
        required: ['location'],
      },
    },
  },
];

const response = await openai.chat.completions.create({
  model: 'gpt-4-turbo-preview',
  messages: [{ role: 'user', content: 'Quel temps fait-il à Lyon ?' }],
  tools,
  tool_choice: 'auto',
});

Gestion des erreurs

Implémentez toujours une gestion robuste :

import { RateLimitError, APIError } from 'openai';

async function safeAskGPT(prompt: string, retries = 3) {
  for (let i = 0; i < retries; i++) {
    try {
      return await askGPT(prompt);
    } catch (error) {
      if (error instanceof RateLimitError) {
        // Attendre et réessayer
        await new Promise(r => setTimeout(r, 2000 * (i + 1)));
        continue;
      }
      if (error instanceof APIError) {
        console.error(`API Error: ${error.status} - ${error.message}`);
        throw error;
      }
      throw error;
    }
  }
  throw new Error('Max retries reached');
}

Optimisation des coûts

1. Choisir le bon modèle

Modèle	Coût (input/1K)	Use case
gpt-3.5-turbo	$0.0005	Tâches simples
gpt-4-turbo	$0.01	Raisonnement complexe
gpt-4o	$0.005	Équilibre qualité/coût

2. Optimiser les prompts

// ❌ Prompt inefficace
const badPrompt = `
  Peux-tu s'il te plaît me donner une liste de 10 idées
  pour améliorer mon site web ? J'aimerais des idées
  créatives et innovantes si possible. Merci !
`;

// ✅ Prompt optimisé
const goodPrompt = `
  Liste 10 améliorations UX pour un site e-commerce.
  Format: numérotation, 1 phrase par idée.
`;

3. Implémenter du caching

import NodeCache from 'node-cache';

const cache = new NodeCache({ stdTTL: 3600 }); // 1h

async function cachedAskGPT(prompt: string) {
  const cacheKey = `gpt:${Buffer.from(prompt).toString('base64')}`;
  const cached = cache.get<string>(cacheKey);

  if (cached) return cached;

  const response = await askGPT(prompt);
  cache.set(cacheKey, response);
  return response;
}

Sécurité

Validation des entrées

function sanitizePrompt(userInput: string): string {
  // Limite la longueur
  const maxLength = 4000;
  let sanitized = userInput.slice(0, maxLength);

  // Supprime les tentatives d'injection
  sanitized = sanitized.replace(/ignore previous instructions/gi, '');

  return sanitized;
}

Rate limiting

import Bottleneck from 'bottleneck';

const limiter = new Bottleneck({
  minTime: 100,      // 100ms entre requêtes
  maxConcurrent: 5,  // Max 5 requêtes simultanées
});

const limitedAskGPT = limiter.wrap(askGPT);

Conclusion

L’intégration de l’API ChatGPT ouvre d’immenses possibilités pour vos applications. Les points clés à retenir :

Sécurisez vos clés API
Gérez les erreurs et les rate limits
Optimisez vos coûts avec le bon modèle
Streamez pour une meilleure UX
Cachez les réponses répétitives

Besoin d’aide ? Chez Kodixar, j’accompagne les entreprises dans l’intégration de solutions IA. Contactez-moi pour en discuter.

Dans un prochain article, on explorera les RAG (Retrieval Augmented Generation) pour créer des chatbots qui utilisent vos propres données.