OrkaJS
Orka.JS

Ask & Generate

Utilisez orka.ask() pour le Q&A le RAG etorka.generate() pour lagénération LLM directe.

Idea

Méthodes d'Importation

Import Standard

import { createOrka, OpenAIAdapter, MemoryVectorAdapter } from 'orkajs';

Import Optimisé

Recommandé
import { createOrka } from '@orka-js/core';
import { OpenAIAdapter } from '@orka-js/openai';
import { MemoryVectorAdapter } from '@orka-js/memory';

Active le tree-shaking pour minimiser la taille du bundle en production.

# orka.ask()

La méthode principale pour le question-réponse. Quand une base de connaissances est spécifiée, Orka AI effectue automatiquement du RAG (Retrieval-Augmented Generation). C'est la méthode la plus puissante pour construire des systèmes de Q&A.

// Utilisation basique avec le RAG
const result = await orka.ask({
question: 'Comment réinitialiser mon mot de passe?',
knowledge: 'support-docs', // Nom de votre base de connaissances
});
 
console.log(result.answer); // Pour réinitialiser votre mot de passe, allez dans Paramètres > Sécurité...
 
// Utilisation avancée avec toutes les options
const result = await orka.ask({
question: 'Comment réinitialiser mon mot de passe?',
knowledge: 'support-docs',
systemPrompt: 'Vous êtes un agent de support helpful. Soyez concis et amical.',
topK: 5, // Nombre de morceaux de contexte à récupérer
minScore: 0.7, // Score de similarité minimum pour les morceaux
temperature: 0.7, // Créativité du LLM (0-1)
maxTokens: 1024, // Longueur maximale de la réponse
includeContext: true, // Retourner les morceaux récupérés dans le résultat
});
 
console.log(result.answer); // La réponse générée
console.log(result.context); // Tableau des morceaux récupérés
console.log(result.latencyMs); // Temps d'exécution total
console.log(result.usage.totalTokens); // Tokens consommés

Paramètres

question
string

La requête principale. OrkaJS l'utilise pour trouver le contexte et générer la réponse.

required
knowledge
string

Base de connaissances cible. Si omis, le LLM répond uniquement avec ses données internes.

optional
topK
number

Contrôle la densité du RAG. Détermine combien de chunks sémantiques sont injectés dans le prompt.

default: 5
minScore
number

Seuil de similarité. Les chunks avec un score inférieur seront ignorés pour éviter les hallucinations.

0.0 to 1.0
systemPrompt
string

Remplace l'identité par défaut de l'agent. Utile pour imposer un persona ou un format spécifique.

optional
temperature
number

Des valeurs hautes rendent la réponse plus aléatoire, des valeurs basses la rendent plus déterministe.

default: 0.7
includeContext
boolean

Flag de débogage. Si activé, les chunks sources utilisés sont retournés dans l'objet de réponse.

default: false

Valeur de Retour

interface AskResult {
answer: string; // La réponse générée
context?: ChunkResult[]; // Morceaux récupérés (si includeContext: true)
latencyMs: number; // Temps d'exécution total en millisecondes
usage: {
promptTokens: number; // Tokens dans la requête
completionTokens: number; // Tokens dans la réponse
totalTokens: number; // Total de tokens consommés
};
}

# orka.generate()

Génération LLM directe sans RAG. Utilisez pour des tâches créatives, transformations de texte, résumé, ou toute tâche qui ne nécessite pas de connaissances externes.

// Génération simple
const response = await orka.generate('Write a haiku about TypeScript');
console.log(response); // "Types flow like water..." (string)
 
// Avec options
const response = await orka.generate('Résumez cet article: [article text]', {
temperature: 0.3, // Plus bas pour une sortie plus déterministe
maxTokens: 200, // Limite la longueur de la réponse
systemPrompt: 'Vous êtes un résumé professionnel. Soyez concis.',
});
 
// Écriture créative
const story = await orka.generate('Écris une courte histoire sur un robot', {
temperature: 0.9, // Plus haut pour plus de créativité
maxTokens: 1000,
systemPrompt: 'Vous êtes un écrivain de fiction créatif.',
});
 
// Génération de code
const code = await orka.generate('Écris une fonction TypeScript pour trier un tableau', {
temperature: 0.2, // Bas pour du code précis
systemPrompt: 'Vous êtes un expert développeur TypeScript. Retournez uniquement du code.',
});

Paramètres

prompt
string

L'instruction principale. C'est le texte central que le LLM va traiter.

required
options.temperature
number

Contrôle l'aléatoire. Utilisez 0 pour la logique pure et 0.8+ pour les tâches créatives.

default: 0.7
options.maxTokens
number

Limite stricte de longueur de réponse. Évite les générations infinies et contrôle les coûts.

optional
options.systemPrompt
string

Instructions initiales définissant le persona, le ton et les contraintes de l'assistant.

optional

# orka.embed()

Générez des embeddings vectoriels pour du texte. Les embeddings sont des vecteurs de haute dimension qui capturent le sens sémantique. Utilisez pour des comparaisons de similarité personnalisées, du clustering, ou construire vos propres systèmes de récupération.

// Single text embedding
const [embedding] = await orka.embed('Bonjour le monde');
console.log(embedding.length); // e.g., 1536 (dépend du modèle)
console.log(embedding[0]); // e.g., 0.0234 (première dimension)
 
// Multiple texts (batched for efficiency)
const embeddings = await orka.embed([
'Comment réinitialiser mon mot de passe?',
'J'ai oublié mes identifiants de connexion',
'Quel est le temps aujourd'hui?',
]);
 
// Compare similarity (cosine similarity)
function cosineSimilarity(a: number[], b: number[]): number {
const dot = a.reduce((sum, val, i) => sum + val * b[i], 0);
const magA = Math.sqrt(a.reduce((sum, val) => sum + val * val, 0));
const magB = Math.sqrt(b.reduce((sum, val) => sum + val * val, 0));
return dot / (magA * magB);
}
 
const sim1 = cosineSimilarity(embeddings[0], embeddings[1]); // ~0.85 (similar)
const sim2 = cosineSimilarity(embeddings[0], embeddings[2]); // ~0.45 (different)
Quand utiliser orka.embed()

Utilisez orka.embed() quand vous avez besoin d'embeddings bruts pour une logique personnalisée. Pour le RAG standard, utilisez orka.knowledge.create() et orka.ask() — ils gèrent les embeddings automatiquement.

Exemple Complet

ask-generate-example.ts
import { createOrka } from '@orka-js/core';
import { OpenAIAdapter } from '@orka-js/openai';
import { MemoryVectorAdapter } from '@orka-js/memory';
 
const orka = createOrka({
llm: new OpenAIAdapter({ apiKey: process.env.OPENAI_API_KEY! }),
vectorDB: new MemoryVectorAdapter(),
});
 
// 1. Créer une base de connaissances
await orka.knowledge.create({
name: 'product-docs',
source: [
'Notre produit supporte le mode sombre. Allez dans Paramètres > Apparence pour l'activer.',
'Pour réinitialiser votre mot de passe, cliquez sur "Mot de passe oublié" sur la page de connexion.',
'Les utilisateurs premium ont accès à des appels API illimités et un support prioritaire.',
],
});
 
// 2. Poser des questions le RAG
const result = await orka.ask({
question: 'Comment activer le mode sombre?',
knowledge: 'product-docs',
topK: 3,
includeContext: true,
});
 
console.log('Answer:', result.answer);
// "To enable dark mode, go to Settings > Appearance."
 
console.log('Sources:', result.context?.map(c => c.content.slice(0, 50)));
// ["Our product supports dark mode. Go to Settings > ..."]
 
// 3. Génération directe (pas de RAG)
const summary = await orka.generate(
'Résume: ' + result.answer,
{ temperature: 0.3, maxTokens: 50 }
);
 
// 4. Obtenir des embeddings pour une logique personnalisée
const [queryEmbed] = await orka.embed('paramètres du mode sombre');
console.log('Dimensions de l'embedding:', queryEmbed.length);

Tableau de Comparaison

MéthodeUsage PrincipalRetour
orka.ask()
Q&A basé sur connaissances (RAG)INTELLIGENT
{ answer, usage }
orka.generate()
Complétion & TransformationCRÉATIF
string
orka.embed()
Vecteurs & Similarité sémantiqueCORE
number[][]

Imports Tree-shakeable

// Import depuis le package principal
import { createOrka } from '@orka-js/core';
 
// Import des adaptateurs séparément
import { OpenAIAdapter } from '@orka-js/openai';
import { MemoryVectorAdapter } from '@orka-js/memory';