Fournisseurs LLM

Configurez les fournisseur pour OpenAI, Anthropic, Mistral et Ollama pourOrka JS.

OpenAI

GPT-4o, GPT-4o-mini, embeddings

new OpenAIAdapter({
  apiKey: process.env.OPENAI_API_KEY!,
  model: 'gpt-4o-mini',
  embeddingModel: 'text-embedding-3-small',
})

Anthropic

Claude 3.5 Sonnet, Claude 3 Opus

new AnthropicAdapter({
  apiKey: process.env.ANTHROPIC_API_KEY!,
  model: 'claude-3-5-sonnet-20241022',
})

Mistral

Mistral Small, Medium, Large

new MistralAdapter({
  apiKey: process.env.MISTRAL_API_KEY!,
  model: 'mistral-small-latest',
})

Ollama

Modèles locaux, sans clé API

new OllamaAdapter({
  model: 'llama3.2',
  baseURL: 'http://localhost:11434',
})

Google AI

Gemini 1.5 Flash, Pro

new GoogleAdapter({
  apiKey: process.env.GOOGLE_API_KEY!,
  model: 'gemini-1.5-flash',
})

Cohere

Command R+, embeddings

new CohereAdapter({
  apiKey: process.env.COHERE_API_KEY!,
  model: 'command-r-plus',
})

Replicate

Modèles open source, Llama, etc.

new ReplicateAdapter({
  apiKey: process.env.REPLICATE_API_TOKEN!,
  model: 'meta/llama-2-70b-chat',
})

Configuration des Adaptateurs

Chaque adaptateur accepte des options de configuration spécifiques. Voici les options complètes pour chaque fournisseur :

OpenAIAdapter

new OpenAIAdapter({
  apiKey: string,              // Requis: Clé API OpenAI
  model?: string,              // Par défaut: 'gpt-4o-mini'
  embeddingModel?: string,     // Par défaut: 'text-embedding-3-small'
  baseURL?: string,            // Endpoint API personnalisé (pour Azure, proxies)
  timeoutMs?: number,          // Délai d'attente de la requête en millisecondes
  maxRetries?: number,         // Tentatives de reprise en cas d'échec
})

generate(prompt, options)Générer une complétion de texte

embed(texts)Générer des embeddings pour les textes

chat(messages, options)Conversation multi-tours

AnthropicAdapter

new AnthropicAdapter({
  apiKey: string,              // Requis: Clé API Anthropic
  model?: string,              // Par défaut: 'claude-3-5-sonnet-20241022'
  maxTokens?: number,          // Nombre maximum de tokens par défaut pour les réponses
  timeoutMs?: number,          // Délai d'attente de la requête en millisecondes
})

Note : Anthropic ne fournit pas d'embeddings. Utilisez OpenAIAdapter pour les embeddings avec Anthropic pour la génération.

MistralAdapter

new MistralAdapter({
  apiKey: string,              // Requis: Clé API Mistral
  model?: string,              // Par défaut: 'mistral-small-latest'
  embeddingModel?: string,     // Par défaut: 'mistral-embed'
  timeoutMs?: number,          // Délai d'attente de la requête en millisecondes
})

OllamaAdapter

new OllamaAdapter({
  model: string,               // Requis: Nom du modèle (ex: 'llama3.2', 'mistral')
  baseURL?: string,            // Par défaut: 'http://localhost:11434'
  embeddingModel?: string,     // Modèle pour les embeddings (ex: 'nomic-embed-text')
})

Ollama s'exécute localement sans clé API. Installez depuis ollama.ai et téléchargez les modèles avec 'ollama pull llama3.2'.

# Interface LLMAdapter

Tous les adaptateurs implémentent l'interface LLMAdapter, garantissant un comportement cohérent :

interface LLMAdapter {
  // Générer du texte à partir d'un prompt
  generate(prompt: string, options?: GenerateOptions): Promise<GenerateResult>;
 
  // Générer des embeddings pour un ou plusieurs textes
  embed(texts: string | string[]): Promise<number[][]>;
 
  // Conversation multi-tours
  chat(messages: ChatMessage[], options?: ChatOptions): Promise<ChatResult>;
}
 
interface GenerateOptions {
  temperature?: number;    // 0-1, contrôle la randomness
  maxTokens?: number;      // Longueur maximale de la réponse
  systemPrompt?: string;   // Message système pour le contexte
  stopSequences?: string[]; // Arrête la génération à ces séquences
}
 
interface GenerateResult {
  content: string;         // Texte généré
  usage: TokenUsage;       // Consommation de tokens
  latencyMs: number;       // Temps de réponse
}

# Changer de Fournisseur

L'une des forces principales d'Orka AI est la portabilité entre fournisseurs. Votre code applicatif reste identique quel que soit le LLM utilisé :

import { createOrka } from '@orka-js/core';
import { OpenAIAdapter } from '@orka-js/openai';
import { OllamaAdapter } from '@orka-js/ollama';
import { MemoryVectorAdapter } from '@orka-js/memory';
 
// Développement: gratuit, local
const devLLM = new OllamaAdapter({ model: 'llama3.2' });
 
// Production: puissant, cloud
const prodLLM = new OpenAIAdapter({ 
  apiKey: process.env.OPENAI_API_KEY!,
  model: 'gpt-4o' 
});
 
// Le même code applicatif fonctionne avec les deux
const orka = createOrka({
  llm: process.env.NODE_ENV === 'production' ? prodLLM: devLLM,
  vectorDB: new MemoryVectorAdapter(),
});
 
// Cela fonctionne identiquement avec n'importe quel adaptateur
const answer = await orka.ask({
  question: 'What is TypeScript?',
  knowledge: 'docs',
});

# Comparaison des Modèles

Fournisseur	Force Majeure	Embeddings
OpenAI	Écosystème & Usage Général	Native Support
Anthropic	Sécurité & Raisonnement Complexe	External Required
Mistral AI	Efficience & Multilingue	Native Support
Ollama	Confidentialité & Dev Local	Native Support
Google AI	Multimodalité (Gemini)	Native Support
Cohere	Maîtrise du RAG Entreprise	Native Support
Replicate	Flexibilité Open Source	External Required

Stratégie Hybride Anthropic

Anthropic ne propose pas d'API d'embeddings native. Pour utiliser Claude avec des bases de connaissances, vous devez implémenter une architecture double : un adaptateur pour le raisonnement et un autre pour la recherche sémantique.

Configuration Recommandée

Reasoning (LLM)AnthropicAdapter

VectorizationOpenAIAdapter

Imports Tree-shakeable

// ✅ Importez uniquement les adaptateurs dont vous avez besoin
import { OpenAIAdapter } from '@orka-js/openai';
import { AnthropicAdapter } from '@orka-js/anthropic';
import { MistralAdapter } from '@orka-js/mistral';
import { OllamaAdapter } from '@orka-js/ollama';
import { GoogleAdapter } from '@orka-js/google';
import { CohereAdapter } from '@orka-js/cohere';
import { ReplicateAdapter } from '@orka-js/replicate';