OrkaJS
Orka.JS

Knowledge & RAG

Indexez des documents, effectuez des recherches sémantiques et construisez des pipelines RAG avec Orka AI.

Pourquoi orka.knowledge ?

L'API orka.knowledge suit la philosophie de conception intent-based d'Orka. Au lieu de manipuler des concepts bas niveau comme les vecteurs, embeddings ou collections, vous travaillez avec une abstraction haut niveau appelée "knowledge" (connaissances).

Abstraction

Cache la complexité : le découpage, la génération d'embeddings, le stockage vectoriel et la recherche de similarité sont gérés automatiquement.

API Fluide

Noms de méthodes naturels : create(), add(), search(), delete(). Votre code se lit comme du français courant.

Configurable

Changez la VectorDB sous-jacente (Memory, Pinecone, Qdrant, Chroma) sans modifier votre code applicatif.

Cohérent

Même pattern que les autres APIs Orka : orka.ask(), orka.workflow(), orka.agent(), orka.knowledge.

Ce Qui Se Passe Sous le Capot

Quand vous appelez orka.knowledge.create(), Orka exécute un pipeline sophistiqué d'opérations :

1
Normalisation de la Source

Votre source (chaîne, tableau, chemin de fichier, URL) est convertie en un format Document[] uniforme. Chaque document reçoit un ID unique et des métadonnées.

2
Découpage (Chunking)

Les documents sont découpés en morceaux plus petits selon chunkSize (défaut : 1000 caractères) avec un chevauchement (défaut : 200 caractères) pour préserver le contexte aux frontières.

3
Génération des Embeddings

Chaque chunk est converti en un vecteur de haute dimension (embedding) via votre adaptateur LLM configuré. Ces vecteurs capturent le sens sémantique du texte.

4
Stockage Vectoriel

Une collection est créée dans votre VectorDB avec la dimension appropriée. Les vecteurs sont insérés par lots de 100 pour l'efficacité.

Référence API

create(options)

Crée une nouvelle base de connaissances à partir de vos documents sources. C'est le point d'entrée principal pour indexer du contenu.

const result = await orka.knowledge.create({
name: 'my-docs', // Required: unique name for this knowledge base
source: [...], // Required: content to index (see formats below)
chunkSize: 1000, // Optional: max characters per chunk (default: 1000)
chunkOverlap: 200, // Optional: overlap between chunks (default: 200)
metadata: { // Optional: metadata attached to all documents
category: 'support',
version: '1.0',
},
});
 
// Returns:
// {
// name: 'my-docs',
// documentCount: 5, // Number of source documents processed
// chunkCount: 23, // Total chunks created
// }
Comprendre Chunk Size & Overlap

chunkSize détermine combien de texte chaque vecteur représente. Petits chunks = récupération plus précise mais moins de contexte. Grands chunks = plus de contexte mais peuvent inclure des infos non pertinentes. chunkOverlap garantit que les informations importantes aux frontières des chunks ne sont pas perdues.

Formats de Source

Orka accepte plusieurs formats de source, détectant et traitant automatiquement chaque type :

* Chaîne Unique

Un long texte qui sera automatiquement découpé. Idéal pour les articles, pages de documentation, ou tout document unique.

await orka.knowledge.create({
name: 'article',
source: 'This is a very long article about AI... [thousands of characters]',
});
* Tableau de Chaînes

Plusieurs documents sous forme de tableau de chaînes. Chaque chaîne est traitée comme un document séparé, puis découpée individuellement.

await orka.knowledge.create({
name: 'faq',
source: [
'How do I reset my password? Go to Settings > Security > Reset Password...',
'How do I contact support? Email us at support@example.com or...',
'What are the pricing plans? We offer Free, Pro, and Enterprise tiers...',
],
});
* Objets Structurés avec Métadonnées

Documents avec métadonnées par document. Les métadonnées sont préservées et retournées dans les résultats de recherche pour le filtrage ou l'affichage.

await orka.knowledge.create({
name: 'products',
source: [
{ text: 'iPhone 15 Pro features...', metadata: { category: 'phones', brand: 'Apple' } },
{ text: 'Galaxy S24 Ultra specs...', metadata: { category: 'phones', brand: 'Samsung' } },
{ text: 'MacBook Pro M3 review...', metadata: { category: 'laptops', brand: 'Apple' } },
],
});
* Chemin de Fichier ou Répertoire

Chargement depuis le système de fichiers. Si c'est un répertoire, tous les fichiers texte (.txt, .md, .json, .csv, .html, .xml, .yaml, .js, .ts, .py, etc.) sont chargés récursivement.

// Single file
await orka.knowledge.create({
name: 'readme',
source: { path: './README.md' },
});
 
// Entire directory
await orka.knowledge.create({
name: 'docs',
source: { path: './documentation/' },
});
* URL (HTTP/HTTPS)

Récupère le contenu depuis une URL. Inclut des protections de sécurité : validation du protocole, timeout de 30s, limite de 50MB.

await orka.knowledge.create({
name: 'external-docs',
source: { url: 'https://example.com/api-documentation.html' },
});

Référence API

add(name, source, options?)

Ajoute plus de documents à une base de connaissances existante. Utilise les mêmes formats de source que create().

// Add new documents to existing knowledge base
const { addedChunks } = await orka.knowledge.add('my-docs', [
'New document content...',
'Another new document...',
], {
chunkSize: 1000,
chunkOverlap: 200,
metadata: { addedAt: '2024-01-15' },
});
 
console.log(`Added ${addedChunks} new chunks`);

search(name, query, options?)

Effectue une recherche sémantique sur une base de connaissances. Retourne les chunks les plus pertinents basés sur la similarité vectorielle.

const results = await orka.knowledge.search('my-docs', 'how to reset password', {
topK: 10, // Number of results to return (default: 5)
minScore: 0.7, // Minimum similarity score 0-1 (optional)
});
 
// Each result contains:
for (const result of results) {
console.log(result.id); // Unique chunk ID
console.log(result.content); // The chunk text
console.log(result.score); // Similarity score (0-1, higher = more relevant)
console.log(result.metadata); // { documentId, chunkIndex, ...your metadata }
}
Comment Fonctionne la Recherche Sémantique

Votre requête est convertie en vecteur d'embedding, puis comparée à tous les vecteurs stockés via la similarité cosinus. Cela trouve du contenu sémantiquement similaire même si les mots exacts ne correspondent pas. "reset password" correspondra à "changer mes identifiants" car ils ont un sens similaire.

delete(name)

Supprime une base de connaissances entière et tous ses vecteurs de la VectorDB.

await orka.knowledge.delete('my-docs');

Comment le RAG Fonctionne avec orka.ask()

RAG (Retrieval-Augmented Generation) combine votre base de connaissances avec la génération LLM. Quand vous appelez orka.ask() avec un paramètre knowledge, voici le flux complet :

Question UtilisateurEmbed RequêteRecherche VectorielleTop-K ChunksConstruire PromptLLMRéponse
// Basic RAG query
const answer = await orka.ask('How do I reset my password?', {
knowledge: 'my-docs', // Name of your knowledge base
topK: 5, // Number of chunks to retrieve
});
 
// With context inspection (for debugging)
const { answer, context } = await orka.ask('How do I reset my password?', {
knowledge: 'my-docs',
topK: 5,
includeContext: true, // Returns the chunks used
});
 
console.log('Answer:', answer);
console.log('Sources used:');
for (const chunk of context) {
console.log(`- [${chunk.score.toFixed(2)}] ${chunk.content.slice(0, 100)}...`);
}

Exemple Complet

Voici un exemple complet montrant comment construire un système de Q&A sur de la documentation :

knowledge-qa-example.ts
import { Orka } from 'orkajs/core';
import { OpenAIAdapter } from 'orkajs/adapters/openai';
import { MemoryVectorDB } from 'orkajs/adapters/memory';
 
// 1. Initialize Orka with adapters
const orka = new Orka({
llm: new OpenAIAdapter({ apiKey: process.env.OPENAI_API_KEY }),
vectorDB: new MemoryVectorDB(),
defaults: {
chunkSize: 800, // Smaller chunks for precise retrieval
chunkOverlap: 100,
topK: 3,
},
});
 
// 2. Create knowledge base from your docs
const { chunkCount } = await orka.knowledge.create({
name: 'product-docs',
source: { path: './docs/' },
metadata: { source: 'official-docs' },
});
console.log(`Indexed ${chunkCount} chunks`);
 
// 3. Add more content later
await orka.knowledge.add('product-docs', [
{ text: 'New feature: Dark mode is now available...', metadata: { type: 'release-note' } },
]);
 
// 4. Query with RAG
const { answer, context } = await orka.ask(
'How do I enable dark mode?',
{ knowledge: 'product-docs', includeContext: true }
);
 
console.log('Answer:', answer);
console.log('Based on', context.length, 'sources');
 
// 5. Direct search (without LLM)
const results = await orka.knowledge.search('product-docs', 'dark mode', { topK: 5 });
for (const r of results) {
console.log(`[${r.score.toFixed(2)}] ${r.content.slice(0, 80)}...`);
}

Conseils Pro

💡 Choisir la bonne taille de chunk

Pour Q&A : 500-1000 caractères. Pour résumé : 1500-2000 caractères. Pour code : 300-500 caractères. Expérimentez pour trouver ce qui fonctionne le mieux pour votre contenu.

💡 Utiliser les métadonnées pour filtrer

Ajoutez des métadonnées de catégorie, date, auteur ou type. Cela permet des recherches filtrées et aide à tracer quels documents ont contribué aux réponses.

💡 Déboguer avec includeContext

Utilisez toujours includeContext: true pendant le développement. Cela montre exactement quels chunks le LLM a utilisés, inestimable pour ajuster votre pipeline RAG.

💡 Considérer minScore

Définissez minScore (ex: 0.7) pour filtrer les résultats peu pertinents. Cela évite que le LLM soit confus par du contexte non pertinent.

Adaptateurs VectorDB Supportés

orka.knowledge fonctionne avec n'importe quel adaptateur VectorDB. Changez d'adaptateur sans modifier votre code applicatif :

MemoryVectorDB

En mémoire, parfait pour le développement et les tests

PineconeAdapter

Base vectorielle cloud managée, scale à des milliards

QdrantAdapter

Open-source, auto-hébergé ou cloud

ChromaAdapter

Open-source, embarqué ou client-serveur

// Development: in-memory
import { MemoryVectorDB } from 'orkajs/adapters/memory';
const vectorDB = new MemoryVectorDB();
 
// Production: Pinecone
import { PineconeAdapter } from 'orkajs/adapters/pinecone';
const vectorDB = new PineconeAdapter({
apiKey: process.env.PINECONE_API_KEY,
environment: 'us-east-1',
indexName: 'my-index',
});
 
// Same orka.knowledge API works with both!