Résilience & Fallback

Construisez des systèmes IA tolérants aux pannes avec retry automatique et fallback multi-fournisseurs.

Les systèmes IA en production doivent gérer les pannes API gracieusement. Orka fournit une logique de retry et des chaînes de fallback intégrées.

ORKA — RESILIENCE ARCHITECTURE

📤 orka.generate(prompt)

withRetry()

maxRetries: 3 | backoff: exponential

→

FallbackLLM

OpenAIPrincipal

↓ si échec

AnthropicFallback 1

↓ si échec

OllamaBackup local

✓ Réponse

rate limit

timeout

429

500

503

1. FallbackLLM - Chaîne Multi-Fournisseurs

Basculez automatiquement vers des fournisseurs de secours quand le principal échoue :

fallback-llm.ts

import { 
  createOrka, 
  OpenAIAdapter, 
  AnthropicAdapter, 
  OllamaAdapter,
  MemoryVectorAdapter,
  FallbackLLM,
} from 'orkajs';
 
// Fallback chain: OpenAI → Anthropic → Ollama local
const llm = new FallbackLLM({
  adapters: [
    new OpenAIAdapter({ apiKey: process.env.OPENAI_API_KEY! }),
    new AnthropicAdapter({ apiKey: process.env.ANTHROPIC_API_KEY! }),
    new OllamaAdapter({ model: 'llama3.2' }), // Backup local
  ],
  onFallback: (error, failedAdapter, nextAdapter) => {
    console.log(`⚠️  ${failedAdapter} failed (${error.message}), falling back to ${nextAdapter}`);
  },
});
 
const orka = createOrka({
  llm,
  vectorDB: new MemoryVectorAdapter(),
});
 
// If OpenAI fails, Anthropic automatically takes over.
const result = await orka.generate('Explain TypeScript in one sentence.');
console.log(`Response: ${result}`);

2. withRetry - Backoff Exponentiel

Réessayez automatiquement les requêtes échouées avec backoff exponentiel :

with-retry.ts

import { createOrka, OpenAIAdapter, MemoryVectorAdapter, withRetry } from 'orkajs';
 
const orka = createOrka({
  llm: new OpenAIAdapter({ apiKey: process.env.OPENAI_API_KEY! }),
  vectorDB: new MemoryVectorAdapter(),
});
 
// Automatic retry with exponential backoff
const result = await withRetry(
  () => orka.ask({ question: 'Explain TypeScript in one sentence.' }),
  {
    maxRetries: 3,
    initialDelayMs: 1000,      // First delay: 1s
    backoffMultiplier: 2,       // Multiplier: 1s → 2s → 4s
    maxDelayMs: 30000,          // Max delay: 30s
    retryableErrors: ['rate limit', 'timeout', '429', '500', '503'],
    onRetry: (error, attempt) => {
      console.log(`🔄 Retry ${attempt}: ${error.message}`);
    },
  },
);
 
console.log(`✅ Response: ${result.answer}`);
console.log(`📊 Tokens: ${result.usage.totalTokens}, Latency: ${result.latencyMs}ms`);

3. Wrapper ResilientLLM

Enveloppez n'importe quel adaptateur LLM avec des capacités de retry automatique :

resilient-llm.ts

import { createOrka, OpenAIAdapter, MemoryVectorAdapter, ResilientLLM } from 'orkajs';
 
// Wrapper that adds automatic retry to any LLM
const llm = new ResilientLLM(
  new OpenAIAdapter({ apiKey: process.env.OPENAI_API_KEY! }),
  {
    maxRetries: 3,
    initialDelayMs: 1000,
    backoffMultiplier: 2,
    retryableErrors: ['rate limit', 'timeout', '429', '500', '503'],
    onRetry: (error, attempt) => {
      console.log(`🔄 Retry ${attempt}: ${error.message}`);
    },
  }
);
 
const orka = createOrka({ llm, vectorDB: new MemoryVectorAdapter() });
 
// All requests automatically benefit from retry
const result = await orka.generate('Hello world');

4. Exemple Complet

resilience-complete.ts

import { 
  createOrka, 
  OpenAIAdapter, 
  AnthropicAdapter,
  OllamaAdapter,
  MemoryVectorAdapter,
  FallbackLLM,
  withRetry,
} from 'orkajs';
 
async function main() {
  // Configuration: Multi-vendor fallback
  const llm = new FallbackLLM({
    adapters: [
      new OpenAIAdapter({ apiKey: process.env.OPENAI_API_KEY! }),
      new AnthropicAdapter({ apiKey: process.env.ANTHROPIC_API_KEY! }),
      new OllamaAdapter({ model: 'llama3.2' }),
    ],
    onFallback: (error, failed, next) => {
      console.log(`⚠️  ${failed} failed (${error.message}), falling back to ${next}`);
    },
  });
 
  const orka = createOrka({
    llm,
    vectorDB: new MemoryVectorAdapter(),
  });
 
  // Combine Fallback + Retry for maximum resilience
  const result = await withRetry(
    () => orka.ask({ question: 'Explique TypeScript en une phrase.' }),
    {
      maxRetries: 3,
      initialDelayMs: 1000,
      backoffMultiplier: 2,
      retryableErrors: ['rate limit', 'timeout', '429', '500', '503'],
      onRetry: (error, attempt) => {
        console.log(`🔄 Retry ${attempt}: ${error.message}`);
      },
    },
  );
 
  console.log(`✅ Response: ${result.answer}`);
  console.log(`📊 Tokens: ${result.usage.totalTokens}, Latency: ${result.latencyMs}ms`);
}
 
main().catch(console.error);

Bonnes Pratiques

✓ Utiliser le Backoff Exponentiel

Évitez de marteler les APIs avec des retries immédiats. Utilisez des délais croissants.

✓ Inclure un Fallback Local

Ajoutez Ollama en dernier recours pour une indépendance API complète.

✓ Logger les Événements de Fallback

Surveillez quels fournisseurs échouent et à quelle fréquence pour la planification.

✓ Définir des Timeouts

Configurez timeoutMs sur les adaptateurs pour échouer rapidement et déclencher le fallback.