OCR & Extraction de Documents

Extrayez du texte à partir d'images, PDFs et documents scannés. Support des moteurs OCR locaux (Tesseract) et cloud (OpenAI Vision).

80%Données Invisibles

Déverrouiller le Savoir d'Entreprise

La majorité des actifs d'entreprise résident dans des formats 'Dark Data'. Sans OCR, ils sont invisibles pour votre LLM. OrkaJS transforme ces images en texte structuré et indexable, convertissant vos archives mortes en contexte RAG vivant.

PDFs Scannés

Manuscrit

Factures

Captures

Installation

# Install OCR package
npm install @orka-js/ocr
 
# For local OCR (Tesseract) - RGPD-friendly
npm install tesseract.js
 
# For cloud OCR (OpenAI Vision) - no additional deps needed

Démarrage Rapide

import { OCR } from '@orka-js/ocr';
 
// Avec Tesseract (local, conforme RGPD)
const ocr = new OCR();
const result = await ocr.process('./document.png');
console.log(result.text);
 
// Avec OpenAI Vision (cloud, haute précision)
const cloudOcr = new OCR({
  type: 'openai-vision',
  config: { apiKey: process.env.OPENAI_API_KEY! },
});
const cloudResult = await cloudOcr.process('./invoice.pdf');

Moteurs OCR

Tesseract OCR

Souveraineté / Moteur Local

"Le standard open-source pour le traitement local."

Conformité RGPD

Données 100% locales

Zéro Coût Variable

Pas de frais à la page

Précision réduite sur scans dégradés

GPT-4o Vision

Intelligence / Cloud Vision

"Vision de pointe pour l'analyse de layouts complexes."

Précision SOTA

Compréhension profonde

Logique Structurelle

Gère tableaux & formulaires

Nécessite transfert de données

Moteur Tesseract

import { TesseractEngine } from '@orka-js/ocr';
 
const engine = new TesseractEngine({
  cacheWorker: true, // Réutiliser le worker pour de meilleures performances
});
 
const result = await engine.process('./document.png', {
  languages: ['eng', 'fra'], // Anglais + Français
  minConfidence: 0.7,
});
 
console.log(result.text);
console.log(`Confidence: ${result.confidence}`);
 
// N'oubliez pas de nettoyer à la fin
await engine.terminate();

Moteur OpenAI Vision

import { OpenAIVisionEngine } from '@orka-js/ocr';
 
const engine = new OpenAIVisionEngine({
  apiKey: process.env.OPENAI_API_KEY!,
  model: 'gpt-4o', // ou 'gpt-4-vision-preview'
  maxTokens: 4096,
});
 
const result = await engine.process('./complex-form.pdf', {
  extractTables: true,
  extractFields: true,
});
 
console.log(result.text);
console.log('Tables:', result.tables);
console.log('Fields:', result.fields);

Extraction Structurée de Documents

Extrayez des données structurées à partir de documents en utilisant une définition de schéma. Combine OCR et LLM pour une extraction intelligente.

import { DocumentExtractor } from '@orka-js/ocr';
import { OpenAIAdapter } from '@orka-js/openai';
 
const extractor = new DocumentExtractor();
 
const result = await extractor.extract({
  file: './invoice.pdf',
  schema: {
    invoiceNumber: 'string',
    date: 'date',
    total: 'number',
    client: {
      type: 'object',
      properties: {
        name: { type: 'string', required: true },
        address: { type: 'string' },
      },
    },
    items: {
      type: 'array',
      items: {
        type: 'object',
        properties: {
          description: { type: 'string' },
          quantity: { type: 'number' },
          unitPrice: { type: 'number' },
        },
      },
    },
  },
  llm: new OpenAIAdapter({ apiKey: process.env.OPENAI_API_KEY! }),
  includeRawText: true,
});
 
console.log(result.data);
// {
//   invoiceNumber: 'INV-2024-001',
//   date: '2024-03-15',
//   total: 1250.00,
//   client: { name: 'Acme Corp', address: '123 Main St' },
//   items: [
//     { description: 'Widget A', quantity: 10, unitPrice: 50 },
//     { description: 'Widget B', quantity: 5, unitPrice: 150 },
//   ]
// }

Types de Champs du Schéma

Type Primitif	Logique de Parsing	Exemple d'Entrée
`string`	Extraction de texte UTF-8 brut	`"OrkaJS SDK"`
`number`	Conversion Flottant/Entier	`42.50`
`date`	Casting temporel ISO 8601	`"2026-03-14"`
`boolean`	Évaluation de vérité binaire	`true`
`array`	Mapping de collection itératif	`['tag1', 'tag2']`
`object`	Structuration imbriquée récursive	`{ id: 1 }`

Structure du Résultat OCR

interface OCRResult {
  text: string;           // Texte extrait complet
  pages: OCRPage[];       // Résultats par page
  confidence: number;     // Confiance globale (0-1)
  tables?: ExtractedTable[];  // Tableaux extraits
  fields?: ExtractedField[];  // Champs de formulaire (clé-valeur)
  metadata: {
    engine: string;
    processingTimeMs: number;
    pageCount: number;
    language?: string;
  };
}
 
interface OCRPage {
  pageNumber: number;
  text: string;
  blocks: OCRBlock[];     // Blocs/paragraphes de texte
  confidence: number;
}
 
interface OCRBlock {
  text: string;
  lines: OCRLine[];
  confidence: number;
  type?: 'text' | 'table' | 'figure' | 'header' | 'footer';
}

Intégration avec Knowledge (RAG)

Utilisez l'OCR pour traiter les documents scannés avant de les ingérer dans votre base de connaissances :

import { OCR } from '@orka-js/ocr';
import { createOrka } from '@orka-js/core';
 
const ocr = new OCR();
const orka = createOrka({ /* config */ });
 
// Traiter les documents scannés
async function ingestScannedDocument(filePath: string, knowledgeName: string) {
  // Étape 1 : Extraire le texte avec OCR
  const ocrResult = await ocr.process(filePath);
 
  if (ocrResult.confidence < 0.7) {
    console.warn(`Low confidence OCR: ${ocrResult.confidence}`);
  }
 
  // Étape 2 : Ajouter à la base de connaissances
  await orka.knowledge.add(knowledgeName, {
    content: ocrResult.text,
    metadata: {
      source: filePath,
      ocrEngine: ocrResult.metadata.engine,
      ocrConfidence: ocrResult.confidence,
      pageCount: ocrResult.metadata.pageCount,
    },
  });
}
 
// Traiter un répertoire de PDFs scannés
const files = ['./docs/invoice1.pdf', './docs/contract.pdf'];
for (const file of files) {
  await ingestScannedDocument(file, 'company-docs');
}

Bonnes Pratiques de Déploiement

Standard Operating Procedures for OCR Pipelines

Sécurité & Conformité

Utilisez Tesseract pour le RGPD afin de garantir zéro fuite de données externe.

Profondeur Cognitive

Déployez OpenAI Vision pour l'analyse critique de tableaux et formulaires complexes.

Assurance Qualité

Validez les scores de confiance avant l'indexation dans votre Vector DB.

Performance & Coûts

Implémentez un cache pour éviter les coûts et calculs redondants.

Structuration Sémantique

Utilisez des schémas pour transformer les pixels en logique métier exploitable.

Hygiène des Ressources

Terminez explicitement les workers Tesseract pour éviter les fuites mémoire.