Créer un chatbot personnalisé avec l’API OpenAI

Créer un chatbot personnalisé avec l’API OpenAI est aujourd’hui l’approche la plus rapide pour livrer un assistant conversationnel fiable, multimodal et extensible. L’API propose : un endpoint “Responses” moderne (remplaçant la logique “Chat Completions” dans la plupart des cas), un SDK officiel (JS/Node et Python), la gestion du streaming, la création d’outils/“function calling” et des modules pour embeddings/vecteurs (mémoire et RAG). OpenAI Platform+1

Dans ce guide, on va :

cadrer le besoin,
choisir l’architecture (LLM seul vs RAG),
implémenter (prompts, outils, mémoire),
traiter la sécurité/qualité,
déployer (Web, serveur, serverless),
optimiser les coûts et le SEO de votre page “Chatbot”.

Table of Contents

1) Cadrer le besoin produit

1.1 Objectifs du chatbot

Support client (FAQ, tri d’intentions, récupération de tickets).
Assistant de contenu (rédaction, reformulation, résumé long → court).
Copilote métier (interroger une base documentaire, générer des comptes rendus, actions CRM via API).
Agent interne (workflow RH/IT, automatisation).

1.2 Données et contraintes

Sources : base de connaissances interne (PDF, Notion, GDrive), FAQ site, CRM.
Risque & conformité : PII/secret-sauce, RGPD, AI Act (journalisation, consentement).
Canaux : widget Web, WhatsApp, Slack, app mobile, voice.
KPI : taux de résolution, CSAT, coût par conversation, latence P50/P95.

2) Choisir l’architecture

2.1 LLM “pur” vs RAG

LLM seul : simple et rapide pour FAQ publiques.
RAG (Retrieval-Augmented Generation) : indispensable si vos réponses doivent s’appuyer sur vos documents. On combine embeddings + index vectoriel + prompt pour “citer” les bons passages, puis on génère la réponse. OpenAI Platform

Voir aussi MidJourney pour débutants : guide pas à pas

2.2 Outils (Function Calling) et Agents

Les modèles peuvent appeler vos fonctions (ex. getOrderStatus, createTicket) de façon structurée ; cela transforme le bot en agent capable d’agir dans vos systèmes. OpenAI documente l’usage des tools/function calling dans son API moderne et un Agents SDK pour orchestrer plus facilement. OpenAI Platform+1

2.3 Temps réel & voix

Pour voix/vision/latence ultra-basse (call center, co-pilot vocal), utilisez l’API Realtime (WebRTC/WebSocket) décrite dans la référence “Responses/Realtime”. OpenAI Platform

3) Pré-requis techniques

Clé API OpenAI (variable d’environnement OPENAI_API_KEY).
SDK officiel : openai (Node) ou openai (Python).
Serveur (Node/Express, Python/FastAPI) ou serverless (Vercel/Netlify/Cloudflare).
Base vecteur (option RAG) : Postgres pgvector, Pinecone, Weaviate, Qdrant, etc.

Les exemples ci-dessous utilisent l’endpoint Responses (recommandé par la doc), avec streaming et tools. OpenAI Platform

4) Implémentation — version minimale (Node.js & Python)

4.1 Prompt de système (ligne éditoriale)

Ton professionnel, concis, sources citées si RAG, refus si donnée sensible, français par défaut.

Modèle de “system prompt”

Tu es le chatbot officiel de <Marque>. 
- Réponds en français, ton clair et utile.
- Si la réponse dépend de documents internes, cite les sections fournies dans le contexte.
- Si l’info n’existe pas, dis-le et propose une alternative.
- Ne divulgue jamais de secrets, tokens, ni données personnelles.

4.2 Node.js — réponse simple (Responses API + streaming)

Le SDK officiel expose openai.responses.create(...) (ou équivalent) et supporte le streaming. Voir la référence Responses. OpenAI Platform

// server/routes/chat.js
import express from "express";
import OpenAI from "openai";

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

// POST /api/chat
router.post("/", async (req, res) => {
  const { messages } = req.body; // [{role:"user", content:"..."}]
  res.setHeader("Content-Type", "text/event-stream"); // streaming SSE

  try {
    const stream = await openai.responses.stream({
      model: "gpt-5", // ou "gpt-4o" selon vos besoins
      input: [
        { role: "system", content: "Tu es un assistant utile en français." },
        ...messages
      ]
    });

    stream.on("message", (chunk) => {
      res.write(`data: ${JSON.stringify(chunk)}\n\n`);
    });

    stream.on("end", () => res.end());
  } catch (err) {
    console.error(err);
    res.status(500).end();
  }
});

export default router;

Remarque : remplacez gpt-5 par le modèle recommandé/autorisé dans votre compte (consultez la page modèles de la doc). OpenAI Platform

4.3 Python — réponse simple

# app/routes/chat.py
from fastapi import APIRouter
from fastapi.responses import StreamingResponse
from openai import OpenAI
import json

router = APIRouter()
client = OpenAI()

@router.post("/api/chat")
def chat(payload: dict):
    messages = payload.get("messages", [])

    def gen():
        with client.responses.stream(
            model="gpt-5",
            input=[{"role":"system","content":"Tu es un assistant utile en français."}, *messages]
        ) as stream:
            for event in stream:
                yield f"data: {json.dumps(event)}\n\n"

    return StreamingResponse(gen(), media_type="text/event-stream")

5) Ajouter des Tools (Function Calling) pour agir

5.1 Déclarer un outil (ex. statut de commande)

Les tools permettent au modèle de demander un appel de fonction avec des arguments structurés que vous exécutez côté serveur. Référence : tools / function calling via Responses API. OpenAI Platform

const tools = [
  {
    type: "function",
    name: "getOrderStatus",
    description: "Récupère le statut d'une commande via son ID",
    parameters: {
      type: "object",
      properties: { orderId: { type: "string" } },
      required: ["orderId"]
    }
  }
];

const response = await openai.responses.create({
  model: "gpt-5",
  input: [{ role: "user", content: "Où en est la commande #AIA-4312 ?" }],
  tools
});

// Si le modèle propose un appel de fonction :
if (response.output && response.output[0]?.type === "tool_call") {
  const { name, arguments: args } = response.output[0].tool_call;
  if (name === "getOrderStatus") {
    const data = await myERP.getOrderStatus(args.orderId);
    const followup = await openai.responses.create({
      model: "gpt-5",
      input: [
        { role: "system", content: "Tu es un assistant service client." },
        { role: "user", content: "Où en est la commande #AIA-4312 ?" },
        { role: "tool", name: "getOrderStatus", content: JSON.stringify(data) }
      ]
    });
    // ...renvoyer followup au client
  }
}

6) Ajouter la mémoire et le RAG

6.1 Générer des embeddings & indexer

Les embeddings convertissent vos textes en vecteurs numériques. Doc officielle “Vector embeddings”. OpenAI Platform

Pipeline :

Extraire le texte (HTML→Markdown, PDF→texte).
Chunking (≈400–1000 tokens, chevauchement 10–15%).
client.embeddings.create → stocker (id, text, vector, métadonnées) dans votre base vecteur.
À chaque question : faire une similarity search (k=3–8), injecter les passages dans le prompt.

Voir aussi Reconnaissance vocale : nouvelles limites atteintes

Exemple (Node) :

const emb = await openai.embeddings.create({
  model: "text-embedding-3-large",
  input: chunkText
});
// emb.data[0].embedding -> tableau de floats à persister

6.2 Chaîne de prompting RAG

[System] Tu es le chatbot de <Marque>. 
Utilise uniquement les "Extraits" fournis pour répondre. Si l’info manque, dis-le.
[Context] Extraits pertinents (max 1500-2500 tokens): <...>
[User] Question

6.3 Citations & prévention d’hallucinations

Inclure titres/URLs des extraits, demander citations (“Selon le doc X, section Y…”).
Activer un second passage “critic” (auto-révision) si coût acceptable.

7) UX : Widget Web propre + anti-frustration

SSE / WebSocket pour streaming (sentiment de vitesse).
Indications (“Tapez /faq, /humain”).
Bulle contextuelle quand le bot utilise un outil (“J’interroge votre commande…”).
Fallback humain si seuil de confiance bas.
Upload (PDF/image) si vous activez l’input multimodal côté modèle (vérifier limites).

8) Sécurité, confidentialité, conformité

Ne journalisez jamais les clés, tokens, ni PII en clair.
Masquez les logs (redaction) + chiffrez au repos/en transit.
Filtre de sortie (listes de blocage : secrets, numéros CB) + règles de refus dans le system prompt.
Consentement utilisateur (RGPD), DPIA si données sensibles.
Rate limiting et quotas par IP/clé organisationnelle.
Garde-fous outils : liste blanche des fonctions, validation stricte des schémas (Pydantic/Zod).

9) Qualité : évaluer & améliorer

Jeux de tests (questions réelles + réponses attendues).
Rubriques d’évaluation : exactitude, traçabilité des sources (RAG), style, sécurité.
Instrumentation : tracing des runs et des tool-calls (voir Agents SDK/tracing). OpenAI Platform
Boucle de feedback : bouton 👍/👎 + raison, ré-entraînement RAG (ajouter docs manquants).
A/B prompts (titres, styles) + seuils de similarité dans la recherche vectorielle.

10) Coûts & performance

Batcher les embeddings (économie de latence).
Limiter le contexte : k=4–6 extraits bien “chunkés” > k=20.
Compresser (ré-résumer) l’historique de chat au-delà de N tours.
Modèle adapté : “raisonnement lourd” seulement quand nécessaire ; autrement un modèle plus léger pour la plupart des tours.
Mise en cache (clé = question normalisée + drapeau langue).
Timeouts outils (ex. 5–10 s) + circuit breaker.

Voir aussi Comment rédiger un email professionnel avec ChatGPT

11) Déploiement (production)

Serverless (Vercel/Netlify/Cloudflare) pour le front + API sur une fonction edge si SSE.
Secrets dans le KV du provider (jamais dans le client).
Observabilité : logs structurés, traces, dashboards d’erreurs.
Backups index vecteur, migration embeddings (si vous changez de modèle embedding).
CDN sur les assets, préconnexion (<link rel="preconnect">) aux endpoints.

12) Exemples “copiables”

12.1 Route `/api/ask` avec RAG (Node)

import OpenAI from "openai";
import express from "express";
import { searchTopK } from "./vectorStore.js"; // à implémenter

const app = express();
app.use(express.json());
const openai = new OpenAI({ apiKey: process.env.OPENAI_API_KEY });

app.post("/api/ask", async (req, res) => {
  const { question, history = [] } = req.body;

  // 1) Récupérer les extraits
  const passages = await searchTopK(question, 6); // [{text, title, url}]
  const context = passages.map((p,i)=>`[${i+1}] ${p.title} - ${p.url}\n${p.text}`).join("\n\n");

  // 2) Prompt
  const input = [
    {
      role: "system",
      content:
        "Tu es l'assistant de <Marque>. Utilise UNIQUEMENT les extraits fournis."
    },
    ...history,
    {
      role: "user",
      content: `Question: ${question}\n\nExtraits:\n${context}`
    }
  ];

  // 3) Appel modèle (streaming recommandé)
  const resp = await openai.responses.create({
    model: "gpt-5",
    input
  });

  res.json({
    answer: resp.output_text, // selon le SDK, exposé pour Responses API
    citations: passages.map((p) => ({ title: p.title, url: p.url }))
  });
});

app.listen(3000);

Le champ de sortie peut différer selon la version du SDK (par ex. output_text/choices[0].message.content selon l’API). Vérifiez la référence Responses du moment. OpenAI Platform

12.2 Générer embeddings (Python)

from openai import OpenAI
client = OpenAI()

def embed_chunks(chunks):
    out = []
    for ch in chunks:
        resp = client.embeddings.create(
            model="text-embedding-3-large",
            input=ch["text"]
        )
        out.append({**ch, "vector": resp.data[0].embedding})
    return out

OpenAI Platform

12.3 Outil “createTicket” (Node) avec validation Zod

import { z } from "zod";
const CreateTicket = z.object({
  email: z.string().email(),
  subject: z.string().max(120),
  body: z.string().max(2000)
});

const tools = [{
  type: "function",
  name: "createTicket",
  description: "Crée un ticket support",
  parameters: JSON.parse(CreateTicket.toString()) // ou schéma JSON équivalent
}];

// ... même pattern que l’exemple tool-call plus haut.

13) SEO de votre page “Chatbot”

Balises : H1 unique (focus keyword), H2 “Fonctionnalités”, H2 “Tarifs”, H2 “Sécurité”, FAQ schema.org/FAQPage.
Snippets : montrer 2–3 captures (UX, temps de réponse).
Preuve : métriques (“95% des questions répondues”), logos clients/avis.
Maillage interne : lier vers vos pages “Tarifs”, “Intégrations”, “Confidentialité”.
Intentions : “chatbot support 24/7”, “FAQ IA”, “assistant client IA français”.

14) FAQ rapide

Lequel des endpoints utiliser ?
→ Responses API pour la majorité des cas (chat, tools, streaming) ; l’API Realtime pour voix/latence très faible. OpenAI Platform

Comment connecter mes données ?
→ Via embeddings + index vectoriel (RAG). OpenAI Platform

Puis-je exécuter des actions (CRM, commandes) ?
→ Oui, via tools/function calling ; voyez aussi l’Agents SDK pour tracer/orchestrer. OpenAI Platform+1

Quels modèles choisir ?
→ Utilisez les modèles disponibles sur votre compte (familles récentes comme GPT-5 / GPT-4o selon l’accès) ; vérifiez la page “latest models & migration vers Responses”. OpenAI Platform

15) Checklist “avant mise en prod”

System prompt verrouillé (+ règles de refus).
Observabilité & tracing activés. OpenAI Platform
Tests RAG (exactitude, citations).
Limites d’input (upload, taille fichiers).
Politiques de rétention & anonymisation logs.
Requêtes idempotentes, timeouts, retries.
Plan de secours (fallback humain).