Update app.py

app.py

@@ -1,397 +1,518 @@
 """
-app.py v5.0 ADAPTÉ - FastAPI pour Chunking Sémantique Intelligent
+app.py v4.0 FINAL - FastAPI pour Chunking Sémantique Intelligent
 
-ADAPTATIONS MAJEURES v5.0:
-✅ Compatible avec LlamaIndex moderne modulaire (llama-index-core)
-✅ Import SmartChunkerPipeline adapté pour nouvelle architecture
-✅ Méthodes corrigées pour nouvelle structure
-✅ Health check v5.0 avec support modulaire
-✅ Gestion erreurs améliorée pour compatibilité
-✅ Optimisations HF Space gratuit renforcées
+CORRECTIONS ET AMÉLIORATIONS:
+✅ Import SmartChunkerPipeline (correct)
+✅ Méthodes synchronisées avec chunker_pipeline.py
+✅ Gestion d'erreurs robuste
+✅ Endpoints optimisés pour n8n
 ✅ Variables d'environnement sécurisées
+✅ Monitoring et health checks complets
+✅ Configuration HF Space gratuit optimisée
 """
 
 import os
 import logging
 import time
+import asyncio
+import gc
+from pathlib import Path
 from fastapi import FastAPI, HTTPException, Request
 from fastapi.middleware.cors import CORSMiddleware
 from fastapi.responses import JSONResponse
 from pydantic import BaseModel, Field
 from typing import List, Dict, Any, Optional
-import asyncio
 from concurrent.futures import ThreadPoolExecutor
-import gc
 
 # Configuration logging optimisée
 logging.basicConfig(
     level=logging.INFO,
-    format="%(asctime)s - %(name)s - %(levelname)s - %(message)s"
+    format="%(asctime)s - %(name)s - %(levelname)s - %(message)s",
+    handlers=[
+        logging.StreamHandler(),
+        logging.FileHandler("/app/logs/app.log", mode="a") if os.path.exists("/app/logs") else logging.StreamHandler()
+    ]
 )
 logger = logging.getLogger(__name__)
 
-# ✅ ADAPTATION: Import SmartChunkerPipeline v5.0 avec fallback
+# ✅ IMPORTS PRINCIPAUX - Vérification de compatibilité
 try:
-    from chunker_pipeline import SmartChunkerPipeline  # Version moderne
+    from chunker_pipeline import SmartChunkerPipeline
     from schemas import ChunkRequest, ChunkResponse, ChunkMetadata
-    logger.info("✅ Modules de chunking v5.0 importés avec succès (LlamaIndex moderne)")
+    logger.info("✅ Modules chunking v4.0 importés avec succès")
 except ImportError as e:
-    logger.error(f"❌ Erreur import modules chunking: {e}")
-    # Fallback pour tests
-    try:
-        from pipeline import ChunkingPipeline as SmartChunkerPipeline
-        from schemas import ChunkRequest, ChunkResponse, ChunkMetadata
-        logger.warning("⚠️ Utilisation pipeline fallback - fonctionnalités limitées")
-    except ImportError as e2:
-        logger.error(f"❌ Erreur import fallback: {e2}")
-        raise
+    logger.error(f"❌ ERREUR CRITIQUE - Import modules chunking: {e}")
+    logger.error("Vérifiez que les fichiers chunker_pipeline.py et schemas.py existent")
+    raise
 
-# ✅ Configuration sécurisée variables d'environnement HF Space
-os.environ["TOKENIZERS_PARALLELISM"] = "false"
-os.environ["HF_HUB_DISABLE_PROGRESS_BARS"] = "1"
-os.environ["TRANSFORMERS_VERBOSITY"] = "error"
-os.environ["HF_HOME"] = "/app/cache/huggingface"
-os.environ["TRANSFORMERS_CACHE"] = "/app/cache/transformers"
+# ✅ CONFIGURATION ENVIRONNEMENT HF SPACE SÉCURISÉE
+def setup_environment():
+    """Configuration optimisée pour Hugging Face Space gratuit"""
+    
+    # Cache HuggingFace optimisé
+    cache_base = "/app/cache"
+    os.environ["HF_HOME"] = f"{cache_base}/huggingface"
+    os.environ["TRANSFORMERS_CACHE"] = f"{cache_base}/transformers"
+    os.environ["HF_HUB_CACHE"] = f"{cache_base}/hub"
+    
+    # Optimisations performance
+    os.environ["TOKENIZERS_PARALLELISM"] = "false"
+    os.environ["HF_HUB_DISABLE_PROGRESS_BARS"] = "1"
+    os.environ["TRANSFORMERS_VERBOSITY"] = "error"
+    os.environ["PYTHONUNBUFFERED"] = "1"
+    
+    # Création dossiers cache sécurisés
+    cache_dirs = [
+        f"{cache_base}/huggingface",
+        f"{cache_base}/transformers", 
+        f"{cache_base}/hub",
+        f"{cache_base}/llm",
+        f"{cache_base}/embeddings",
+        "/app/logs"
+    ]
+    
+    for cache_dir in cache_dirs:
+        try:
+            os.makedirs(cache_dir, exist_ok=True)
+            os.chmod(cache_dir, 0o755)
+        except Exception as e:
+            logger.warning(f"⚠️ Impossible de créer {cache_dir}: {e}")
+    
+    logger.info("✅ Environnement HF Space configuré")
 
-# ✅ NOUVEAU: Configuration spécifique LlamaIndex moderne
-os.environ["LLAMA_INDEX_CACHE_DIR"] = "/app/cache/llamaindex"
+# Configuration environnement
+setup_environment()
 
-# Initialisation FastAPI avec optimisations v5.0
+# ✅ INITIALISATION FASTAPI OPTIMISÉE
 app = FastAPI(
-    title="Chunking Sémantique Intelligent API v5.0",
-    description="API de découpage récursif hiérarchique avec parentalité - Powered by LlamaIndex Moderne + Chonkie",
-    version="5.0.0",
+    title="🧠 Chunking Sémantique Intelligent API",
+    description="""
+    **API de découpage récursif hiérarchique avec parentalité**
+    
+    🚀 **Fonctionnalités:**
+    - Chunking sémantique avec Chonkie + LlamaIndex
+    - Relations bidirectionnelles parent/enfant
+    - Export Obsidian format [[Titre]], id  
+    - Base connaissance pour agents IA spécialisés
+    - 100% gratuit sur HuggingFace Space
+    
+    🔧 **Optimisé pour n8n et automation**
+    """,
+    version="4.0.0",
     docs_url="/docs",
-    redoc_url="/redoc"
+    redoc_url="/redoc",
+    openapi_tags=[
+        {"name": "chunking", "description": "Endpoints de chunking principal"},
+        {"name": "monitoring", "description": "Santé et configuration"},
+        {"name": "test", "description": "Tests et validation"}
+    ]
 )
 
-# Configuration CORS étendue pour n8n et tests
+# ✅ CORS ÉTENDU POUR N8N ET INTÉGRATIONS
 app.add_middleware(
     CORSMiddleware,
-    allow_origins=["*"],  # Pour n8n et tests
+    allow_origins=["*"],  # Nécessaire pour n8n
     allow_credentials=True,
-    allow_methods=["GET", "POST", "OPTIONS"],
+    allow_methods=["GET", "POST", "PUT", "DELETE", "OPTIONS"],
     allow_headers=["*"],
+    expose_headers=["*"]
 )
 
-# ✅ Instance globale pipeline v5.0 (chargée une seule fois)
+# ✅ VARIABLES GLOBALES
 pipeline = None
 executor = ThreadPoolExecutor(max_workers=1)  # HF Space gratuit = 1 worker max
+startup_time = time.time()
+request_count = 0
 
-# ✅ Middleware gestion erreurs globales
+# ✅ MIDDLEWARE MONITORING ET SÉCURITÉ
 @app.middleware("http")
-async def catch_exceptions_middleware(request: Request, call_next):
-    """Middleware pour capturer et gérer les erreurs globales"""
+async def monitoring_middleware(request: Request, call_next):
+    """Middleware pour monitoring et gestion erreurs globales"""
+    global request_count
+    start_time = time.time()
+    request_count += 1
+    
+    # Headers sécurité
+    response = None
     try:
         response = await call_next(request)
+        response.headers["X-API-Version"] = "4.0.0"
+        response.headers["X-Powered-By"] = "Chunking-Semantic-AI"
+        
+        # Log performance
+        process_time = time.time() - start_time
+        if process_time > 5.0:  # Log requêtes lentes
+            logger.warning(f"⚠️ Requête lente: {request.url.path} - {process_time:.2f}s")
+        
         return response
+        
     except Exception as e:
-        logger.error(f"❌ Erreur globale: {str(e)}")
+        logger.error(f"❌ Erreur middleware {request.url.path}: {str(e)}")
+        
+        # Réponse d'erreur structurée
         return JSONResponse(
             status_code=500,
             content={
                 "error": "Erreur interne du serveur",
                 "detail": str(e),
+                "path": str(request.url.path),
                 "timestamp": time.time(),
-                "version": "5.0.0"
+                "request_id": request_count,
+                "version": "4.0.0"
             }
         )
 
+# ✅ ÉVÉNEMENTS LIFECYCLE
 @app.on_event("startup")
 async def startup_event():
-    """✅ Initialisation pipeline v5.0 au démarrage avec LlamaIndex moderne"""
+    """Initialisation complète au démarrage"""
     global pipeline
+    
     try:
-        logger.info("🚀 Initialisation SmartChunkerPipeline v5.0 (LlamaIndex moderne)...")
+        logger.info("🚀 === DÉMARRAGE API CHUNKING SÉMANTIQUE v4.0 ===")
+        
+        # Vérification espace disque
+        import shutil
+        total, used, free = shutil.disk_usage("/app")
+        free_gb = free / (1024**3)
+        logger.info(f"💾 Espace libre: {free_gb:.1f}GB")
+        
+        if free_gb < 1.0:
+            logger.warning("⚠️ Espace disque faible (<1GB)")
         
-        # ✅ ADAPTATION: SmartChunkerPipeline avec support modulaire
+        # Initialisation pipeline principal
+        logger.info("🔧 Initialisation SmartChunkerPipeline...")
         pipeline = SmartChunkerPipeline()
         await pipeline.initialize()
         
-        # Test santé initial avec méthodes adaptatives
-        try:
-            health = await pipeline.health_check_v4()
-            logger.info(f"✅ Pipeline v5.0 initialisé - Status: {health['status']}")
-        except AttributeError:
-            # Fallback pour anciennes méthodes
-            health = await pipeline.get_health_status() if hasattr(pipeline, 'get_health_status') else {"status": "unknown"}
-            logger.info(f"✅ Pipeline v5.0 initialisé - Status: {health.get('status', 'initialized')}")
-        
-        # Log informations configuration avec fallback
-        try:
-            config_info = await pipeline.get_config_info_v4()
-            logger.info(f"⚙️ LLM: {config_info.get('models', {}).get('llm_model', 'N/A')}")
-            logger.info(f"🧬 Embedding: {config_info.get('models', {}).get('embedding_model', 'N/A')}")
-            logger.info(f"🦛 Chonkie: {config_info.get('models', {}).get('chonkie_available', False)}")
-        except AttributeError:
-            logger.info("⚙️ Configuration détaillée non disponible (mode fallback)")
+        # Vérification santé
+        health = await pipeline.health_check_v4()
+        logger.info(f"🏥 Status santé: {health['status']}")
+        
+        if health['status'] != 'healthy':
+            logger.warning(f"⚠️ Pipeline en mode dégradé: {health['status']}")
+        
+        # Configuration système
+        config_info = await pipeline.get_config_info_v4()
+        logger.info(f"🧠 LLM: {config_info['models']['llm_model']}")
+        logger.info(f"🔤 Embedding: {config_info['models']['embedding_model']}")
+        logger.info(f"🦛 Chonkie: {'✅' if config_info['models']['chonkie_available'] else '❌'}")
+        
+        # Test rapide de fonctionnement
+        test_request = ChunkRequest(
+            text="Test d'initialisation du système de chunking.",
+            titre="Test Init",
+            source_id="init_test"
+        )
+        
+        test_result = await pipeline.process_text(test_request)
+        logger.info(f"✅ Test init: {test_result.total_chunks} chunks générés")
         
-        logger.info("🔧 LlamaIndex moderne modulaire configuré")
+        logger.info("🎉 API Chunking Sémantique v4.0 prête !")
         
     except Exception as e:
-        logger.error(f"❌ Erreur initialisation pipeline v5.0: {e}")
+        logger.error(f"❌ ERREUR CRITIQUE lors du démarrage: {e}")
+        logger.error("Le service ne pourra pas fonctionner correctement")
         raise
 
 @app.on_event("shutdown")
 async def shutdown_event():
-    """✅ Nettoyage à l'arrêt optimisé v5.0"""
+    """Nettoyage propre à l'arrêt"""
     global pipeline, executor
+    
     try:
-        logger.info("🛑 Arrêt du service - nettoyage en cours...")
+        logger.info("🛑 Arrêt du service en cours...")
         
+        # Nettoyage pipeline
         if pipeline:
-            # Nettoyage adaptatif selon les méthodes disponibles
-            if hasattr(pipeline, 'cleanup'):
-                await pipeline.cleanup()
-            elif hasattr(pipeline, '_cleanup_memory_v4'):
-                await pipeline._cleanup_memory_v4()
+            await pipeline.cleanup()
+            logger.info("✅ Pipeline nettoyé")
         
+        # Nettoyage executor
         if executor:
-            executor.shutdown(wait=True)
+            executor.shutdown(wait=True, timeout=10)
+            logger.info("✅ Executor fermé")
         
         # Nettoyage mémoire final
         gc.collect()
         
-        logger.info("✅ Nettoyage v5.0 terminé")
+        # Statistiques finales
+        uptime = time.time() - startup_time
+        logger.info(f"📊 Statistiques finales:")
+        logger.info(f"   - Temps de fonctionnement: {uptime:.1f}s")
+        logger.info(f"   - Requêtes traitées: {request_count}")
+        logger.info(f"   - Moyenne: {request_count/uptime:.2f} req/s")
+        
+        logger.info("✅ Arrêt propre terminé")
         
     except Exception as e:
-        logger.error(f"⚠️ Erreur lors du nettoyage: {e}")
+        logger.error(f"⚠️ Erreur lors de l'arrêt: {e}")
+
+# ✅ ENDPOINTS PRINCIPAUX
 
-@app.get("/")
+@app.get("/", tags=["monitoring"])
 async def root():
-    """Point d'entrée racine avec informations service v5.0"""
+    """Page d'accueil avec informations complètes du service"""
+    uptime = time.time() - startup_time
+    
     return {
-        "service": "Chunking Sémantique Intelligent API",
-        "version": "5.0.0",
-        "status": "running",
-        "architecture": "LlamaIndex Moderne Modulaire",
+        "service": "🧠 Chunking Sémantique Intelligent API",
+        "version": "4.0.0",
+        "status": "🟢 Opérationnel" if pipeline else "🔴 Non initialisé",
+        "uptime_seconds": round(uptime, 1),
+        "requests_processed": request_count,
+        
         "features": [
-            "Chunking sémantique avec Chonkie",
-            "LlamaIndex moderne (llama-index-core)",
-            "Hiérarchie récursive intelligente", 
-            "Relations bidirectionnelles",
-            "Export Obsidian [[Titre]], id",
-            "Agents spécialisés IA",
-            "100% gratuit (HuggingFace local)"
-        ],
-        "endpoints": [
-            "GET / - Informations service",
-            "GET /health - Vérification santé",
-            "GET /config - Configuration système",
-            "POST /chunk - Chunking principal",
-            "POST /chunk-batch - Chunking par lots",
-            "POST /test - Test de fonctionnement"
+            "🧩 Chunking sémantique avec Chonkie",
+            "🏗️ Hiérarchie récursive intelligente", 
+            "🔗 Relations bidirectionnelles parent/enfant",
+            "📝 Export Obsidian format [[Titre]], id",
+            "🤖 Base connaissance pour agents IA spécialisés",
+            "💰 100% gratuit sur HuggingFace Space",
+            "🔄 Optimisé pour n8n et automation"
         ],
-        "documentation": "/docs",
-        "compatible_with": [
-            "llama-index-core (moderne)",
-            "llama-index-embeddings-huggingface",
-            "chonkie >= 0.1.0"
-        ]
+        
+        "endpoints": {
+            "chunking": [
+                "POST /chunk - Chunking principal",
+                "POST /chunk-batch - Traitement par lots"
+            ],
+            "monitoring": [
+                "GET /health - Vérification santé détaillée",
+                "GET /config - Configuration système",
+                "GET /stats - Statistiques d'usage"
+            ],
+            "test": [
+                "POST /test - Test de validation",
+                "GET /ping - Test connectivité simple"
+            ]
+        },
+        
+        "documentation": {
+            "interactive": "/docs",
+            "redoc": "/redoc"
+        },
+        
+        "support": {
+            "n8n_compatible": True,
+            "max_text_length": "500,000 caractères",
+            "max_batch_size": 3,
+            "response_format": "JSON structuré"
+        }
     }
 
-@app.get("/health")
+@app.get("/health", tags=["monitoring"])
 async def health_check():
-    """✅ Vérification santé complète v5.0 avec fallbacks adaptatifs"""
+    """Vérification santé complète et détaillée"""
     try:
         if pipeline is None:
             return {
-                "status": "error", 
+                "status": "🔴 error",
                 "message": "Pipeline non initialisé",
-                "version": "5.0.0",
-                "timestamp": time.time()
+                "version": "4.0.0",
+                "timestamp": time.time(),
+                "uptime": time.time() - startup_time,
+                "critical": True
             }
         
-        # ✅ ADAPTATION: Health check avec fallbacks multiples
-        health_result = None
-        memory_info = None
+        # Health check pipeline
+        health_result = await pipeline.health_check_v4()
         
-        # Tentative méthode v4.0
-        try:
-            health_result = await pipeline.health_check_v4()
-        except AttributeError:
-            # Fallback méthode alternative
-            try:
-                health_result = await pipeline.get_health_status()
-            except AttributeError:
-                # Fallback basique
-                health_result = {
-                    "status": "running",
-                    "checks": {"initialization": True},
-                    "version": "5.0.0"
-                }
-        
-        # Tentative récupération mémoire
+        # Informations mémoire
+        memory_info = pipeline.get_memory_usage_v4()
+        
+        # Statistiques système
+        import psutil
         try:
-            memory_info = pipeline.get_memory_usage_v4()
-        except AttributeError:
-            try:
-                memory_info = pipeline.get_memory_usage()
-            except AttributeError:
-                memory_info = {"status": "monitoring_unavailable"}
+            cpu_percent = psutil.cpu_percent(interval=1)
+            memory_percent = psutil.virtual_memory().percent
+        except:
+            cpu_percent = 0
+            memory_percent = 0
+        
+        # Status coloré
+        status_map = {
+            "healthy": "🟢 healthy",
+            "degraded": "🟡 degraded", 
+            "unhealthy": "🔴 unhealthy",
+            "error": "🔴 error"
+        }
         
         return {
             **health_result,
+            "status": status_map.get(health_result['status'], health_result['status']),
             "memory_info": memory_info,
-            "version": "5.0.0",
-            "architecture": "LlamaIndex Moderne"
+            "system_info": {
+                "cpu_percent": cpu_percent,
+                "memory_percent": memory_percent,
+                "uptime": time.time() - startup_time,
+                "requests_processed": request_count
+            },
+            "version": "4.0.0"
         }
         
     except Exception as e:
-        logger.error(f"❌ Erreur health check v5.0: {e}")
+        logger.error(f"❌ Erreur health check: {e}")
         return {
-            "status": "error", 
+            "status": "🔴 error",
             "message": f"Erreur health check: {str(e)}",
-            "version": "5.0.0",
-            "timestamp": time.time()
+            "version": "4.0.0",
+            "timestamp": time.time(),
+            "critical": True
         }
 
-@app.get("/config")
+@app.get("/config", tags=["monitoring"])
 async def get_config():
-    """✅ Informations configuration système v5.0 avec adaptation modulaire"""
+    """Configuration système détaillée"""
     try:
         if pipeline is None:
             raise HTTPException(status_code=503, detail="Pipeline non initialisé")
         
-        # ✅ ADAPTATION: Configuration avec fallbacks
-        config_info = {}
+        config_info = await pipeline.get_config_info_v4()
         
-        try:
-            config_info = await pipeline.get_config_info_v4()
-        except AttributeError:
-            # Fallback configuration basique
-            config_info = {
-                "version": "5.0.0",
-                "architecture": "LlamaIndex Moderne Modulaire",
-                "models": {
-                    "llm_available": hasattr(pipeline, 'llm'),
-                    "embedding_available": hasattr(pipeline, 'embed_model'),
-                    "chonkie_available": hasattr(pipeline, 'chonkie_semantic')
-                },
-                "chunking_config": {
-                    "pipeline_type": "SmartChunkerPipeline",
-                    "initialized": pipeline._is_initialized if hasattr(pipeline, '_is_initialized') else True
-                }
-            }
+        # Ajout informations runtime
+        runtime_info = {
+            "python_version": f"{os.sys.version_info.major}.{os.sys.version_info.minor}.{os.sys.version_info.micro}",
+            "platform": os.name,
+            "workers": 1,
+            "max_request_size": "500KB",
+            "cache_enabled": True,
+            "environment": "HuggingFace Space"
+        }
         
         return {
             **config_info,
-            "api_version": "5.0.0",
-            "timestamp": time.time(),
-            "llamaindex_architecture": "moderne_modulaire"
+            "runtime_info": runtime_info,
+            "api_version": "4.0.0",
+            "timestamp": time.time()
         }
         
     except Exception as e:
-        logger.error(f"❌ Erreur récupération config v5.0: {e}")
+        logger.error(f"❌ Erreur récupération config: {e}")
         raise HTTPException(status_code=500, detail=f"Erreur config: {str(e)}")
 
-@app.post("/chunk", response_model=ChunkResponse)
+@app.get("/stats", tags=["monitoring"])
+async def get_stats():
+    """Statistiques d'usage détaillées"""
+    uptime = time.time() - startup_time
+    avg_requests_per_minute = (request_count / uptime) * 60 if uptime > 0 else 0
+    
+    return {
+        "service_stats": {
+            "uptime_seconds": round(uptime, 1),
+            "uptime_formatted": f"{int(uptime//3600)}h {int((uptime%3600)//60)}m {int(uptime%60)}s",
+            "total_requests": request_count,
+            "avg_requests_per_minute": round(avg_requests_per_minute, 2)
+        },
+        "system_health": {
+            "pipeline_initialized": pipeline is not None,
+            "memory_usage": pipeline.get_memory_usage_v4() if pipeline else "N/A"
+        },
+        "version": "4.0.0",
+        "timestamp": time.time()
+    }
+
+@app.post("/chunk", response_model=ChunkResponse, tags=["chunking"])
 async def chunk_text(request: ChunkRequest):
     """
-    ✅ Point d'entrée principal chunking sémantique intelligent v5.0
+    🧠 ENDPOINT PRINCIPAL - Chunking sémantique intelligent
     
-    Traitement récursif hiérarchique avec LlamaIndex moderne:
-    - llama-index-core + llama-index-embeddings-huggingface
-    - Chonkie SemanticChunker + RecursiveChunker
-    - Relations bidirectionnelles complètes
+    **Fonctionnalités:**
+    - Chunking sémantique avec Chonkie + LlamaIndex
+    - Relations hiérarchiques bidirectionnelles
     - Export Obsidian format [[Titre]], id
-    - Génération base connaissance agents IA
+    - Base connaissance pour agents IA
+    
+    **Optimisé pour n8n et automation**
     """
     if pipeline is None:
-        raise HTTPException(status_code=503, detail="Pipeline non initialisé")
+        raise HTTPException(
+            status_code=503, 
+            detail="❌ Pipeline non initialisé - Redémarrez le service"
+        )
     
     start_time = time.time()
     
     try:
-        logger.info(f"📝 Début chunking v5.0: {request.titre or 'Sans titre'}")
+        logger.info(f"📝 Début chunking: {request.titre or 'Sans titre'} ({len(request.text)} chars)")
         
         # Validation entrées renforcée
         if not request.text or len(request.text.strip()) < 10:
             raise HTTPException(
                 status_code=400, 
-                detail="Le texte doit contenir au moins 10 caractères"
+                detail="❌ Le texte doit contenir au moins 10 caractères"
             )
         
-        if len(request.text) > 500000:  # 500k caractères max pour HF Space gratuit
+        # Limite HF Space gratuit
+        max_length = 500000
+        if len(request.text) > max_length:
             raise HTTPException(
                 status_code=400,
-                detail="Texte trop long (max 500,000 caractères pour Space gratuit)"
+                detail=f"❌ Texte trop long ({len(request.text)} chars). Maximum: {max_length:,} caractères"
             )
         
-        # ✅ ADAPTATION: Appel méthode avec fallbacks
-        result = None
-        
-        # Tentative méthode v4.0
-        try:
-            result = await pipeline.process_text(request)
-        except AttributeError:
-            # Fallback méthode alternative
-            try:
-                result = await pipeline.process_text_sync(request)
-            except AttributeError:
-                raise HTTPException(
-                    status_code=500,
-                    detail="Méthode de traitement non disponible dans cette version du pipeline"
-                )
+        # Traitement principal
+        result = await pipeline.process_text(request)
         
         processing_time = time.time() - start_time
-        logger.info(f"✅ Chunking v5.0 terminé: {result.total_chunks} chunks en {processing_time:.2f}s")
+        
+        # Log succès
+        logger.info(
+            f"✅ Chunking terminé: {result.total_chunks} chunks, "
+            f"{result.total_tokens} tokens en {processing_time:.2f}s"
+        )
         
         return result
         
     except HTTPException:
-        # Re-lever les HTTPException sans modification
         raise
     except Exception as e:
-        logger.error(f"❌ Erreur chunking v5.0: {str(e)}")
+        logger.error(f"❌ Erreur chunking: {str(e)}")
         
-        # Nettoyage mémoire en cas d'erreur avec fallback
+        # Nettoyage mémoire d'urgence
         try:
-            if hasattr(pipeline, '_cleanup_memory_v4'):
-                await pipeline._cleanup_memory_v4()
-            elif hasattr(pipeline, '_cleanup_memory'):
-                await pipeline._cleanup_memory()
+            await pipeline._cleanup_memory_v4()
+            gc.collect()
         except:
             pass
         
-        gc.collect()
-        
         raise HTTPException(
             status_code=500, 
-            detail=f"Erreur traitement chunking v5.0: {str(e)}"
+            detail=f"❌ Erreur traitement: {str(e)}"
         )
 
-@app.post("/chunk-batch")
+@app.post("/chunk-batch", tags=["chunking"])
 async def chunk_batch(requests: List[ChunkRequest]):
-    """✅ Traitement par lots optimisé v5.0 (limité HF Space gratuit)"""
+    """
+    📦 Traitement par lots optimisé pour HF Space gratuit
+    
+    **Limites:**
+    - Maximum 3 textes par lot
+    - Traitement séquentiel pour économiser la mémoire
+    """
     
     # Validation limite batch pour Space gratuit
     max_batch_size = 3
     if len(requests) > max_batch_size:
         raise HTTPException(
             status_code=400, 
-            detail=f"Maximum {max_batch_size} textes par lot sur HF Space gratuit"
+            detail=f"❌ Maximum {max_batch_size} textes par lot sur HF Space gratuit"
         )
     
     if pipeline is None:
-        raise HTTPException(status_code=503, detail="Pipeline non initialisé")
+        raise HTTPException(status_code=503, detail="❌ Pipeline non initialisé")
     
     start_time = time.time()
     results = []
     
     try:
-        logger.info(f"📦 Début chunking batch v5.0: {len(requests)} textes")
+        logger.info(f"📦 Début batch: {len(requests)} textes")
         
         for idx, request in enumerate(requests):
             try:
-                # Traitement individuel avec méthodes adaptatives
-                result = None
-                
-                try:
-                    result = await pipeline.process_text(request)
-                except AttributeError:
-                    result = await pipeline.process_text_sync(request)
+                logger.info(f"   📝 Traitement {idx+1}/{len(requests)}: {request.titre or 'Sans titre'}")
                 
+                result = await pipeline.process_text(request)
                 results.append({
                     "success": True,
                     "index": idx,
@@ -399,122 +520,187 @@ async def chunk_batch(requests: List[ChunkRequest]):
                     "result": result
                 })
                 
+                # Nettoyage entre chaque traitement
+                if idx < len(requests) - 1:  # Pas pour le dernier
+                    await pipeline._cleanup_memory_v4()
+                
             except Exception as e:
-                logger.error(f"❌ Erreur chunking batch item {idx}: {e}")
+                logger.error(f"❌ Erreur batch item {idx}: {e}")
                 results.append({
                     "success": False,
                     "index": idx,
-                    "source_id": request.source_id,
+                    "source_id": request.source_id or f"item_{idx}",
                     "error": str(e)
                 })
         
         total_time = time.time() - start_time
         successful_results = [r for r in results if r["success"]]
         
-        # Nettoyage mémoire après batch
+        # Nettoyage final
         try:
-            if hasattr(pipeline, '_cleanup_memory_v4'):
-                await pipeline._cleanup_memory_v4()
+            await pipeline._cleanup_memory_v4()
         except:
             pass
         
-        logger.info(f"✅ Batch v5.0 terminé: {len(successful_results)}/{len(requests)} succès en {total_time:.2f}s")
+        logger.info(
+            f"✅ Batch terminé: {len(successful_results)}/{len(requests)} succès "
+            f"en {total_time:.2f}s"
+        )
         
         return {
             "results": results,
-            "total_processed": len(requests),
-            "successful": len(successful_results),
-            "failed": len(requests) - len(successful_results),
-            "total_processing_time": total_time,
-            "version": "5.0.0"
+            "summary": {
+                "total_processed": len(requests),
+                "successful": len(successful_results),
+                "failed": len(requests) - len(successful_results),
+                "success_rate": f"{(len(successful_results)/len(requests)*100):.1f}%",
+                "total_processing_time": round(total_time, 2),
+                "avg_time_per_item": round(total_time / len(requests), 2)
+            },
+            "version": "4.0.0",
+            "timestamp": time.time()
         }
         
     except Exception as e:
-        logger.error(f"❌ Erreur chunking batch v5.0: {e}")
+        logger.error(f"❌ Erreur batch global: {e}")
         gc.collect()
         raise HTTPException(
             status_code=500, 
-            detail=f"Erreur traitement batch v5.0: {str(e)}"
+            detail=f"❌ Erreur traitement batch: {str(e)}"
         )
 
-# ✅ Endpoint test adapté pour v5.0
-@app.post("/test")
+@app.post("/test", tags=["test"])
 async def test_chunking():
-    """Endpoint de test pour validation déploiement v5.0"""
+    """🧪 Test de validation du déploiement"""
     if pipeline is None:
-        raise HTTPException(status_code=503, detail="Pipeline non initialisé")
+        raise HTTPException(status_code=503, detail="❌ Pipeline non initialisé")
     
     try:
-        # Test avec texte simple
         test_request = ChunkRequest(
-            text="Ceci est un test de chunking sémantique intelligent v5.0. "
-                 "Le système utilise LlamaIndex moderne avec llama-index-core. "
-                 "Il intègre Chonkie pour le découpage sémantique avancé. "
-                 "Il génère des relations hiérarchiques bidirectionnelles. "
-                 "L'export Obsidian utilise le format [[Titre]], id. "
-                 "Les agents IA reçoivent une base de connaissance structurée.",
-            titre="Test Chunking v5.0",
-            source_id="test_v5",
-            include_metadata=True
+            text="""
+            Ceci est un test complet de chunking sémantique intelligent v4.0.
+            
+            Le système utilise Chonkie pour le découpage sémantique avancé.
+            Il génère des relations hiérarchiques bidirectionnelles entre les chunks.
+            
+            L'export Obsidian utilise le format [[Titre]], id pour les liens.
+            Les agents IA reçoivent une base de connaissance parfaitement structurée.
+            
+            Ce test valide toutes les fonctionnalités principales du système.
+            """,
+            titre="Test Validation v4.0",
+            source_id="validation_test_v4",
+            include_metadata=True,
+            export_obsidian=True,
+            export_agents=True
         )
         
-        # Test avec méthodes adaptatives
-        result = None
-        try:
-            result = await pipeline.process_text(test_request)
-        except AttributeError:
-            result = await pipeline.process_text_sync(test_request)
+        start_time = time.time()
+        result = await pipeline.process_text(test_request)
+        test_time = time.time() - start_time
+        
+        # Vérifications détaillées
+        checks = {
+            "chunking_functional": result.total_chunks > 0,
+            "metadata_extracted": len(result.chunks[0].metadata.keywords) > 0 if result.chunks else False,
+            "hierarchy_built": len(result.hierarchy) > 0,
+            "obsidian_export": result.obsidian_export is not None,
+            "agent_knowledge": result.agent_knowledge is not None,
+            "processing_time_ok": test_time < 30  # Moins de 30s
+        }
+        
+        success_rate = sum(checks.values()) / len(checks) * 100
         
         return {
-            "test_status": "success",
-            "chunks_generated": result.total_chunks,
-            "processing_time": result.processing_time,
-            "features_tested": [
-                "LlamaIndex moderne (llama-index-core)",
-                "Chunking sémantique Chonkie",
-                "Relations hiérarchiques",
-                "Export Obsidian",
-                "Base connaissance agents"
+            "test_status": "✅ SUCCESS" if success_rate == 100 else "⚠️ PARTIAL",
+            "success_rate": f"{success_rate:.1f}%",
+            "results": {
+                "chunks_generated": result.total_chunks,
+                "tokens_processed": result.total_tokens,
+                "processing_time": round(test_time, 2),
+                "hierarchy_levels": len(result.hierarchy)
+            },
+            "checks": checks,
+            "features_validated": [
+                "✅ Chunking sémantique Chonkie" if checks["chunking_functional"] else "❌ Chunking failed",
+                "✅ Extraction métadonnées" if checks["metadata_extracted"] else "❌ Metadata failed",
+                "✅ Relations hiérarchiques" if checks["hierarchy_built"] else "❌ Hierarchy failed",
+                "✅ Export Obsidian" if checks["obsidian_export"] else "❌ Obsidian failed",
+                "✅ Base agents IA" if checks["agent_knowledge"] else "❌ Agents failed"
             ],
-            "version": "5.0.0",
-            "architecture": "LlamaIndex Moderne Modulaire"
+            "version": "4.0.0",
+            "timestamp": time.time()
         }
         
     except Exception as e:
-        logger.error(f"❌ Erreur test chunking v5.0: {e}")
+        logger.error(f"❌ Test validation échoué: {e}")
         raise HTTPException(
             status_code=500, 
-            detail=f"Test échoué v5.0: {str(e)}"
+            detail=f"❌ Test échoué: {str(e)}"
         )
 
-# ✅ Gestion erreur 404 personnalisée
+@app.get("/ping", tags=["test"])
+async def ping():
+    """🏓 Test de connectivité simple"""
+    return {
+        "ping": "pong",
+        "timestamp": time.time(),
+        "version": "4.0.0",
+        "status": "🟢 Opérationnel" if pipeline else "🔴 Non initialisé"
+    }
+
+# ✅ GESTION D'ERREURS PERSONNALISÉE
+
 @app.exception_handler(404)
 async def not_found_handler(request: Request, exc):
+    """Gestionnaire 404 personnalisé"""
     return JSONResponse(
         status_code=404,
         content={
-            "error": "Endpoint non trouvé",
+            "error": "❌ Endpoint non trouvé",
             "message": f"L'endpoint {request.url.path} n'existe pas",
-            "available_endpoints": ["/", "/health", "/config", "/chunk", "/chunk-batch", "/test"],
+            "available_endpoints": {
+                "chunking": ["/chunk", "/chunk-batch"],
+                "monitoring": ["/health", "/config", "/stats"],
+                "test": ["/test", "/ping"],
+                "docs": ["/docs", "/redoc"]
+            },
+            "suggestion": "Consultez /docs pour la documentation complète",
+            "version": "4.0.0"
+        }
+    )
+
+@app.exception_handler(422)
+async def validation_exception_handler(request: Request, exc):
+    """Gestionnaire erreurs de validation Pydantic"""
+    return JSONResponse(
+        status_code=422,
+        content={
+            "error": "❌ Erreur de validation",
+            "message": "Les données envoyées ne respectent pas le format attendu",
+            "detail": str(exc),
+            "hint": "Vérifiez la structure de votre requête JSON",
             "documentation": "/docs",
-            "version": "5.0.0",
-            "architecture": "LlamaIndex Moderne"
+            "version": "4.0.0"
         }
     )
 
-# Configuration pour démarrage Uvicorn optimisé HF Space
+# ✅ POINT D'ENTRÉE PRINCIPAL
 if __name__ == "__main__":
     import uvicorn
     
+    logger.info("🚀 Démarrage direct du serveur...")
+    
     # Configuration optimisée pour HF Space gratuit
     uvicorn.run(
         "app:app", 
         host="0.0.0.0", 
-        port=7860, 
-        reload=False,  # Production mode
+        port=7860,  # Port standard HF Space
+        reload=False,  # Mode production
         access_log=False,  # Économie ressources
         log_level="info",
         workers=1,  # HF Space gratuit = 1 worker
         timeout_keep_alive=30,
-        limit_concurrency=10  # Limite connexions simultanées
+        limit_concurrency=10,  # Limite connexions simultanées
+        timeout_graceful_shutdown=30
     )