Update app.py

app.py

@@ -4,44 +4,43 @@ from fastapi import FastAPI
 from pydantic import BaseModel
 from typing import Optional
 
-# ✅ Modules LlamaIndex (version >= 0.10.0)
+# ✅ LlamaIndex (version >= 0.10.0)
 from llama_index.core import Document
 from llama_index.core.settings import Settings
-from llama_index.core.node_parser import SemanticSplitterNodeParser
-from llama_index.core.text_splitter import RecursiveTextSplitter
+from llama_index.core.node_parser import SemanticSplitterNodeParser, RecursiveCharacterTextSplitter
 from llama_index.llms.llama_cpp import LlamaCPP
 from llama_index.core.base.llms.base import BaseLLM
 
-# ✅ Embedding local (transformers + torch)
+# ✅ Embedding local (basé sur transformers + torch)
 from transformers import AutoTokenizer, AutoModel
 import torch
 import torch.nn.functional as F
 import os
 
-# ✅ Initialisation de l'app FastAPI
+# ✅ Initialisation de l'application FastAPI
 app = FastAPI()
 
-# ✅ Configuration du cache Hugging Face (important pour HF Spaces)
+# ✅ Configuration du cache local de Hugging Face pour économiser l'espace dans le container
 CACHE_DIR = "/app/cache"
 os.environ["HF_HOME"] = CACHE_DIR
 os.environ["TRANSFORMERS_CACHE"] = CACHE_DIR
 os.environ["HF_MODULES_CACHE"] = CACHE_DIR
 os.environ["HF_HUB_CACHE"] = CACHE_DIR
 
-# ✅ Choix du modèle d'embedding dense (ex : BGE-small)
+# ✅ Modèle d'embedding local utilisé pour vectoriser les textes
 MODEL_NAME = "BAAI/bge-small-en-v1.5"
 tokenizer = AutoTokenizer.from_pretrained(MODEL_NAME, cache_dir=CACHE_DIR)
 model = AutoModel.from_pretrained(MODEL_NAME, cache_dir=CACHE_DIR)
 
-# ✅ Fonction d'embedding normalisé (vectorisation dense)
 def get_embedding(text: str):
+    """Fonction pour générer un embedding dense normalisé à partir d’un texte."""
     with torch.no_grad():
         inputs = tokenizer(text, return_tensors="pt", truncation=True, padding=True)
         outputs = model(**inputs)
-        embeddings = outputs.last_hidden_state[:, 0]  # On prend le token [CLS]
+        embeddings = outputs.last_hidden_state[:, 0]  # On prend le vecteur [CLS]
         return F.normalize(embeddings, p=2, dim=1).squeeze().tolist()
 
-# ✅ Format des données envoyées à l’API
+# ✅ Schéma des données attendues dans le POST
 class ChunkRequest(BaseModel):
     text: str
     max_tokens: Optional[int] = 1000
@@ -51,13 +50,12 @@ class ChunkRequest(BaseModel):
     source: Optional[str] = None
     type: Optional[str] = None
 
-# ✅ Route de l’API pour le chunking sémantique
 @app.post("/chunk")
 async def chunk_text(data: ChunkRequest):
     try:
         print(f"\n✅ Texte reçu ({len(data.text)} caractères) : {data.text[:200]}...", flush=True)
 
-        # ✅ Chargement du modèle GGUF distant avec LlamaCPP (CPU friendly)
+        # ✅ Chargement du modèle LLM CodeLlama quantifié (GGUF) via URL Hugging Face
         llm = LlamaCPP(
             model_url="https://huggingface.co/TheBloke/CodeLlama-7B-Instruct-GGUF/resolve/main/codellama-7b-instruct.Q4_K_M.gguf",
             temperature=0.1,
@@ -67,35 +65,42 @@ async def chunk_text(data: ChunkRequest):
             model_kwargs={"n_gpu_layers": 1},
         )
 
-        print("✅ Modèle LLM chargé avec succès !")
+        print("✅ Modèle CodeLlama-7B chargé avec succès !")
 
-        # ✅ Wrapper embedding compatible avec LlamaIndex
+        # ✅ Embedding local pour LlamaIndex
         class SimpleEmbedding:
             def get_text_embedding(self, text: str):
                 return get_embedding(text)
 
-        # ✅ Configuration globale de LlamaIndex
-        assert isinstance(llm, BaseLLM), "❌ L’objet LLM n’est pas compatible avec LlamaIndex"
+        # ✅ Configuration du moteur dans LlamaIndex
+        assert isinstance(llm, BaseLLM), "❌ Le LLM n'est pas compatible avec Settings.llm"
         Settings.llm = llm
         Settings.embed_model = SimpleEmbedding()
 
-        print("✅ Configuration du LLM et de l'embedding terminée. On initialise le Semantic Splitter...")
+        print("✅ Configuration du LLM et de l'embedding terminée.")
 
-        parser = SemanticSplitterNodeParser.from_defaults(llm=llm)
+        # ✅ Document à découper
         doc = Document(text=data.text)
 
+        # ✅ Split intelligent (semantic)
+        parser = SemanticSplitterNodeParser.from_defaults(llm=llm)
+
         try:
             nodes = parser.get_nodes_from_documents([doc])
             print(f"✅ Semantic Splitter : {len(nodes)} chunks générés")
             if not nodes:
-                raise ValueError("Aucun chunk produit par SemanticSplitter")
+                raise ValueError("Aucun chunk généré par SemanticSplitter")
+
         except Exception as e:
-            print(f"⚠️ Fallback vers RecursiveTextSplitter suite à : {e}")
-            splitter = RecursiveTextSplitter(chunk_size=data.max_tokens, chunk_overlap=data.overlap)
+            print(f"⚠️ Fallback vers RecursiveCharacterTextSplitter suite à : {e}")
+            splitter = RecursiveCharacterTextSplitter(
+                chunk_size=data.max_tokens,
+                chunk_overlap=data.overlap
+            )
             nodes = splitter.get_nodes_from_documents([doc])
             print(f"♻️ Recursive Splitter : {len(nodes)} chunks générés")
 
-        # ✅ Résultat structuré pour n8n ou autre client HTTP
+        # ✅ Construction de la réponse
         return {
             "chunks": [node.text for node in nodes],
             "metadatas": [node.metadata for node in nodes],
@@ -103,14 +108,14 @@ async def chunk_text(data: ChunkRequest):
             "titre": data.titre,
             "source": data.source,
             "type": data.type,
-            "error": None  # ← utilisé par n8n pour signaler "pas d'erreur"
+            "error": None  # utile pour n8n ou tout autre client
         }
 
     except Exception as e:
         print(f"❌ Erreur critique : {e}")
         return {"error": str(e)}
 
-# ✅ Lancement local (facultatif pour HF Spaces)
+# ✅ Lancement du serveur si exécution directe (mode debug)
 if __name__ == "__main__":
     import uvicorn
     uvicorn.run("app:app", host="0.0.0.0", port=7860)