0Pricing
AI Agents · Leçon

Indexer un ensemble de documents

Générez un embedding pour chaque segment et stockez les vecteurs dans un index : l’étape de préparation hors ligne de tout système RAG.

Indexer un ensemble de documents est une leçon AI Agents gratuite sur CoddyKit. Ceci est la leçon 3 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage AI Agents, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours AI Agents comprend 4 leçons au total.

Chaîne d'ingestion

La chaîne RAG hors ligne comporte quatre étapes :

  1. Charger les documents (PDF, HTML, MD)
  2. Segmenter chaque document
  3. Vectoriser chaque segment
  4. Stocker les vecteurs et les métadonnées dans un index

Étape 1 : charger les documents

Utilisez des chargeurs spécialisés pour les différents formats :

# PDFs
from pypdf import PdfReader
text = ''
for page in PdfReader('doc.pdf').pages:
    text += page.extract_text()

# HTML
from bs4 import BeautifulSoup
text = BeautifulSoup(html, 'html.parser').get_text()

# Markdown — just read the file
text = open('doc.md').read()

Étape 2 : segmenter

Utilisez l'outil de segmentation de la leçon précédente :

from langchain.text_splitter import RecursiveCharacterTextSplitter
splitter = RecursiveCharacterTextSplitter(chunk_size=800, chunk_overlap=100)
chunks = splitter.split_text(text)

Étape 3 : vectoriser par lots

Vectorisez plusieurs segments par appel à l'API :

from openai import OpenAI
client = OpenAI()

def embed_batch(texts, batch_size=100):
    vectors = []
    for i in range(0, len(texts), batch_size):
        batch = texts[i:i + batch_size]
        resp = client.embeddings.create(model='text-embedding-3-small', input=batch)
        vectors.extend(d.embedding for d in resp.data)
    return vectors

Étape 4 : stocker

Pour 10 000 à 50 000 segments, FAISS ou Chroma suffisent :

import chromadb
client = chromadb.Client()
collection = client.create_collection('docs')

collection.add(
    ids=[f'doc-{i}' for i in range(len(chunks))],
    embeddings=vectors,
    documents=chunks,
    metadatas=[{'source': 'doc.pdf', 'page': i} for i in range(len(chunks))]
)

Ingestion idempotente

Faites en sorte que l'ingestion puisse être relancée sans risque. Utilisez des identifiants déterministes (empreinte du contenu) afin qu'une nouvelle exécution ne crée pas de doublons :

import hashlib

def chunk_id(source, text):
    h = hashlib.sha256(text.encode()).hexdigest()[:16]
    return f'{source}:{h}'

print(chunk_id('handbook.pdf', 'Employees get 20 vacation days per year.'))
print(chunk_id('handbook.pdf', 'Employees get 20 vacation days per year.'))

Mises à jour incrémentielles

Lorsqu'un document est modifié :

  1. Calculez les nouveaux segments
  2. Comparez-les aux identifiants existants
  3. Supprimez les éléments retirés, ajoutez les nouveaux et conservez ceux qui sont inchangés

L'approche naïve (tout supprimer puis tout réinsérer) convient aux petits corpus, mais gaspille des appels de vectorisation.

Métadonnées pour le filtrage

Incluez tout champ selon lequel vous pourriez vouloir filtrer ultérieurement :

metadata = {
    'source': '/docs/handbook.pdf',
    'page': 42,
    'department': 'engineering',
    'updated_at': '2024-08-12',
    'access_level': 'internal'
}
for k, v in metadata.items():
    print(f"{k}: {v}")

Progression et points de sauvegarde

Pour les ingestions volumineuses, consignez la progression et créez un point de sauvegarde :

for i, batch in enumerate(batches):
    embed_and_store(batch)
    if i % 10 == 0:
        save_checkpoint(i)
        print(f'Processed {i * 100} chunks')

Limites de débit

Les représentations vectorielles d'OpenAI sont soumises à une limite de débit élevée, mais bien réelle. Utilisez des sémaphores ou des tentatives répétées avec `tenacity` :

from asyncio import Semaphore
sem = Semaphore(10)  # 10 concurrent embed calls max

async def safe_embed(batch):
    async with sem:
        return await client.embeddings.create(...)

Vérifier la cohérence de l'index

Après l'ingestion, exécutez quelques requêtes d'essai et examinez manuellement les résultats. Si aucun résultat pertinent ne s'affiche, votre segmentation ou votre vectorisation ne fonctionne pas : découvrez-le avant vos utilisateurs.

Gestion des versions de l'index

Versionnez l'index afin de pouvoir passer à une nouvelle segmentation ou à un nouveau modèle de vectorisation sans interruption de service :

collection = client.create_collection(f'docs-v2-{date.today()}')
# old collection stays live until new one is validated

Identifiants idempotents

Pourquoi utiliser des empreintes du contenu comme identifiants de segment ?

Récapitulatif

Charger -> segmenter -> vectoriser -> stocker, avec des identifiants idempotents et des métadonnées. L'index est le fondement de toutes les étapes de recherche ultérieures.

Questions Fréquemment Posées

La leçon « Indexer un ensemble de documents » est-elle gratuite ?

Oui — le texte complet de « Indexer un ensemble de documents » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours AI Agents, passe à CoddyKit PRO. Le cours AI Agents comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Indexer un ensemble de documents » ?

Générez un embedding pour chaque segment et stockez les vecteurs dans un index : l’étape de préparation hors ligne de tout système RAG. Tu pratiques AI Agents avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer AI Agents ?

Aucune expérience préalable n'est requise. AI Agents sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 3 sur 4.

Combien de temps prend la leçon « Indexer un ensemble de documents » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon AI Agents ?

Oui. Chaque leçon AI Agents inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

  1. Ce que RAG permet de résoudre (date de connaissance, hallucinations)
  2. Stratégies de découpage (fixe, par phrase, sémantique)
  3. Indexer un ensemble de documents
  4. Construire un RAG naïf avec FAISS ou Chroma
← Retour à AI Agents