Définition

Le Chunkability Score (score de découpabilité) mesure de 0 à 100 la facilité avec laquelle un contenu web peut être segmenté en "chunks" (fragments) exploitables par les moteurs RAG (Retrieval-Augmented Generation). Un score élevé indique une structure claire avec des titres hiérarchiques, des paragraphes distincts et une table des matières — des signaux qui permettent aux IA de découper, indexer et restituer le contenu avec précision.

Deep Dive

Chunkability Score : structurer pour les IA

Pourquoi la "découpabilité" compte

Les moteurs RAG (Perplexity, Bing Chat, Google SGE) ne lisent pas une page entière. Ils :

1. **Découpent** le contenu en fragments de 200-500 tokens

2. **Indexent** chaque chunk avec un embedding vectoriel

3. **Récupèrent** les chunks les plus pertinents pour une requête donnée

4. **Synthétisent** une réponse à partir des chunks sélectionnés

Comment le score est calculé

Le Chunkability Score analyse 4 signaux structurels (sans appel LLM) :

| Signal | Poids | Mesure |

|--------|-------|--------|

| Titres H2/H3 | 30% | Nombre et hiérarchie des sous-titres |

| Paragraphes distincts | 25% | Ratio paragraphes / longueur totale |

| Table des matières | 25% | Présence d'un sommaire ou TOC |

| Longueur moyenne | 20% | Paragraphes de 100-300 mots (optimal) |

Score et interprétation

**80-100** : Excellent — contenu parfaitement structuré pour le RAG

**50-79** : Correct — quelques améliorations structurelles possibles

**0-49** : Faible — contenu monolithique, difficile à exploiter par les IA

Optimisation

Ajouter des H2 tous les 200-400 mots

Inclure une table des matières (TOC) en début de page

Découper les longs paragraphes (>150 mots) en sections distinctes

Utiliser des listes à puces pour les énumérations

Placer un résumé (TL;DR) en introduction

Code Playground

Calcul du Chunkability Score basé sur l'analyse DOM de la page

typescript

// Calcul déterministe du Chunkability Score
interface ChunkabilityResult {
  score: number;
  paragraphCount: number;
  headingCount: number;
  hasToc: boolean;
  avgParagraphLength: number;
}

function computeChunkabilityScore(html: string): ChunkabilityResult {
  const doc = new DOMParser().parseFromString(html, 'text/html');
  
  // Compter les titres H2/H3
  const headings = doc.querySelectorAll('h2, h3');
  const headingCount = headings.length;
  
  // Compter les paragraphes
  const paragraphs = doc.querySelectorAll('p');
  const paraTexts = Array.from(paragraphs).map(p => p.textContent || '');
  const paragraphCount = paraTexts.filter(t => t.length > 50).length;
  
  // Longueur moyenne des paragraphes
  const avgLen = paraTexts.reduce((s, t) => s + t.split(' ').length, 0) 
    / Math.max(paragraphCount, 1);
  
  // Détection TOC
  const hasToc = !!doc.querySelector('nav, [class*="toc"], [id*="toc"]')
    || doc.querySelectorAll('a[href^="#"]').length >= 3;
  
  // Scoring
  let score = 0;
  score += Math.min(30, headingCount * 5);           // max 30
  score += Math.min(25, paragraphCount * 2.5);        // max 25
  score += hasToc ? 25 : 0;                           // max 25
  score += avgLen >= 30 && avgLen <= 100 ? 20 : 10;   // max 20
  
  return {
    score: Math.min(100, Math.round(score)),
    paragraphCount, headingCount, hasToc,
    avgParagraphLength: Math.round(avgLen)
  };
}

Avis d'Expert 2026

Le Chunkability Score est le pont entre le SEO technique et le GEO. En 2026, une page parfaitement optimisée pour Google mais monolithique (un seul bloc de texte) sera invisible pour les moteurs RAG. La structuration du contenu en chunks est devenue aussi importante que les balises title et meta description.

Chunkability Score