Découpeurs de Texte

Découpez les documents en chunks optimisés pour les embeddings et la récupération avec des stratégies intelligentes.

Pourquoi Découper le Texte ?

Les documents volumineux doivent être découpés en chunks plus petits pour une recherche sémantique et une injection de contexte efficaces. Un bon découpage préserve le sens et respecte la structure du document.

🎯

Taille de Chunk Optimale

500-1000 caractères pour Q&A, 1500-2000 pour résumé

🔗

Chevauchement

10-20% de chevauchement préserve le contexte aux frontières

📐

Conscient de la Structure

Découpe sur paragraphes, phrases, pas en milieu de mot

# RecursiveCharacterTextSplitter

Le découpeur le plus polyvalent. Utilise des séparateurs hiérarchiques pour découper le texte tout en préservant les limites sémantiques. Essaie de découper sur les paragraphes d'abord, puis les phrases, puis les mots, et enfin les caractères en dernier recours.

import { RecursiveCharacterTextSplitter } from 'orkajs/splitters/recursive';
 
const splitter = new RecursiveCharacterTextSplitter({
  chunkSize: 1000,           // Target chunk size in characters
  chunkOverlap: 200,         // Overlap between chunks
  separators: ['\n\n', '\n', '. ', ' ', ''],  // Try these in order
  keepSeparator: true,       // Keep separators in chunks
  trimWhitespace: true       // Remove leading/trailing whitespace
});
 
const text = `Long document content here...`;
const chunks = splitter.split(text);
 
// Or split multiple documents
const documents = [
  { id: '1', content: 'Doc 1...', metadata: {} },
  { id: '2', content: 'Doc 2...', metadata: {} }
];
const allChunks = splitter.splitDocuments(documents);

🎯 Comment Ça Marche

Essaie de découper sur les doubles retours à la ligne (paragraphes)
Si les chunks sont encore trop grands, essaie les retours à la ligne simples
Puis les phrases (points), puis les mots (espaces)
Enfin les caractères en dernier recours
Maintient un chevauchement pour la continuité du contexte

# MarkdownTextSplitter

Découpeur spécialisé pour Markdown qui respecte la structure du document : en-têtes, blocs de code et listes. Parfait pour la documentation où maintenir la hiérarchie et les exemples de code est crucial.

import { MarkdownTextSplitter } from 'orkajs/splitters/markdown';
 
const splitter = new MarkdownTextSplitter({
  chunkSize: 1000,
  chunkOverlap: 200
});
 
const markdown = `
## Introduction
 
This is a paragraph...
 
### Subsection
 
More content here...
 
\`\`\`typescript
const code = 'example';
\`\`\`
`;
 
const chunks = splitter.split(markdown);
// Splits at headers, preserving structure

Séparateur	Priorité	Description
`\\n##`	1	En-têtes H2
`\\n###`	2	En-têtes H3
\\n\`\`\`\\n	3	Blocs de code
`\\n---\\n`	4	Lignes horizontales
`\\n\\n`	5	Paragraphes

# CodeTextSplitter

Découpeur conscient du langage qui respecte la structure du code : classes, fonctions et blocs. Utilise des séparateurs spécifiques au langage pour découper aux frontières naturelles comme les définitions de fonctions, déclarations de classes et instructions d'import.

import { CodeTextSplitter } from 'orkajs/splitters/code';
 
const splitter = new CodeTextSplitter({
  language: 'typescript',  // or 'python', 'javascript', 'java', etc.
  chunkSize: 1000,
  chunkOverlap: 200
});
 
const code = `
export class MyClass {
  constructor() {}
 
  method1() {
    // implementation
  }
 
  method2() {
    // implementation
  }
}
 
export function helperFunction() {
  // implementation
}
`;
 
const chunks = splitter.split(code);
// Splits at class/function boundaries

Langages Supportés

• TypeScript

• JavaScript

• Python

• Java

• Go

• Rust

• C++

• HTML

• CSS

# TokenTextSplitter

Découpe le texte en fonction du nombre de tokens estimé, utile pour rester dans les limites de contexte du LLM. Utilise une estimation du ratio caractères-tokens (défaut : 4 caractères par token pour l'anglais) pour garantir que les chunks respectent les contraintes du modèle.

import { TokenTextSplitter } from 'orkajs/splitters/token';
 
const splitter = new TokenTextSplitter({
  chunkSize: 500,                    // Target tokens per chunk
  chunkOverlap: 50,                  // Overlap in tokens
  estimatedTokensPerChar: 0.25       // ~4 chars per token (English)
});
 
const text = `Long document...`;
const chunks = splitter.split(text);
 
// Each chunk is approximately 500 tokens

⚠️ Estimation de Tokens

Ce découpeur utilise une estimation basée sur les caractères. Pour un comptage précis des tokens, considérez l'utilisation d'une bibliothèque de tokenisation comme tiktoken ou gpt-tokenizer.

Comparaison

Découpeur	Idéal Pour	Préserve
RecursiveCharacter	Texte général, articles, livres	Paragraphes, phrases
Markdown	Documentation, READMEs	En-têtes, blocs de code
Code	Fichiers de code source	Classes, fonctions
Token	Limites de contexte LLM	Limites de tokens

Exemple Complet

Voici un pipeline complet montrant comment charger, découper et indexer des documents :

import { createOrka } from 'orkajs';
import { MarkdownLoader } from 'orkajs/loaders/markdown';
import { RecursiveCharacterTextSplitter } from 'orkajs/splitters/recursive';
 
const orka = createOrka({ /* config */ });
 
// 1. Load documents
const loader = new MarkdownLoader('./docs/guide.md');
const documents = await loader.load();
 
// 2. Split into chunks
const splitter = new RecursiveCharacterTextSplitter({
  chunkSize: 1000,
  chunkOverlap: 200
});
const chunks = splitter.splitDocuments(documents);
 
// 3. Create knowledge base
await orka.knowledge.create({
  name: 'documentation',
  source: chunks.map(c => ({
    text: c.content,
    metadata: c.metadata
  }))
});
 
// 4. Query
const result = await orka.ask({
  knowledge: 'documentation',
  question: 'How do I configure Orka AI?'
});

Imports Tree-shakeable

Importez uniquement ce dont vous avez besoin pour minimiser la taille du bundle :

// ✅ Import only what you need
import { RecursiveCharacterTextSplitter } from 'orkajs/splitters/recursive';
import { MarkdownTextSplitter } from 'orkajs/splitters/markdown';
 
// ✅ Or import from index
import { RecursiveCharacterTextSplitter, CodeTextSplitter } from 'orkajs/splitters';