test_change

app.py

@@ -36,6 +36,8 @@ from chromadb.config import Settings
 from langchain_text_splitters import RecursiveCharacterTextSplitter
 from pypdf import PdfReader
 
+from sentence_transformers import CrossEncoder
+
 from llm import call_llm as call_llm_with_metrics
 
 logging.basicConfig(level=logging.INFO)
@@ -55,9 +57,25 @@ DATA_DIR = Path("/data") if Path("/data").is_dir() else Path("./data")
 CHROMA_PERSIST_DIR = str(DATA_DIR / "chroma_db")
 TRAIN_DOCS_DIR = Path("./train_data")
 COLLECTION_NAME = "rag_documents"
-CHUNK_SIZE = 512
-CHUNK_OVERLAP = 50
-TOP_K_RESULTS = 5
+CHUNK_SIZE = 1000   # était 512
+CHUNK_OVERLAP = 150  # était 50
+
+# ---------------------------------------------------------------------------
+# Reranking configuration
+# ---------------------------------------------------------------------------
+# Mettre à True pour activer le reranking, False pour le désactiver
+ENABLE_RERANKING = True
+
+# Nombre de chunks récupérés lors de la première étape (recherche vectorielle)
+# Plus ce nombre est élevé, meilleur est le rappel — mais plus le reranker est lent
+TOP_K_RETRIEVAL = 20
+
+# Nombre de chunks conservés après le reranking (envoyés au LLM)
+# Doit être inférieur ou égal à TOP_K_RETRIEVAL
+TOP_K_RERANKED = 2
+
+# Modèle cross-encoder multilingue (supporte le français)
+RERANKER_MODEL_NAME = "cross-encoder/mmarco-mMiniLMv2-L12-H384-v1"
 
 # Settings loaded from data/config.json (runtime config).
 # Falls back to the root config.json which serves as the example/template.
@@ -116,6 +134,17 @@ collection = chroma_client.get_or_create_collection(
 )
 logger.info(f"ChromaDB collection '{COLLECTION_NAME}' ready. Documents: {collection.count()}")
 
+# ---------------------------------------------------------------------------
+# Step 2b: Initialize Cross-Encoder Reranker
+# ---------------------------------------------------------------------------
+reranker = None
+if ENABLE_RERANKING:
+    logger.info(f"Loading reranker model: {RERANKER_MODEL_NAME}")
+    reranker = CrossEncoder(RERANKER_MODEL_NAME)
+    logger.info("Reranker ready.")
+else:
+    logger.info("Reranking disabled (ENABLE_RERANKING = False).")
+
 # ---------------------------------------------------------------------------
 # Step 3: LLM Configuration (Azure Foundry GPT-5)
 # ---------------------------------------------------------------------------
@@ -228,14 +257,19 @@ def add_documents_to_vectorstore(documents: list[dict]) -> int:
     return len(documents)
 
 
-def retrieve_relevant_context(query: str, top_k: int = TOP_K_RESULTS) -> list[dict]:
+def retrieve_relevant_context(
+    query: str,
+    top_k: int = TOP_K_RETRIEVAL,
+    enable_reranking: bool = ENABLE_RERANKING,
+    top_k_reranked: int = TOP_K_RERANKED,
+) -> list[dict]:
     """
     Retrieve the most relevant document chunks for a given query.
 
-    This is the "Retrieval" step in RAG:
-    1. Embed the user's query using the same embedding model
-    2. Search the vector store for the nearest neighbors
-    3. Return the top-k most similar chunks as context
+    Pipeline :
+    1. Recherche vectorielle : récupère top_k candidats
+    2. Si enable_reranking : score chaque paire (query, chunk) avec le cross-encoder
+       et conserve les top_k_reranked meilleurs
     """
     if collection.count() == 0:
         return []
@@ -256,7 +290,19 @@ def retrieve_relevant_context(query: str, top_k: int = TOP_K_RESULTS) -> list[di
             "similarity_score": 1 - results["distances"][0][i],
         })
 
-    return contexts
+    if not enable_reranking or reranker is None:
+        return contexts
+
+    # Étape 2 : reranking avec le cross-encoder
+    pairs = [[query, ctx["text"]] for ctx in contexts]
+    rerank_scores = reranker.predict(pairs)
+
+    for ctx, score in zip(contexts, rerank_scores):
+        ctx["rerank_score"] = float(score)
+
+    contexts.sort(key=lambda x: x["rerank_score"], reverse=True)
+
+    return contexts[:top_k_reranked]
 
 
 def build_rag_prompt(query: str, contexts: list[dict]) -> str:
@@ -276,23 +322,30 @@ def build_rag_prompt(query: str, contexts: list[dict]) -> str:
     return prompt
 
 
-def rag_query(query: str, top_k: int = TOP_K_RESULTS) -> dict:
+def rag_query(
+    query: str,
+    top_k: int = TOP_K_RETRIEVAL,
+    *,
+    temperature: float = LLM_TEMPERATURE,
+    max_tokens: int = LLM_MAX_TOKENS,
+    enable_reranking: bool = ENABLE_RERANKING,
+    top_k_reranked: int = TOP_K_RERANKED,
+) -> dict:
     """
     End-to-end RAG pipeline: Query → Retrieve → Generate.
 
-    This demonstrates Step 2d: How to make a RAG system end-to-end.
-
-    Pipeline steps:
-    1. Receive user query
-    2. Retrieve relevant context from vector store
-    3. Build augmented prompt with context
-    4. Call LLM to generate answer
-    5. Return answer with source metadata, explanation, token count, and timing
+    Tous les paramètres ont des valeurs par défaut issues de la configuration globale
+    et peuvent être surchargés lors de l'appel (ex : sensitivity analysis).
     """
     start_time = time.perf_counter()
 
     # Step 1: Retrieve relevant document chunks
-    contexts = retrieve_relevant_context(query, top_k=top_k)
+    contexts = retrieve_relevant_context(
+        query,
+        top_k=top_k,
+        enable_reranking=enable_reranking,
+        top_k_reranked=top_k_reranked,
+    )
 
     if not contexts:
         elapsed_ms = round((time.perf_counter() - start_time) * 1000, 2)
@@ -318,8 +371,8 @@ def rag_query(query: str, top_k: int = TOP_K_RESULTS) -> dict:
         endpoint_url=LLM_ENDPOINT_URL,
         api_key=AZURE_API_KEY,
         model=LLM_MODEL_NAME,
-        max_completion_tokens=LLM_MAX_TOKENS,
-        temperature=LLM_TEMPERATURE,
+        max_completion_tokens=max_tokens,
+        temperature=temperature,
         top_p=LLM_TOP_P,
     )
     raw_content = llm_result["content"]
@@ -406,7 +459,7 @@ app = FastAPI(
 class QueryRequest(BaseModel):
     """Request schema for the /query endpoint."""
     query: str
-    top_k: Optional[int] = TOP_K_RESULTS
+    top_k: Optional[int] = TOP_K_RETRIEVAL
 
 
 class IngestRequest(BaseModel):

ingest_train_data.py

@@ -1,24 +1,29 @@
 """
-Ingest Training Data Script
-============================
+Ingest Training Data Script — Version parallélisée
+=====================================================
 
-Standalone script to convert all documents in ./train_data into embeddings
-and store them in the ChromaDB vector store.
+Trois phases :
+  1. Extraction + chunking de tous les fichiers  (ThreadPoolExecutor, I/O + CPU)
+  2. Embedding via Azure OpenAI                  (ThreadPoolExecutor, I/O pur → gros gain)
+  3. Insertion bulk dans ChromaDB                (1 seul appel par tranche de 5000)
 
 Usage:
-    python ingest_train_data.py
+    python ingest_train_data.py              # ingestion normale (skip si déjà fait)
+    python ingest_train_data.py --reset      # supprime la collection et recommence
 
-Requires:
-    - AZURE_API_KEY environment variable set
-    - data/config.json (or root config.json as fallback) with endpoint URLs
-    - Documents (PDF/TXT) in ./train_data/<category>/
+Paramètres de parallélisme (ajuster selon les limites de l'API Azure) :
+    EXTRACTION_WORKERS  : workers pour la lecture/parsing des PDFs
+    EMBEDDING_WORKERS   : workers pour les appels HTTP à l'API d'embedding
+    EMBEDDING_BATCH_SIZE: chunks par requête (max ~2048 pour Azure OpenAI)
 """
 
-import os
-import sys
+import argparse
 import json
 import logging
+import os
+import sys
 import time
+from concurrent.futures import ThreadPoolExecutor, as_completed
 from pathlib import Path
 
 os.environ.setdefault("ANONYMIZED_TELEMETRY", "False")
@@ -32,40 +37,56 @@ from pypdf import PdfReader
 logging.basicConfig(level=logging.INFO, format="%(asctime)s [%(levelname)s] %(message)s")
 logger = logging.getLogger(__name__)
 
-# ---------------------------------------------------------------------------
-# Configuration
-# ---------------------------------------------------------------------------
+# ──────────────────────────────────────────────────────────────────────────────
+# Configuration test de la configuration
+# ──────────────────────────────────────────────────────────────────────────────
 
-PROJECT_ROOT = Path(__file__).parent
-DATA_DIR = Path("/data") if Path("/data").is_dir() else PROJECT_ROOT / "data"
+PROJECT_ROOT   = Path(__file__).parent
+DATA_DIR       = Path("/data")       if Path("/data").is_dir()       else PROJECT_ROOT / "data"
 TRAIN_DATA_DIR = Path("/train_data") if Path("/train_data").is_dir() else PROJECT_ROOT / "train_data"
 
 CHROMA_PERSIST_DIR = str(DATA_DIR / "chroma_db")
-COLLECTION_NAME = "rag_documents"
-CHUNK_SIZE = 512
-CHUNK_OVERLAP = 50
-EMBEDDING_BATCH_SIZE = 16
+COLLECTION_NAME    = "rag_documents"
+
+# Chunking — mis à jour pour de meilleures performances RAG
+CHUNK_SIZE    = 1000   # était 512
+CHUNK_OVERLAP = 150    # était 50
+
+# Parallélisme
+EMBEDDING_BATCH_SIZE = 64   # chunks par requête API (était 16)
+EMBEDDING_WORKERS    = 6    # appels API simultanés — réduire si rate-limit Azure
+EXTRACTION_WORKERS   = 8    # workers pour l'extraction/parsing PDF
+
+# Insertion ChromaDB par tranches pour éviter les problèmes mémoire
+CHROMA_INSERT_BATCH  = 5_000
+
+# Retry sur les appels embedding
+EMBEDDING_MAX_RETRIES = 3
+EMBEDDING_RETRY_DELAY = 2.0  # secondes entre deux tentatives
+
+# ──────────────────────────────────────────────────────────────────────────────
+# Chargement de la config
+# ──────────────────────────────────────────────────────────────────────────────
 
 _CONFIG_PATH = DATA_DIR / "config.json"
 if not _CONFIG_PATH.exists():
     _CONFIG_PATH = PROJECT_ROOT / "config.json"
-    logger.warning(f"No config.json in {DATA_DIR} — using root config.json as fallback.")
+    logger.warning(f"Pas de config.json dans {DATA_DIR} — utilisation de root config.json.")
 
 with open(_CONFIG_PATH, encoding="utf-8") as _f:
     _config = json.load(_f)
 
 EMBEDDING_ENDPOINT_URL = _config["embedding"]["endpoint_url"]
-EMBEDDING_MODEL_NAME = _config["embedding"]["model"]
+EMBEDDING_MODEL_NAME   = _config["embedding"]["model"]
 
 AZURE_API_KEY = os.environ.get("AZURE_API_KEY")
 if not AZURE_API_KEY:
-    logger.error("AZURE_API_KEY is not set. Export it before running this script.")
+    logger.error("AZURE_API_KEY n'est pas défini. Définissez la variable d'environnement avant de lancer.")
     sys.exit(1)
 
-# ---------------------------------------------------------------------------
+# ────────────────────────────���─────────────────────────────────────────────────
 # Helpers
-# ---------------------------------------------------------------------------
-
+# ──────────────────────────────────────────────────────────────────────────────
 
 def extract_text_from_pdf(pdf_path: Path) -> str:
     reader = PdfReader(str(pdf_path))
@@ -88,109 +109,192 @@ def chunk_text(text: str, source: str) -> list[dict]:
 
 
 def generate_embeddings(texts: list[str]) -> list[list[float]]:
+    """Un seul appel HTTP — appelé en parallèle par plusieurs workers."""
     headers = {"api-key": AZURE_API_KEY, "Content-Type": "application/json"}
     payload = {"input": texts, "model": EMBEDDING_MODEL_NAME}
     resp = http_requests.post(EMBEDDING_ENDPOINT_URL, headers=headers, json=payload, timeout=120)
     resp.raise_for_status()
-    data = resp.json()
-    return [item["embedding"] for item in data["data"]]
-
-
-def generate_embeddings_batched(texts: list[str]) -> list[list[float]]:
-    all_embeddings = []
-    for i in range(0, len(texts), EMBEDDING_BATCH_SIZE):
-        batch = texts[i:i + EMBEDDING_BATCH_SIZE]
-        logger.info(f"  Embedding batch {i // EMBEDDING_BATCH_SIZE + 1} ({len(batch)} chunks)...")
-        embeddings = generate_embeddings(batch)
-        all_embeddings.extend(embeddings)
-        time.sleep(0.5)  # Rate-limit courtesy
-    return all_embeddings
+    return [item["embedding"] for item in resp.json()["data"]]
+
+
+# ──────────────────────────────────────────────────────────────────────────────
+# Workers (appelés depuis les ThreadPoolExecutors)
+# ──────────────────────────────────────────────────────────────────────────────
+
+def _process_file(file_path: Path) -> tuple[str, list[dict]]:
+    """Phase 1 — Extrait et chunke un fichier. Retourne (source, chunks)."""
+    source = str(file_path.relative_to(TRAIN_DATA_DIR))
+    try:
+        text = extract_text_from_pdf(file_path) if file_path.suffix.lower() == ".pdf" \
+               else file_path.read_text(encoding="utf-8")
+    except Exception as e:
+        logger.warning(f"  Ignoré (erreur lecture) {source}: {e}")
+        return source, []
+    if not text.strip():
+        logger.warning(f"  Ignoré (pas de texte) {source}")
+        return source, []
+    chunks = chunk_text(text, source=source)
+    return source, chunks
+
+
+def _embed_batch(batch_idx: int, texts: list[str]) -> tuple[int, list[list[float]]]:
+    """Phase 2 — Embedde un batch avec retry. Retourne (batch_idx, embeddings)."""
+    for attempt in range(1, EMBEDDING_MAX_RETRIES + 1):
+        try:
+            return batch_idx, generate_embeddings(texts)
+        except Exception as e:
+            if attempt == EMBEDDING_MAX_RETRIES:
+                logger.error(f"  Batch {batch_idx} échoué après {EMBEDDING_MAX_RETRIES} tentatives : {e}")
+                raise
+            logger.warning(f"  Batch {batch_idx} — tentative {attempt} échouée ({e}), retry dans {EMBEDDING_RETRY_DELAY}s...")
+            time.sleep(EMBEDDING_RETRY_DELAY)
 
 
-# ---------------------------------------------------------------------------
+# ──────────────────────────────────────────────────────────────────────────────
 # Main
-# ---------------------------------------------------------------------------
-
+# ──────────────────────────────────────────────────────────────────────────────
 
 def main():
+    parser = argparse.ArgumentParser(description="Ingestion parallélisée des documents d'entraînement")
+    parser.add_argument(
+        "--reset", action="store_true",
+        help="Supprime la collection ChromaDB existante avant de réingérer (nécessaire après changement de chunking)",
+    )
+    args = parser.parse_args()
+
     if not TRAIN_DATA_DIR.exists():
-        logger.error(f"Training data directory not found: {TRAIN_DATA_DIR}")
+        logger.error(f"Dossier train_data introuvable : {TRAIN_DATA_DIR}")
         sys.exit(1)
 
-    logger.info(f"Training data directory: {TRAIN_DATA_DIR}")
-    logger.info(f"ChromaDB path: {CHROMA_PERSIST_DIR}")
-    logger.info(f"Embedding model: {EMBEDDING_MODEL_NAME}")
-
+    # ── ChromaDB ──────────────────────────────────���───────────────────────────
     chroma_client = chromadb.PersistentClient(
         path=CHROMA_PERSIST_DIR,
         settings=Settings(anonymized_telemetry=False),
     )
+    if args.reset:
+        try:
+            chroma_client.delete_collection(COLLECTION_NAME)
+            logger.info("Collection supprimée (--reset).")
+        except Exception:
+            pass
     collection = chroma_client.get_or_create_collection(
         name=COLLECTION_NAME,
         metadata={"hnsw:space": "cosine"},
     )
-    logger.info(f"ChromaDB collection '{COLLECTION_NAME}' — existing documents: {collection.count()}")
-
-    # Gather all PDF and TXT files recursively
-    files = sorted(
-        list(TRAIN_DATA_DIR.rglob("*.pdf")) + list(TRAIN_DATA_DIR.rglob("*.txt"))
-    )
-    logger.info(f"Found {len(files)} files to process.")
-
-    total_chunks_added = 0
-
-    for idx, file_path in enumerate(files, start=1):
-        relative = file_path.relative_to(TRAIN_DATA_DIR)
-        # Use category/filename as the source identifier
-        source = str(relative)
-        logger.info(f"[{idx}/{len(files)}] Processing: {source}")
-
-        try:
-            if file_path.suffix.lower() == ".pdf":
-                text = extract_text_from_pdf(file_path)
-            else:
-                text = file_path.read_text(encoding="utf-8")
-        except Exception as e:
-            logger.warning(f"  Skipped (read error): {e}")
-            continue
-
-        if not text.strip():
-            logger.warning(f"  Skipped (no extractable text)")
-            continue
-
-        chunks = chunk_text(text, source=source)
-        if not chunks:
-            logger.warning(f"  Skipped (no chunks produced)")
-            continue
-
-        logger.info(f"  {len(chunks)} chunks extracted")
-
-        texts = [c["text"] for c in chunks]
-        try:
-            embeddings = generate_embeddings_batched(texts)
-        except http_requests.exceptions.HTTPError as e:
-            logger.error(f"  Embedding failed: {e}")
-            continue
-        except Exception as e:
-            logger.error(f"  Unexpected embedding error: {e}")
-            continue
+    if collection.count() > 0 and not args.reset:
+        logger.info(f"Collection déjà peuplée ({collection.count()} chunks). Utilisez --reset pour réingérer.")
+        sys.exit(0)
+
+    # ── Découverte des fichiers ───────────────────────────────────────────────
+    files = sorted(list(TRAIN_DATA_DIR.rglob("*.pdf")) + list(TRAIN_DATA_DIR.rglob("*.txt")))
+    if not files:
+        logger.error(f"Aucun fichier PDF/TXT trouvé dans {TRAIN_DATA_DIR}")
+        sys.exit(1)
 
-        existing_count = collection.count()
-        ids = [f"doc_{existing_count + i}" for i in range(len(chunks))]
-        metadatas = [{"source": c["source"], "chunk_index": c["chunk_index"]} for c in chunks]
+    t_start = time.perf_counter()
+    logger.info(f"{'='*60}")
+    logger.info(f"Fichiers trouvés   : {len(files)}")
+    logger.info(f"Chunk size / overlap: {CHUNK_SIZE} / {CHUNK_OVERLAP}")
+    logger.info(f"Batch size embedding: {EMBEDDING_BATCH_SIZE}")
+    logger.info(f"Workers extraction  : {EXTRACTION_WORKERS}")
+    logger.info(f"Workers embedding   : {EMBEDDING_WORKERS}")
+    logger.info(f"{'='*60}")
+
+    # ── Phase 1 : Extraction + chunking en parallèle ─────────────────────────
+    logger.info(f"\nPhase 1/3 — Extraction et chunking ({EXTRACTION_WORKERS} workers)...")
+    all_chunks: list[dict] = []
+    errors_extraction = 0
+
+    with ThreadPoolExecutor(max_workers=EXTRACTION_WORKERS) as executor:
+        futures = {executor.submit(_process_file, f): f for f in files}
+        done = 0
+        for future in as_completed(futures):
+            done += 1
+            try:
+                source, chunks = future.result()
+                all_chunks.extend(chunks)
+                logger.info(f"  [{done}/{len(files)}] {source} → {len(chunks)} chunks")
+            except Exception as e:
+                errors_extraction += 1
+                logger.error(f"  [{done}/{len(files)}] Erreur inattendue : {e}")
+
+    t_phase1 = time.perf_counter() - t_start
+    logger.info(f"Phase 1 terminée en {t_phase1:.1f}s — {len(all_chunks)} chunks ({errors_extraction} erreurs)")
+
+    if not all_chunks:
+        logger.error("Aucun chunk produit. Vérifiez les fichiers dans train_data/.")
+        sys.exit(1)
 
+    # ── Phase 2 : Embedding en parallèle ─────────────────────────────────────
+    logger.info(f"\nPhase 2/3 — Embedding ({len(all_chunks)} chunks, batch={EMBEDDING_BATCH_SIZE}, workers={EMBEDDING_WORKERS})...")
+
+    texts  = [c["text"] for c in all_chunks]
+    batches = [(i, texts[i : i + EMBEDDING_BATCH_SIZE]) for i in range(0, len(texts), EMBEDDING_BATCH_SIZE)]
+    embeddings_map: dict[int, list] = {}
+    errors_embedding = 0
+
+    t_phase2_start = time.perf_counter()
+    with ThreadPoolExecutor(max_workers=EMBEDDING_WORKERS) as executor:
+        futures = {executor.submit(_embed_batch, idx, batch): idx for idx, batch in batches}
+        done = 0
+        for future in as_completed(futures):
+            done += 1
+            try:
+                batch_idx, embeddings = future.result()
+                embeddings_map[batch_idx] = embeddings
+            except Exception as e:
+                errors_embedding += 1
+                logger.error(f"  Batch échoué, {errors_embedding} erreurs totales")
+            if done % 20 == 0 or done == len(batches):
+                elapsed = time.perf_counter() - t_phase2_start
+                rate = done / elapsed if elapsed > 0 else 0
+                eta = (len(batches) - done) / rate if rate > 0 else 0
+                logger.info(f"  {done}/{len(batches)} batches — {elapsed:.0f}s écoulés, ETA ~{eta:.0f}s")
+
+    t_phase2 = time.perf_counter() - t_phase2_start
+    logger.info(f"Phase 2 terminée en {t_phase2:.1f}s ({errors_embedding} erreurs)")
+
+    if errors_embedding > 0:
+        logger.warning(f"{errors_embedding} batches ont échoué — les chunks correspondants seront absents de la base.")
+
+    # Reconstruction dans l'ordre original
+    flat_embeddings: list = []
+    failed_indices: set[int] = set()
+    valid_chunks: list[dict] = []
+
+    for batch_start in range(0, len(texts), EMBEDDING_BATCH_SIZE):
+        if batch_start in embeddings_map:
+            flat_embeddings.extend(embeddings_map[batch_start])
+            batch_end = min(batch_start + EMBEDDING_BATCH_SIZE, len(all_chunks))
+            valid_chunks.extend(all_chunks[batch_start:batch_end])
+        else:
+            failed_indices.add(batch_start)
+
+    # ── Phase 3 : Insertion bulk dans ChromaDB ───────────────────────────────
+    logger.info(f"\nPhase 3/3 — Insertion dans ChromaDB ({len(valid_chunks)} chunks)...")
+    t_phase3_start = time.perf_counter()
+
+    for i in range(0, len(valid_chunks), CHROMA_INSERT_BATCH):
+        batch_chunks     = valid_chunks[i : i + CHROMA_INSERT_BATCH]
+        batch_embeddings = flat_embeddings[i : i + CHROMA_INSERT_BATCH]
         collection.add(
-            ids=ids,
-            embeddings=embeddings,
-            documents=texts,
-            metadatas=metadatas,
+            ids        = [f"doc_{i + j}" for j in range(len(batch_chunks))],
+            embeddings = batch_embeddings,
+            documents  = [c["text"]         for c in batch_chunks],
+            metadatas  = [{"source": c["source"], "chunk_index": c["chunk_index"]} for c in batch_chunks],
         )
-        total_chunks_added += len(chunks)
-        logger.info(f"  Added {len(chunks)} chunks (total in store: {collection.count()})")
-
-    logger.info("=" * 60)
-    logger.info(f"Ingestion complete. Chunks added this run: {total_chunks_added}")
-    logger.info(f"Total documents in vector store: {collection.count()}")
+        logger.info(f"  Inséré {min(i + CHROMA_INSERT_BATCH, len(valid_chunks))}/{len(valid_chunks)} chunks")
+
+    t_phase3 = time.perf_counter() - t_phase3_start
+    t_total   = time.perf_counter() - t_start
+
+    logger.info(f"\n{'='*60}")
+    logger.info(f"Ingestion terminée en {t_total:.1f}s ({t_total/60:.1f} min)")
+    logger.info(f"  Phase 1 (extraction) : {t_phase1:.1f}s")
+    logger.info(f"  Phase 2 (embedding)  : {t_phase2:.1f}s")
+    logger.info(f"  Phase 3 (ChromaDB)   : {t_phase3:.1f}s")
+    logger.info(f"Chunks dans la base    : {collection.count()}")
+    logger.info(f"{'='*60}")
 
 
 if __name__ == "__main__":