💬 Chat AI - Créer des conversations intelligentes

Introduction

Le module Chat AI de l'API OUPI vous permet de créer des conversations avec les meilleurs modèles d'IA du marché (GPT, Claude, Mistral) via une API unifiée. Ce guide vous explique comment créer des chatbots, gérer des conversations et intégrer l'IA conversationnelle dans vos applications.

🎯 Cas d'usage

Applications possibles

Support client intelligent

• Chatbot 24/7 sur votre site web

• Réponses automatiques aux questions fréquentes

• Escalade vers humain si nécessaire

Assistants virtuels

• Assistant personnel dans votre application

• Aide à la rédaction

• Recherche d'informations

Applications de messagerie

• Chat IA dans votre app mobile

• Conversations contextuelles

• Personnalisation par utilisateur

Automatisation

• Traitement de demandes clients

• Génération de réponses emails

• Analyse de conversations

📋 Endpoints disponibles

Vue d'ensemble

🆕 Créer une conversation

Endpoint

POST /api/aichat/new-chat

Paramètres

Body (JSON) :

{
  "category_id": "1"
}

Paramètres :

• category_id (string) : ID de la catégorie de chatbot

  • "1" : Chat général

  • Autres valeurs selon les catégories disponibles

Exemple complet

JavaScript/Node.js :

const API_TOKEN = process.env.OUPI_API_TOKEN;
const BASE_URL = 'https://app.oupi.com/api';

async function createNewChat() {
  const response = await fetch(`${BASE_URL}/aichat/new-chat`, {
    method: 'POST',
    headers: {
      'Authorization': `Bearer ${API_TOKEN}`,
      'Content-Type': 'application/json'
    },
    body: JSON.stringify({
      category_id: '1'
    })
  });

  if (!response.ok) {
    throw new Error(`Erreur HTTP: ${response.status}`);
  }

  const data = await response.json();
  console.log('Chat créé avec ID:', data.conver_id);
  
  return data;
}

// Utilisation
createNewChat()
  .then(chat => console.log('✅ Conversation créée:', chat))
  .catch(error => console.error('❌ Erreur:', error));

Python :

import requests
import os

API_TOKEN = os.getenv('OUPI_API_TOKEN')
BASE_URL = 'https://app.oupi.com/api'

def create_new_chat():
    headers = {
        'Authorization': f'Bearer {API_TOKEN}',
        'Content-Type': 'application/json'
    }
    
    data = {'category_id': '1'}
    
    response = requests.post(
        f'{BASE_URL}/aichat/new-chat',
        headers=headers,
        json=data
    )
    response.raise_for_status()
    
    result = response.json()
    print(f'Chat créé avec ID: {result["conver_id"]}')
    return result

# Utilisation
if __name__ == '__main__':
    try:
        chat = create_new_chat()
        print('✅ Conversation créée:', chat)
    except Exception as e:
        print(f'❌ Erreur: {e}')

Réponse

Structure de la réponse :

{
  "status": "success",
  "conver_id": "abc123def456",
  "created_at": "2024-12-18T10:30:00Z",
  "category_id": "1"
}

Champs importants :

• conver_id : ID unique de la conversation (conservez-le pour envoyer des messages)

• created_at : Date de création

• category_id : Catégorie du chatbot

💬 Envoyer un message

Endpoint

POST /api/aichat/chat/chat-send

Paramètres

Body (JSON) :

{
  "conver_id": "abc123def456",
  "prompt": "Bonjour, comment puis-je créer un chatbot ?",
  "category_id": "1"
}

Paramètres requis :

• conver_id (string) : ID de la conversation (obtenu lors de la création)

• prompt (string) : Votre message/question

• category_id (string) : ID de la catégorie

Exemple complet avec streaming

JavaScript/Node.js :

async function sendMessage(converId, message) {
  const response = await fetch(`${BASE_URL}/aichat/chat/chat-send`, {
    method: 'POST',
    headers: {
      'Authorization': `Bearer ${API_TOKEN}`,
      'Content-Type': 'application/json'
    },
    body: JSON.stringify({
      conver_id: converId,
      prompt: message,
      category_id: '1'
    })
  });

  if (!response.ok) {
    throw new Error(`Erreur HTTP: ${response.status}`);
  }

  const result = await response.json();
  console.log('Réponse de l\'IA:', result.response);
  
  return result;
}

// Utilisation
sendMessage('abc123def456', 'Explique-moi le machine learning')
  .then(response => {
    console.log('✅ Message envoyé');
    console.log('Réponse:', response.response);
  })
  .catch(error => console.error('❌ Erreur:', error));

Python avec gestion complète :

def send_message(conver_id, message):
    headers = {
        'Authorization': f'Bearer {API_TOKEN}',
        'Content-Type': 'application/json'
    }
    
    data = {
        'conver_id': conver_id,
        'prompt': message,
        'category_id': '1'
    }
    
    response = requests.post(
        f'{BASE_URL}/aichat/chat/chat-send',
        headers=headers,
        json=data
    )
    
    response.raise_for_status()
    result = response.json()
    
    print(f'Réponse de l\'IA: {result["response"]}')
    return result

# Utilisation
try:
    response = send_message('abc123def456', 'Explique-moi le machine learning')
    print('✅ Message envoyé')
except Exception as e:
    print(f'❌ Erreur: {e}')

Réponse

Structure de la réponse :

{
  "status": "success",
  "message_id": "msg_789xyz",
  "response": "Le machine learning est une branche de l'intelligence artificielle qui permet aux ordinateurs d'apprendre à partir de données...",
  "model": "gpt-4",
  "tokens_used": 150,
  "created_at": "2024-12-18T10:31:15Z"
}

Champs importants :

• response : La réponse générée par l'IA

• message_id : ID unique du message

• model : Modèle utilisé

• tokens_used : Nombre de tokens consommés

🔄 Workflow complet : Conversation

Exemple : Créer un chatbot simple

Scénario : Un utilisateur pose plusieurs questions successives.

// Classe pour gérer les conversations
class OupiChat {
  constructor(apiToken) {
    this.apiToken = apiToken;
    this.baseUrl = 'https://app.oupi.com/api';
    this.converId = null;
  }

  // Créer une nouvelle conversation
  async startConversation() {
    const response = await fetch(`${this.baseUrl}/aichat/new-chat`, {
      method: 'POST',
      headers: {
        'Authorization': `Bearer ${this.apiToken}`,
        'Content-Type': 'application/json'
      },
      body: JSON.stringify({ category_id: '1' })
    });

    const data = await response.json();
    this.converId = data.conver_id;
    console.log('✅ Conversation démarrée:', this.converId);
    return this.converId;
  }

  // Envoyer un message
  async sendMessage(message) {
    if (!this.converId) {
      throw new Error('Conversation non démarrée. Appelez startConversation() d\'abord.');
    }

    const response = await fetch(`${this.baseUrl}/aichat/chat/chat-send`, {
      method: 'POST',
      headers: {
        'Authorization': `Bearer ${this.apiToken}`,
        'Content-Type': 'application/json'
      },
      body: JSON.stringify({
        conver_id: this.converId,
        prompt: message,
        category_id: '1'
      })
    });

    const data = await response.json();
    return data.response;
  }

  // Conversation multi-tours
  async chat(messages) {
    const responses = [];
    
    for (const message of messages) {
      console.log(`\n👤 Utilisateur: ${message}`);
      const response = await this.sendMessage(message);
      console.log(`🤖 IA: ${response}`);
      responses.push({ user: message, ai: response });
      
      // Pause entre les messages (rate limiting)
      await new Promise(resolve => setTimeout(resolve, 1000));
    }
    
    return responses;
  }
}

// Utilisation
async function example() {
  const chat = new OupiChat(process.env.OUPI_API_TOKEN);
  
  // Démarrer la conversation
  await chat.startConversation();
  
  // Conversation avec contexte
  const conversation = [
    "Bonjour, peux-tu m'aider ?",
    "J'aimerais créer un site web. Par où commencer ?",
    "Quels langages dois-je apprendre ?",
    "Merci pour tes conseils !"
  ];
  
  const responses = await chat.chat(conversation);
  console.log('\n📋 Résumé de la conversation:', responses);
}

example();

📜 Récupérer l'historique

Conversations récentes

Endpoint :

GET /api/aichat/recent-chats

Description : Récupère les 20 dernières conversations de l'utilisateur.

Exemple :

async function getRecentChats() {
  const response = await fetch(`${BASE_URL}/aichat/recent-chats`, {
    headers: {
      'Authorization': `Bearer ${API_TOKEN}`,
      'Content-Type': 'application/json'
    }
  });

  const data = await response.json();
  console.log(`📋 ${data.chats.length} conversations récentes`);
  
  return data.chats;
}

// Utilisation
getRecentChats()
  .then(chats => {
    chats.forEach(chat => {
      console.log(`- ${chat.title || 'Sans titre'} (${chat.conver_id})`);
      console.log(`  Créée: ${chat.created_at}`);
      console.log(`  Messages: ${chat.message_count}`);
    });
  });

Conversations par catégorie

Endpoint :

GET /api/aichat/history/{cat_slug}

Paramètres :

• cat_slug (string) : Slug de la catégorie (ex: "ai-chat-bot")

Exemple :

async function getChatsByCategory(categorySlug) {
  const response = await fetch(
    `${BASE_URL}/aichat/history/${categorySlug}`,
    {
      headers: {
        'Authorization': `Bearer ${API_TOKEN}`,
        'Content-Type': 'application/json'
      }
    }
  );

  const data = await response.json();
  return data.conversations;
}

// Utilisation
getChatsByCategory('ai-chat-bot')
  .then(conversations => {
    console.log(`Trouvé ${conversations.length} conversations`);
  });

🗑️ Supprimer une conversation

Endpoint

DELETE /api/aichat/history

Paramètres

Body (JSON) :

{
  "conver_id": "abc123def456"
}

Exemple

JavaScript :

async function deleteConversation(converId) {
  const response = await fetch(`${BASE_URL}/aichat/history`, {
    method: 'DELETE',
    headers: {
      'Authorization': `Bearer ${API_TOKEN}`,
      'Content-Type': 'application/json'
    },
    body: JSON.stringify({
      conver_id: converId
    })
  });

  if (response.ok) {
    console.log('✅ Conversation supprimée');
  } else {
    throw new Error('Échec de la suppression');
  }
}

// Utilisation
deleteConversation('abc123def456')
  .then(() => console.log('Conversation supprimée avec succès'))
  .catch(error => console.error('Erreur:', error));

✏️ Renommer une conversation

Endpoint

PATCH /api/aichat/history

Paramètres

Body (JSON) :

{
  "conver_id": "abc123def456",
  "title": "Discussion sur le machine learning"
}

Exemple

Python :

def rename_conversation(conver_id, new_title):
    headers = {
        'Authorization': f'Bearer {API_TOKEN}',
        'Content-Type': 'application/json'
    }
    
    data = {
        'conver_id': conver_id,
        'title': new_title
    }
    
    response = requests.patch(
        f'{BASE_URL}/aichat/history',
        headers=headers,
        json=data
    )
    
    if response.ok:
        print('✅ Conversation renommée')
    else:
        raise Exception('Échec du renommage')

# Utilisation
rename_conversation('abc123def456', 'Discussion sur le machine learning')

🎨 Cas d'usage avancés

1. Chatbot de support client

Fonctionnalités :

• Réponses automatiques aux questions fréquentes

• Détection d'intention

• Escalade vers humain si nécessaire

Exemple d'implémentation :

class SupportChatbot {
  constructor(apiToken) {
    this.chat = new OupiChat(apiToken);
    this.currentConversation = null;
  }

  async handleUserMessage(userId, message) {
    // Créer ou récupérer la conversation de l'utilisateur
    if (!this.currentConversation) {
      this.currentConversation = await this.chat.startConversation();
    }

    // Envoyer le message
    const response = await this.chat.sendMessage(message);

    // Analyser la réponse pour détecter si escalade nécessaire
    if (this.needsHumanIntervention(response)) {
      return {
        type: 'escalate',
        message: "Je vais vous mettre en contact avec un conseiller.",
        aiResponse: response
      };
    }

    return {
      type: 'ai_response',
      message: response
    };
  }

  needsHumanIntervention(response) {
    // Logique de détection (mots-clés, sentiment, etc.)
    const escalationKeywords = ['remboursement', 'annulation', 'urgence'];
    return escalationKeywords.some(keyword => 
      response.toLowerCase().includes(keyword)
    );
  }
}

// Utilisation
const supportBot = new SupportChatbot(process.env.OUPI_API_TOKEN);

// Simuler des messages utilisateurs
supportBot.handleUserMessage('user_123', 'Comment réinitialiser mon mot de passe ?')
  .then(result => console.log(result));

2. Assistant d'écriture contextuel

Fonctionnalités :

• Aide à la rédaction en temps réel

• Suggestions de reformulation

• Correction grammaticale

class WritingAssistant {
  constructor(apiToken) {
    this.chat = new OupiChat(apiToken);
    this.documentContext = '';
  }

  async startSession(initialContext) {
    await this.chat.startConversation();
    this.documentContext = initialContext;
  }

  async getSuggestion(currentText) {
    const prompt = `
      Contexte du document: ${this.documentContext}
      
      Texte actuel: "${currentText}"
      
      Propose 3 façons d'améliorer ou de continuer ce texte.
    `;

    const response = await this.chat.sendMessage(prompt);
    return this.parseSuggestions(response);
  }

  parseSuggestions(response) {
    // Parser la réponse pour extraire les suggestions
    // Retourner un tableau structuré
    return response.split('\n')
      .filter(line => line.trim())
      .map(suggestion => ({ text: suggestion }));
  }
}

// Utilisation
const assistant = new WritingAssistant(process.env.OUPI_API_TOKEN);
await assistant.startSession('Article sur le climat');
const suggestions = await assistant.getSuggestion('Le réchauffement climatique est un enjeu majeur...');
console.log('Suggestions:', suggestions);

3. Chatbot multilingue

Fonctionnalités :

• Détection automatique de la langue

• Réponses dans la langue de l'utilisateur

async function multilingualChat(userMessage) {
  const chat = new OupiChat(process.env.OUPI_API_TOKEN);
  await chat.startConversation();

  // Ajouter instruction pour répondre dans la même langue
  const prompt = `
    Réponds dans la même langue que l'utilisateur.
    
    Message utilisateur: ${userMessage}
  `;

  const response = await chat.sendMessage(prompt);
  return response;
}

// Test avec différentes langues
multilingualChat('Hello, how are you?').then(console.log);
multilingualChat('Bonjour, comment allez-vous ?').then(console.log);
multilingualChat('Hola, ¿cómo estás?').then(console.log);

💡 Bonnes pratiques

1. Gestion du contexte

Conservez le conver_id :

// ❌ Mauvais : Créer un nouveau chat à chaque message
async function badPattern(message) {
  const chat = await createNewChat();
  return await sendMessage(chat.conver_id, message);
  // Perd le contexte à chaque fois !
}

// ✅ Bon : Réutiliser la même conversation
class ChatSession {
  constructor() {
    this.converId = null;
  }

  async initialize() {
    const chat = await createNewChat();
    this.converId = chat.conver_id;
  }

  async send(message) {
    return await sendMessage(this.converId, message);
  }
}

2. Gestion des sessions utilisateur

Associez conversations à vos utilisateurs :

// Base de données ou cache
const userSessions = new Map();

async function getUserChat(userId) {
  if (!userSessions.has(userId)) {
    const chat = new OupiChat(API_TOKEN);
    await chat.startConversation();
    userSessions.set(userId, chat);
  }
  return userSessions.get(userId);
}

// Utilisation
async function handleUserMessage(userId, message) {
  const chat = await getUserChat(userId);
  return await chat.sendMessage(message);
}

3. Nettoyage des conversations

Supprimez les anciennes conversations :

async function cleanupOldChats() {
  const recentChats = await getRecentChats();
  const now = new Date();
  
  for (const chat of recentChats) {
    const chatDate = new Date(chat.created_at);
    const daysSinceCreation = (now - chatDate) / (1000 * 60 * 60 * 24);
    
    // Supprimer les chats de plus de 30 jours
    if (daysSinceCreation > 30) {
      await deleteConversation(chat.conver_id);
      console.log(`🗑️ Chat ${chat.conver_id} supprimé`);
    }
  }
}

// Exécuter périodiquement (cron job)
setInterval(cleanupOldChats, 24 * 60 * 60 * 1000); // Tous les jours

4. Rate limiting côté client

Évitez de surcharger l'API :

class RateLimitedChat {
  constructor(apiToken, maxRequestsPerMinute = 10) {
    this.chat = new OupiChat(apiToken);
    this.requests = [];
    this.maxRequests = maxRequestsPerMinute;
  }

  async sendMessage(message) {
    // Vérifier le rate limit
    await this.waitIfNeeded();
    
    // Enregistrer la requête
    this.requests.push(Date.now());
    
    // Envoyer le message
    return await this.chat.sendMessage(message);
  }

  async waitIfNeeded() {
    const now = Date.now();
    const oneMinuteAgo = now - 60000;
    
    // Nettoyer les anciennes requêtes
    this.requests = this.requests.filter(time => time > oneMinuteAgo);
    
    // Attendre si limite atteinte
    if (this.requests.length >= this.maxRequests) {
      const oldestRequest = this.requests[0];
      const waitTime = 60000 - (now - oldestRequest);
      console.log(`⏳ Rate limit atteint. Attente de ${waitTime}ms...`);
      await new Promise(resolve => setTimeout(resolve, waitTime));
    }
  }
}

🐛 Dépannage

Erreur : "Conversation not found"

Cause : Le conver_id est invalide ou la conversation a été supprimée.

Solution :

async function safeSendMessage(converId, message) {
  try {
    return await sendMessage(converId, message);
  } catch (error) {
    if (error.message.includes('not found')) {
      console.log('Conversation expirée, création d\'une nouvelle...');
      const newChat = await createNewChat();
      return await sendMessage(newChat.conver_id, message);
    }
    throw error;
  }
}

Erreur 419 : Plus de crédits

Solution :

async function sendMessageWithCreditCheck(converId, message) {
  // Vérifier les crédits avant
  const usage = await checkUsage();
  
  if (usage.remaining_credits < 100) {
    return {
      error: 'low_credits',
      message: 'Crédits insuffisants. Veuillez recharger.',
      redirectUrl: 'https://app.oupi.com/pricing'
    };
  }
  
  return await sendMessage(converId, message);
}

📊 Monitoring et analytics

Suivre l'utilisation

class ChatAnalytics {
  constructor() {
    this.metrics = {
      totalMessages: 0,
      totalTokens: 0,
      averageResponseTime: 0
    };
  }

  async sendMessageWithMetrics(converId, message) {
    const startTime = Date.now();
    
    const response = await sendMessage(converId, message);
    
    const endTime = Date.now();
    const responseTime = endTime - startTime;
    
    // Enregistrer les métriques
    this.metrics.totalMessages++;
    this.metrics.totalTokens += response.tokens_used;
    this.metrics.averageResponseTime = 
      (this.metrics.averageResponseTime * (this.metrics.totalMessages - 1) + responseTime) 
      / this.metrics.totalMessages;
    
    console.log(`📊 Métriques:`, this.metrics);
    
    return response;
  }

  getReport() {
    return {
      ...this.metrics,
      estimatedCost: this.metrics.totalTokens * 0.002, // Exemple de calcul
      averageResponseTimeSeconds: this.metrics.averageResponseTime / 1000
    };
  }
}

🎯 Checklist d'intégration

Avant de mettre en production votre chatbot :

• [ ] Gestion des sessions utilisateur implémentée

• [ ] Context maintenu entre les messages

• [ ] Gestion d'erreurs robuste (401, 419, 500)

• [ ] Rate limiting côté client

• [ ] Nettoyage des anciennes conversations

• [ ] Monitoring de l'utilisation

• [ ] Logs des erreurs

• [ ] Tests avec différents scénarios

• [ ] Fallback en cas d'échec API

• [ ] Documentation interne

Créez des conversations intelligentes avec l'API Chat OUPI ! 💬

Dernière mise à jour : Décembre 2024
Guide Chat AI - API OUPI v1.0