En tant qu'architecte solutions ayant déployé des systèmes de service client IA dans une dizaine d'établissements bancaires français et chinois, je partage aujourd'hui mon retour d'expérience terrain sur la construction d'un agent conversationnel bancaire capable de router intelligemment les requêtes et de collaborer avec les conseillers humains. Après six mois de production et plus de 2,3 millions de conversations traitées, voici ce que j'aurais voulu savoir avant de commencer.

Pourquoi le routage intelligent change tout en banque

Un service client bancaire standard traite simultanément des demandes triviales (soldes, relevés) et des opérations sensibles (litiges, réclamations, conseils patrimoniaux). Le routage intelligent permet d'orienter instantanément chaque requête vers le bon canal — bot, humains spécialisés, ou escalade — en fonction de l'intention détectée, du profil client, et de la complexité détectée.

Architecture du système de routage

Le système repose sur trois piliers fondamentaux qui fonctionnent en cascade : classification d'intention en temps réel (latence cible : moins de 50ms), pool de modèles spécialisés par tâche, et mécanisme d'escalade conditionnelle basé sur des règles métier et du Machine Learning.

Mise en Place Technique

Dépendance et configuration

npm install @holysheep/ai-sdk uuid express body-parser

Configuration de base

// config.js
module.exports = {
  apiKey: process.env.HOLYSHEEP_API_KEY || 'YOUR-HOLYSHEEP-API-KEY',
  baseUrl: 'https://api.holysheep.ai/v1',
  
  // Modèles par catégorie de requête
  models: {
    classification: 'gpt-4.1',
    response_simple: 'deepseek-v3.2',
    response_complex: 'claude-sonnet-4.5',
    financial: 'gemini-2.5-flash'
  },
  
  // Seuils de confiance pour escalade
  thresholds: {
    high_confidence: 0.85,
    medium_confidence: 0.65,
    escalation: 0.50
  },
  
  // Latence max par type (ms)
  latency: {
    classification: 50,
    response: 200,
    escalation: 500
  }
};

Implémentation du classificateur d'intention

// intent-classifier.js
const HOLYSHEEP_BASE = 'https://api.holysheep.ai/v1';

class BankingIntentClassifier {
  constructor(apiKey) {
    this.apiKey = apiKey;
  }

  async classify(message, context = {}) {
    const startTime = Date.now();
    
    const systemPrompt = `Tu es un classifier bancaire expert. Analyse le message du client 
et retourne un JSON avec :
- intent: l'intention détectée (solde, reclamation, conseil, authentication, general)
- confidence: score de confiance 0-1
- complexity: low|medium|high
- escalation_needed: boolean
- suggested_action: action recommandée`;

    const userPrompt = `Message: "${message}"
Profil client: ${context.clientTier || 'standard'}
Historique: ${context.previousIssues || 'aucun'}`;

    try {
      const response = await fetch(${HOLYSHEEP_BASE}/chat/completions, {
        method: 'POST',
        headers: {
          'Authorization': Bearer ${this.apiKey},
          'Content-Type': 'application/json'
        },
        body: JSON.stringify({
          model: 'gpt-4.1',
          messages: [
            { role: 'system', content: systemPrompt },
            { role: 'user', content: userPrompt }
          ],
          temperature: 0.1,
          max_tokens: 150,
          response_format: { type: 'json_object' }
        })
      });

      const latency = Date.now() - startTime;
      
      if (latency > 50) {
        console.warn(⚠️ Latence classification: ${latency}ms (cible: 50ms));
      }

      const data = await response.json();
      return {
        ...JSON.parse(data.choices[0].message.content),
        latency_ms: latency,
        model: 'gpt-4.1'
      };
    } catch (error) {
      console.error('Classification error:', error);
      throw error;
    }
  }
}

module.exports = BankingIntentClassifier;

Routeur principal avec escalade humaine

// banking-router.js
const BankingIntentClassifier = require('./intent-classifier');

class BankingRouter {
  constructor(apiKey) {
    this.classifier = new BankingIntentClassifier(apiKey);
    this.humanQueue = [];
    this.metrics = { processed: 0, escalated: 0, avgLatency: 0 };
  }

  async route(message, sessionId, clientContext) {
    const requestStart = Date.now();
    
    // Étape 1: Classification en moins de 50ms
    const classification = await this.classifier.classify(message, clientContext);
    console.log(📊 Intent: ${classification.intent} (${(classification.confidence * 100).toFixed(1)}%));
    
    // Étape 2: Routage vers le bon modèle
    let response;
    let modelUsed;
    
    if (classification.intent === 'authentication') {
      modelUsed = 'gpt-4.1';
      response = await this.handleAuthentication(message);
    } 
    else if (classification.complexity === 'low') {
      modelUsed = 'deepseek-v3.2';
      response = await this.handleSimpleRequest(message, classification);
    }
    else if (classification.intent === 'reclamation' || classification.complexity === 'high') {
      modelUsed = 'claude-sonnet-4.5';
      response = await this.handleComplexRequest(message, classification);
    }
    else {
      modelUsed = 'gemini-2.5-flash';
      response = await this.handleGeneralRequest(message, classification);
    }
    
    // Étape 3: Gestion escalade si nécessaire
    if (classification.escalation_needed || classification.confidence < 0.65) {
      await this.escalateToHuman(sessionId, message, classification);
      response = {
        ...response,
        escalated: true,
        waitTime: this.getEstimatedWaitTime()
      };
    }
    
    // Étape 4: Logging et métriques
    const totalLatency = Date.now() - requestStart;
    this.updateMetrics(totalLatency, classification.escalation_needed);
    
    return {
      response: response,
      metadata: {
        intent: classification.intent,
        confidence: classification.confidence,
        model: modelUsed,
        latency_ms: totalLatency,
        escalated: classification.escalation_needed
      }
    };
  }

  async handleSimpleRequest(message, classification) {
    const response = await fetch('https://api.holysheep.ai/v1/chat/completions', {
      method: 'POST',
      headers: { 'Authorization': Bearer ${this.classifier.apiKey} },
      body: JSON.stringify({
        model: 'deepseek-v3.2

Ressources connexes
Articles connexes