Orchestration Multi-Modèle

// Load-balanced pool for simple requests
const cheapPool = new LoadBalancerLLM({
  adapters: [miniAdapter1, miniAdapter2],
  strategy: 'round_robin',
});
 
// Fallback chain for complex requests
const powerfulChain = new FallbackLLM({
  adapters: [gpt4oAdapter, claudeAdapter],
});
 
// Router that picks the right strategy
const llm = new RouterLLM({
  routes: [
    { condition: (p) => p.length > 1000, adapter: powerfulChain },
  ],
  defaultAdapter: cheapPool,
});

import { RouterLLM } from 'orkajs/orchestration';
import { OpenAIAdapter } from 'orkajs/adapters/openai';
 
const gpt4o = new OpenAIAdapter({ apiKey: '...', model: 'gpt-4o' });
const gpt4oMini = new OpenAIAdapter({ apiKey: '...', model: 'gpt-4o-mini' });
const claude = new AnthropicAdapter({ apiKey: '...', model: 'claude-3-sonnet' });
 
const router = new RouterLLM({
  routes: [
    // Route long prompts to GPT-4o (better at complex reasoning)
    { condition: (prompt) => prompt.length > 2000, adapter: gpt4o },
 
    // Route code-related prompts to Claude (strong at code)
    { condition: (prompt) => /(code|function|class|import)/i.test(prompt), adapter: claude },
 
    // Route math/calculation prompts to GPT-4o
    { condition: (prompt) => /(calculate|compute|math|equation)/i.test(prompt), adapter: gpt4o },
  ],
  defaultAdapter: gpt4oMini, // Fast and cheap for simple queries
});
 
// Usage
const result = await router.generate('Write a Python function to sort a list');
// → Routed to Claude (matches 'function' keyword)

import { ConsensusLLM } from 'orkajs/orchestration';
 
// Strategy 1: best_score — Judge picks the best response
const consensus = new ConsensusLLM({
  adapters: [gpt4oMini, claude, mistral],
  strategy: 'best_score',
  judge: gpt4o, // A more powerful model evaluates responses
  judgePrompt: 'Rate these responses 1-10 for accuracy and helpfulness. Return the best one.',
});
 
// Strategy 2: majority — Most common answer wins (good for factual questions)
const majorityConsensus = new ConsensusLLM({
  adapters: [gpt4oMini, claude, mistral],
  strategy: 'majority',
});
 
// Strategy 3: merge — Combine all responses (good for creative tasks)
const mergeConsensus = new ConsensusLLM({
  adapters: [gpt4oMini, claude],
  strategy: 'merge',
  mergePrompt: 'Combine these responses into a comprehensive answer.',
});
 
const result = await consensus.generate('What is the capital of France?');
// All 3 models are queried in parallel, then judge picks the best answer

import { RaceLLM } from 'orkajs/orchestration';
 
const race = new RaceLLM({
  adapters: [openai, anthropic, mistral],
  timeout: 10000, // 10s max wait time
});
 
const result = await race.generate('Quick question: what is 2+2?');
// Returns the first model to respond
// Other requests are cancelled (if supported by the adapter)
 
console.log(result.metadata?.adapter); // Which adapter won the race

import { LoadBalancerLLM } from 'orkajs/orchestration';
 
// Multiple API keys for the same model
const key1 = new OpenAIAdapter({ apiKey: process.env.OPENAI_KEY_1! });
const key2 = new OpenAIAdapter({ apiKey: process.env.OPENAI_KEY_2! });
const key3 = new OpenAIAdapter({ apiKey: process.env.OPENAI_KEY_3! });
 
const balancer = new LoadBalancerLLM({
  adapters: [key1, key2, key3],
  strategy: 'round_robin', // Rotate through adapters
});
 
// Strategies:
// - 'round_robin': Cycle through adapters in order (1, 2, 3, 1, 2, 3...)
// - 'random': Pick a random adapter each time
// - 'least_tokens': Pick the adapter that has used the fewest tokens
 
// Make 100 requests — they'll be distributed across all 3 keys
for (let i = 0; i < 100; i++) {
  await balancer.generate('Hello!');
}