Fournisseurs LLM

Configurez les adaptateurs OpenAI, Anthropic, Mistral et Ollama pour Orka AI.

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',
})

# 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,              // Required: OpenAI API key
  model?: string,              // Default: 'gpt-4o-mini'
  embeddingModel?: string,     // Default: 'text-embedding-3-small'
  baseURL?: string,            // Custom API endpoint (for Azure, proxies)
  timeoutMs?: number,          // Request timeout in milliseconds
  maxRetries?: number,         // Retry attempts on failure
})

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,              // Required: Anthropic API key
  model?: string,              // Default: 'claude-3-5-sonnet-20241022'
  maxTokens?: number,          // Default max tokens for responses
  timeoutMs?: number,          // Request timeout in milliseconds
})

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

MistralAdapter

new MistralAdapter({
  apiKey: string,              // Required: Mistral API key
  model?: string,              // Default: 'mistral-small-latest'
  embeddingModel?: string,     // Default: 'mistral-embed'
  timeoutMs?: number,          // Request timeout in milliseconds
})

OllamaAdapter

new OllamaAdapter({
  model: string,               // Required: Model name (e.g., 'llama3.2', 'mistral')
  baseURL?: string,            // Default: 'http://localhost:11434'
  embeddingModel?: string,     // Model for embeddings (e.g., '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 {
  // Generate text from a prompt
  generate(prompt: string, options?: GenerateOptions): Promise<GenerateResult>;
 
  // Generate embeddings for one or more texts
  embed(texts: string | string[]): Promise<number[][]>;
 
  // Multi-turn chat conversation
  chat(messages: ChatMessage[], options?: ChatOptions): Promise<ChatResult>;
}
 
interface GenerateOptions {
  temperature?: number;    // 0-1, controls randomness
  maxTokens?: number;      // Maximum response length
  systemPrompt?: string;   // System message for context
  stopSequences?: string[]; // Stop generation at these sequences
}
 
interface GenerateResult {
  content: string;         // Generated text
  usage: TokenUsage;       // Token consumption
  latencyMs: number;       // Response time
}

# 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 'orkajs/core';
import { OpenAIAdapter } from 'orkajs/adapters/openai';
import { OllamaAdapter } from 'orkajs/adapters/ollama';
import { MemoryVectorDB } from 'orkajs/adapters/memory';
 
// Development: free, local
const devLLM = new OllamaAdapter({ model: 'llama3.2' });
 
// Production: powerful, cloud
const prodLLM = new OpenAIAdapter({ 
  apiKey: process.env.OPENAI_API_KEY!,
  model: 'gpt-4o' 
});
 
// Same application code works with both
const orka = createOrka({
  llm: process.env.NODE_ENV === 'production' ? prodLLM: devLLM,
  vectorDB: new MemoryVectorDB(),
});
 
// This works identically with any adapter
const answer = await orka.ask({
  question: 'What is TypeScript?',
  knowledge: 'docs',
});

# Comparaison des Modèles

Fournisseur	Meilleur Pour	Embeddings
OpenAI	Usage général, meilleur écosystème	✅
Anthropic	Long contexte, sécurité, code	❌
Mistral	Européen, multilingue, économique	✅
Ollama	Local, confidentialité, développement	✅

⚠️ Note Anthropic

Anthropic ne fournit pas d'API d'embeddings. Si vous utilisez AnthropicAdapter comme LLM principal, vous aurez besoin d'un adaptateur séparé pour les embeddings (ex : OpenAI) lors de l'utilisation des fonctionnalités RAG.

Imports Tree-shakeable

// ✅ Import only the adapters you need
import { OpenAIAdapter } from 'orkajs/adapters/openai';
import { AnthropicAdapter } from 'orkajs/adapters/anthropic';
import { MistralAdapter } from 'orkajs/adapters/mistral';
import { OllamaAdapter } from 'orkajs/adapters/ollama';