Upload 9 files

Dockerfile

@@ -0,0 +1,128 @@
+# Dockerfile pour Smart Chunker API v4.0
+# Compatible HuggingFace Spaces + Pipeline complet
+# Version finale corrigée
+
+# ===================================
+# IMAGE DE BASE OPTIMISÉE
+# ===================================
+
+FROM python:3.10-slim
+
+# ===================================
+# MÉTADONNÉES
+# ===================================
+
+LABEL maintainer="Smart Chunker Pipeline v4.0"
+LABEL description="API de chunking sémantique intelligent récursif"
+LABEL version="4.0.0"
+
+# ===================================
+# VARIABLES D'ENVIRONNEMENT
+# ===================================
+
+# Configuration Python
+ENV PYTHONUNBUFFERED=1
+ENV PYTHONDONTWRITEBYTECODE=1
+ENV PYTHONIOENCODING=utf-8
+
+# Configuration HuggingFace pour Spaces
+ENV HF_HOME=/tmp/huggingface
+ENV TRANSFORMERS_CACHE=/tmp/transformers
+ENV HF_HUB_CACHE=/tmp/hub
+ENV TOKENIZERS_PARALLELISM=false
+ENV HF_HUB_DISABLE_PROGRESS_BARS=1
+ENV TRANSFORMERS_VERBOSITY=error
+
+# Configuration FastAPI/Uvicorn
+ENV PORT=7860
+ENV HOST=0.0.0.0
+ENV WORKERS=1
+
+# Optimisations performance
+ENV OMP_NUM_THREADS=1
+ENV OPENBLAS_NUM_THREADS=1
+ENV MKL_NUM_THREADS=1
+
+# ===================================
+# INSTALLATION DÉPENDANCES SYSTÈME
+# ===================================
+
+RUN apt-get update && apt-get install -y \
+    build-essential \
+    git \
+    curl \
+    && rm -rf /var/lib/apt/lists/* \
+    && apt-get clean
+
+# ===================================
+# CRÉATION RÉPERTOIRE TRAVAIL
+# ===================================
+
+WORKDIR /app
+
+# ===================================
+# CRÉATION DOSSIERS CACHE
+# ===================================
+
+RUN mkdir -p /tmp/huggingface \
+    && mkdir -p /tmp/transformers \
+    && mkdir -p /tmp/hub \
+    && mkdir -p /tmp/llm \
+    && mkdir -p /tmp/embeddings \
+    && mkdir -p /tmp/logs \
+    && chmod -R 755 /tmp
+
+# ===================================
+# COPIE FICHIERS CONFIGURATION
+# ===================================
+
+# Copie requirements en premier pour cache Docker
+COPY requirements.txt .
+
+# ===================================
+# INSTALLATION DÉPENDANCES PYTHON
+# ===================================
+
+# Mise à jour pip
+RUN pip install --no-cache-dir --upgrade pip
+
+# Installation des dépendances avec cache nettoyé
+RUN rm -rf /root/.cache/pip \
+    && pip install --no-cache-dir -r requirements.txt
+
+# ===================================
+# COPIE CODE APPLICATION
+# ===================================
+
+# Copie tous les fichiers Python
+COPY *.py .
+COPY config.yaml .
+
+# ===================================
+# CONFIGURATION PERMISSIONS
+# ===================================
+
+# S'assurer que les dossiers sont accessibles
+RUN chmod -R 755 /app \
+    && chmod -R 777 /tmp
+
+# ===================================
+# VÉRIFICATION SANTÉ
+# ===================================
+
+# Healthcheck pour vérifier que l'API répond
+HEALTHCHECK --interval=30s --timeout=10s --start-period=60s --retries=3 \
+    CMD curl -f http://localhost:${PORT}/health || exit 1
+
+# ===================================
+# EXPOSITION PORT
+# ===================================
+
+EXPOSE ${PORT}
+
+# ===================================
+# COMMANDE DE DÉMARRAGE
+# ===================================
+
+# Commande par défaut pour démarrer l'application
+CMD ["uvicorn", "app:app", "--host", "0.0.0.0", "--port", "7860", "--workers", "1"]

app.py

@@ -0,0 +1,725 @@
+"""
+app.py v4.0 FINAL - FastAPI pour Chunking Sémantique Intelligent
+
+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 tempfile
+
+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
+from concurrent.futures import ThreadPoolExecutor
+
+
+import os
+
+#os.environ["HF_HOME"] = "/tmp/cache/huggingface"
+#os.environ["TRANSFORMERS_CACHE"] = "/tmp/cache/transformers"
+
+
+os.environ["HF_HOME"] = "/tmp/hf"
+os.environ["TRANSFORMERS_CACHE"] = "/tmp/hf"
+
+
+
+
+# Configuration logging optimisée
+logging.basicConfig(
+    level=logging.INFO,
+    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__)
+
+# ✅ IMPORTS PRINCIPAUX - Vérification de compatibilité
+try:
+    from chunker_pipeline import SmartChunkerPipeline
+    from schemas import ChunkRequest, ChunkResponse, ChunkMetadata
+    logger.info("✅ Modules chunking v4.0 importés avec succès")
+except ImportError as e:
+    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 ENVIRONNEMENT HF SPACE SÉCURISÉE
+def setup_environment():
+    """Configuration optimisée pour Hugging Face Space gratuit"""
+    
+    # ✅ Compatible Hugging Face Space (car /tmp est accessible en écriture)
+    
+    cache_base = os.path.join(tempfile.gettempdir(), "cache")
+    os.environ["HF_HOME"] = os.path.join(cache_base, "huggingface")
+    os.environ["TRANSFORMERS_CACHE"] = os.path.join(cache_base, "transformers")
+    os.environ["HF_HUB_CACHE"] = os.path.join(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 = [
+    os.environ["HF_HOME"],
+    os.environ["TRANSFORMERS_CACHE"],
+    os.environ["HF_HUB_CACHE"],
+    os.path.join(cache_base, "llm"),
+    os.path.join(cache_base, "embeddings"),
+    os.path.join(cache_base, "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é")
+
+# Configuration environnement
+setup_environment()
+
+# ✅ INITIALISATION FASTAPI OPTIMISÉE
+app = FastAPI(
+    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",
+    openapi_tags=[
+        {"name": "chunking", "description": "Endpoints de chunking principal"},
+        {"name": "monitoring", "description": "Santé et configuration"},
+        {"name": "test", "description": "Tests et validation"}
+    ]
+)
+
+# ✅ CORS ÉTENDU POUR N8N ET INTÉGRATIONS
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],  # Nécessaire pour n8n
+    allow_credentials=True,
+    allow_methods=["GET", "POST", "PUT", "DELETE", "OPTIONS"],
+    allow_headers=["*"],
+    expose_headers=["*"]
+)
+
+# ✅ VARIABLES GLOBALES
+pipeline = None
+executor = ThreadPoolExecutor(max_workers=1)  # HF Space gratuit = 1 worker max
+startup_time = time.time()
+request_count = 0
+
+# ✅ MIDDLEWARE MONITORING ET SÉCURITÉ
+@app.middleware("http")
+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 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(),
+                "request_id": request_count,
+                "version": "4.0.0"
+            }
+        )
+
+# ✅ ÉVÉNEMENTS LIFECYCLE
+@app.on_event("startup")
+async def startup_event():
+    """Initialisation complète au démarrage"""
+    global pipeline
+    
+    try:
+        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)")
+        
+        # Initialisation pipeline principal
+        logger.info("🔧 Initialisation SmartChunkerPipeline...")
+        pipeline = SmartChunkerPipeline()
+        await pipeline.initialize()
+        
+        # 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("🎉 API Chunking Sémantique v4.0 prête !")
+        
+    except Exception as 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 propre à l'arrêt"""
+    global pipeline, executor
+    
+    try:
+        logger.info("🛑 Arrêt du service en cours...")
+        
+        # Nettoyage pipeline
+        if pipeline:
+            await pipeline.cleanup()
+            logger.info("✅ Pipeline nettoyé")
+        
+        # Nettoyage executor
+        if executor:
+            executor.shutdown(wait=True, timeout=10)
+            logger.info("✅ Executor fermé")
+        
+        # Nettoyage mémoire final
+        gc.collect()
+        
+        # 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 de l'arrêt: {e}")
+
+# ✅ ENDPOINTS PRINCIPAUX
+
+@app.get("/", tags=["monitoring"])
+async def root():
+    """Page d'accueil avec informations complètes du service"""
+    uptime = time.time() - startup_time
+    
+    return {
+        "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",
+            "🏗️ 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"
+        ],
+        
+        "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", tags=["monitoring"])
+async def health_check():
+    """Vérification santé complète et détaillée"""
+    try:
+        if pipeline is None:
+            return {
+                "status": "🔴 error",
+                "message": "Pipeline non initialisé",
+                "version": "4.0.0",
+                "timestamp": time.time(),
+                "uptime": time.time() - startup_time,
+                "critical": True
+            }
+        
+        # Health check pipeline
+        health_result = await pipeline.health_check_v4()
+        
+        # Informations mémoire
+        memory_info = pipeline.get_memory_usage_v4()
+        
+        # Statistiques système
+        import psutil
+        try:
+            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,
+            "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: {e}")
+        return {
+            "status": "🔴 error",
+            "message": f"Erreur health check: {str(e)}",
+            "version": "4.0.0",
+            "timestamp": time.time(),
+            "critical": True
+        }
+
+@app.get("/config", tags=["monitoring"])
+async def get_config():
+    """Configuration système détaillée"""
+    try:
+        if pipeline is None:
+            raise HTTPException(status_code=503, detail="Pipeline non initialisé")
+        
+        config_info = await pipeline.get_config_info_v4()
+        
+        # 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,
+            "runtime_info": runtime_info,
+            "api_version": "4.0.0",
+            "timestamp": time.time()
+        }
+        
+    except Exception as e:
+        logger.error(f"❌ Erreur récupération config: {e}")
+        raise HTTPException(status_code=500, detail=f"Erreur config: {str(e)}")
+
+@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):
+    """
+    🧠 ENDPOINT PRINCIPAL - Chunking sémantique intelligent
+    
+    **Fonctionnalités:**
+    - Chunking sémantique avec Chonkie + LlamaIndex
+    - Relations hiérarchiques bidirectionnelles
+    - Export Obsidian format [[Titre]], id
+    - Base connaissance pour agents IA
+    
+    **Optimisé pour n8n et automation**
+    """
+    if pipeline is None:
+        raise HTTPException(
+            status_code=503, 
+            detail="❌ Pipeline non initialisé - Redémarrez le service"
+        )
+    
+    start_time = time.time()
+    
+    try:
+        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"
+            )
+        
+        # Limite HF Space gratuit
+        max_length = 500000
+        if len(request.text) > max_length:
+            raise HTTPException(
+                status_code=400,
+                detail=f"❌ Texte trop long ({len(request.text)} chars). Maximum: {max_length:,} caractères"
+            )
+        
+        # Traitement principal
+        result = await pipeline.process_text(request)
+        
+        processing_time = time.time() - start_time
+        
+        # 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:
+        raise
+    except Exception as e:
+        logger.error(f"❌ Erreur chunking: {str(e)}")
+        
+        # Nettoyage mémoire d'urgence
+        try:
+            await pipeline._cleanup_memory_v4()
+            gc.collect()
+        except:
+            pass
+        
+        raise HTTPException(
+            status_code=500, 
+            detail=f"❌ Erreur traitement: {str(e)}"
+        )
+
+@app.post("/chunk-batch", tags=["chunking"])
+async def chunk_batch(requests: List[ChunkRequest]):
+    """
+    📦 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"
+        )
+    
+    if pipeline is None:
+        raise HTTPException(status_code=503, detail="❌ Pipeline non initialisé")
+    
+    start_time = time.time()
+    results = []
+    
+    try:
+        logger.info(f"📦 Début batch: {len(requests)} textes")
+        
+        for idx, request in enumerate(requests):
+            try:
+                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,
+                    "source_id": request.source_id,
+                    "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 batch item {idx}: {e}")
+                results.append({
+                    "success": False,
+                    "index": idx,
+                    "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 final
+        try:
+            await pipeline._cleanup_memory_v4()
+        except:
+            pass
+        
+        logger.info(
+            f"✅ Batch terminé: {len(successful_results)}/{len(requests)} succès "
+            f"en {total_time:.2f}s"
+        )
+        
+        return {
+            "results": results,
+            "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 batch global: {e}")
+        gc.collect()
+        raise HTTPException(
+            status_code=500, 
+            detail=f"❌ Erreur traitement batch: {str(e)}"
+        )
+
+@app.post("/test", tags=["test"])
+async def test_chunking():
+    """🧪 Test de validation du déploiement"""
+    if pipeline is None:
+        raise HTTPException(status_code=503, detail="❌ Pipeline non initialisé")
+    
+    try:
+        test_request = ChunkRequest(
+            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
+        )
+        
+        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" 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": "4.0.0",
+            "timestamp": time.time()
+        }
+        
+    except Exception as e:
+        logger.error(f"❌ Test validation échoué: {e}")
+        raise HTTPException(
+            status_code=500, 
+            detail=f"❌ Test échoué: {str(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é",
+            "message": f"L'endpoint {request.url.path} n'existe pas",
+            "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": "4.0.0"
+        }
+    )
+
+# ✅ 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,  # 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
+        timeout_graceful_shutdown=30
+    )

chunker_pipeline.py

@@ -0,0 +1,1582 @@
+"""
+Smart Chunker Pipeline v4.0 - VERSION FINALE FUSIONNÉE
+Combine les corrections GPT + toutes les fonctionnalités avancées originales
+Compatible LlamaIndex v0.12 + HuggingFace + CustomRecursiveChunker
+"""
+
+import os
+import sys
+import logging
+import yaml
+import asyncio
+import tempfile
+import time
+import hashlib
+import re
+import collections
+from typing import Dict, List, Any, Optional, Union, Tuple
+from pathlib import Path
+from dataclasses import dataclass, field
+from enum import Enum
+
+# LlamaIndex v0.12 imports
+from llama_index.core import Settings, Document, SimpleDirectoryReader
+from llama_index.core.schema import BaseEmbedding, BaseNode, TextNode
+from llama_index.embeddings.huggingface import HuggingFaceEmbedding
+from llama_index.llms.huggingface import HuggingFaceLLM
+from llama_index.core.node_parser import (
+    SentenceSplitter,
+    SemanticSplitterNodeParser, 
+    TokenTextSplitter,
+    HierarchicalNodeParser
+)
+
+# Transformers et models
+from sentence_transformers import SentenceTransformer
+import torch
+import gc
+
+# Import schemas
+from schemas import ChunkRequest, ChunkResponse, SemanticChunk, ChunkLevel, ChunkMetadata
+
+# Import du chunker personnalisé
+from custom_recursive_chunker import CustomRecursiveChunker, ChunkResult
+
+# Configuration logging
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
+)
+logger = logging.getLogger(__name__)
+
+# Vérification disponibilité Chonkie (optionnel)
+try:
+    from chonkie import SemanticChunker
+    CHONKIE_AVAILABLE = True
+    logger.info("✅ Chonkie disponible")
+except ImportError:
+    CHONKIE_AVAILABLE = False
+    logger.warning("⚠️ Chonkie non disponible - utilisation CustomRecursiveChunker")
+
+# ===================================
+# CONFIGURATION ENVIRONNEMENT HF SPACE
+# ===================================
+
+def setup_environment():
+    """Configuration optimisée pour Hugging Face Space gratuit"""
+    cache_base = os.path.join(tempfile.gettempdir(), "cache")
+    os.environ["HF_HOME"] = os.path.join(cache_base, "huggingface")
+    os.environ["TRANSFORMERS_CACHE"] = os.path.join(cache_base, "transformers")
+    os.environ["HF_HUB_CACHE"] = os.path.join(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 = [
+        os.environ["HF_HOME"],
+        os.environ["TRANSFORMERS_CACHE"],
+        os.environ["HF_HUB_CACHE"],
+        os.path.join(cache_base, "llm"),
+        os.path.join(cache_base, "embeddings"),
+        os.path.join(cache_base, "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é")
+
+# Configuration environnement
+setup_environment()
+
+# ===================================
+# WRAPPER EMBEDDING COMPATIBLE
+# ===================================
+
+class EmbeddingWrapper(BaseEmbedding):
+    """Wrapper pour compatibilité entre SentenceTransformer et BaseEmbedding"""
+    
+    def __init__(self, model):
+        super().__init__()
+        self.model = model
+        self._validate_model()
+    
+    def _validate_model(self):
+        """Valide que le modèle fonctionne correctement"""
+        try:
+            test_result = self.model.encode(["test"], convert_to_tensor=False)
+            if not hasattr(test_result, "__len__") or len(test_result) == 0:
+                raise ValueError("Le modèle ne retourne pas d'embeddings valides")
+            logger.info("✅ Le modèle d'embedding est conforme à BaseEmbedding (test réussi)")
+        except Exception as e:
+            logger.error(f"❌ Validation du modèle d'embedding échouée: {e}")
+            raise
+    
+    def _get_query_embedding(self, query: str) -> List[float]:
+        """Obtient l'embedding d'une requête"""
+        return self.model.encode([query], convert_to_tensor=False)[0].tolist()
+    
+    def _get_text_embedding(self, text: str) -> List[float]:
+        """Obtient l'embedding d'un texte"""
+        return self.model.encode([text], convert_to_tensor=False)[0].tolist()
+    
+    async def _aget_query_embedding(self, query: str) -> List[float]:
+        """Version async de _get_query_embedding"""
+        return self._get_query_embedding(query)
+    
+    async def _aget_text_embedding(self, text: str) -> List[float]:
+        """Version async de _get_text_embedding"""
+        return self._get_text_embedding(text)
+
+# ===================================
+# PIPELINE PRINCIPAL
+# ===================================
+
+class SmartChunkerPipeline:
+    """Pipeline de chunking intelligent v4.0 avec toutes les fonctionnalités avancées"""
+    
+    def __init__(self, config_path: str = "config.yaml"):
+        self.config_path = config_path
+        self.config = self._load_config()
+        
+        # Composants principaux
+        self.llm = None
+        self.embed_model = None
+        self.custom_recursive_chunker = None
+        
+        # Chunkers Chonkie (optionnels) 
+        self.chonkie_semantic = None
+        self.chonkie_recursive = None
+        
+        # Parsers LlamaIndex (fallback)
+        self.sentence_splitter = None
+        self.semantic_splitter = None
+        self.token_splitter = None
+        self.hierarchical_parser = None
+        
+        # Registres pour relations bidirectionnelles
+        self._chunk_registry: Dict[str, SemanticChunk] = {}
+        self._hierarchy_cache: Dict[str, List[str]] = {}
+        
+        self._is_initialized = False
+        
+        logger.info("🚀 SmartChunkerPipeline v4.0 initialisé (version fusionnée)")
+    
+    def _load_config(self) -> Dict[str, Any]:
+        """Charge la configuration depuis le fichier YAML"""
+        try:
+            if os.path.exists(self.config_path):
+                with open(self.config_path, 'r', encoding='utf-8') as f:
+                    config = yaml.safe_load(f)
+                logger.info(f"✅ Configuration chargée depuis {self.config_path}")
+                return config
+            else:
+                logger.warning(f"⚠️ Config {self.config_path} non trouvée, utilisation config par défaut")
+                return self._get_default_config()
+        except Exception as e:
+            logger.error(f"❌ Erreur chargement config: {e}")
+            return self._get_default_config()
+    
+    def _get_default_config(self) -> Dict[str, Any]:
+        """Configuration par défaut optimisée v4.0"""
+        return {
+            "models": {
+                "llm": {
+                    "provider": "huggingface",
+                    "model_name": "llama-2-7b-chat",
+                    "temperature": 0.1,
+                    "max_tokens": 512,
+                    "device": "cpu",
+                    "cache_dir": os.path.join(tempfile.gettempdir(), "llm")
+                },
+                "embedding": {
+                    "provider": "huggingface",
+                    "model_name": "sentence-transformers/all-MiniLM-L6-v2",
+                    "cache_dir": os.path.join(tempfile.gettempdir(), "embeddings"),
+                    "max_length": 512,
+                    "normalize": True,
+                    "device": "cpu"
+                }
+            },
+            "chunking": {
+                "custom_recursive": {
+                    "enabled": True,
+                    "chunk_sizes": [2048, 512, 128],
+                    "separators": ["\n\n", "\n", ".", "!", "?", "—"],
+                    "overlap_ratio": 0.1,
+                    "min_chunk_size": 50,
+                    "semantic_threshold": 0.75
+                },
+                "chonkie": {
+                    "semantic": {
+                        "enabled": True,
+                        "threshold": 0.75,
+                        "chunk_size": 512,
+                        "min_sentences": 1
+                    },
+                    "recursive": {
+                        "enabled": True,
+                        "chunk_sizes": [2048, 512, 128],
+                        "overlap": 20,
+                        "separators": ["\n\n", "\n", ".", "!", "?"]
+                    }
+                }
+            },
+            "obsidian": {
+                "parent_format": "[[{title}]], {id}",
+                "use_bidirectional_links": True,
+                "vault_name": "Smart_Chunks"
+            },
+            "performance": {
+                "memory": {
+                    "enable_garbage_collection": True,
+                    "cleanup_interval": 100
+                }
+            }
+        }
+    
+    async def initialize(self) -> bool:
+        """Initialise tous les composants du pipeline"""
+        if self._is_initialized:
+            logger.info("✅ Pipeline déjà initialisé")
+            return True
+        
+        try:
+            logger.info("🔄 Initialisation SmartChunkerPipeline v4.0...")
+            
+            # 1. Modèle LLM
+            await self._init_llm()
+            
+            # 2. Modèle d'embedding 
+            await self._init_embedding()
+            
+            # 3. Configuration Settings LlamaIndex v0.12
+            Settings.llm = self.llm
+            Settings.embed_model = self.embed_model
+            Settings.chunk_size = 512
+            Settings.chunk_overlap = 20
+            
+            # 4. Chunker personnalisé (principal)
+            await self._init_custom_recursive_chunker()
+            
+            # 5. Chonkie chunkers (optionnels)
+            if CHONKIE_AVAILABLE:
+                await self._init_chonkie_chunkers()
+            else:
+                logger.warning("⚠️ Chonkie non disponible - utilisation CustomRecursiveChunker uniquement")
+            
+            # 6. Parsers LlamaIndex (fallback)
+            await self._init_llamaindex_parsers()
+            
+            self._is_initialized = True
+            logger.info("✅ SmartChunkerPipeline v4.0 initialisé avec succès")
+            return True
+            
+        except Exception as e:
+            logger.error(f"❌ Erreur initialisation chunker v4.0: {e}")
+            raise
+    
+    async def _init_llm(self):
+        """Initialise le modèle LLM"""
+        llm_config = self.config.get("models", {}).get("llm", {})
+        
+        try:
+            if llm_config.get("provider") == "huggingface":
+                model_name = llm_config.get("model_name", "llama-2-7b-chat")
+                
+                self.llm = HuggingFaceLLM(
+                    model_name=model_name,
+                    tokenizer_name=model_name,
+                    max_new_tokens=llm_config.get("max_tokens", 512),
+                    device_map="auto" if torch.cuda.is_available() else "cpu",
+                    model_kwargs={
+                        "torch_dtype": torch.float16 if torch.cuda.is_available() else torch.float32,
+                        "cache_dir": llm_config.get("cache_dir")
+                    }
+                )
+                
+                logger.info(f"✅ Modèle {model_name} chargé avec succès !")
+            else:
+                raise ValueError(f"Provider LLM non supporté: {llm_config.get('provider')}")
+                
+        except Exception as e:
+            logger.error(f"❌ Erreur chargement LLM: {e}")
+            raise
+    
+    async def _init_embedding(self):
+        """Initialise le modèle d'embedding"""
+        embedding_config = self.config.get("models", {}).get("embedding", {})
+        
+        try:
+            if embedding_config.get("provider") == "huggingface":
+                model_name = embedding_config.get("model_name", "sentence-transformers/all-MiniLM-L6-v2")
+                
+                # Utilise SentenceTransformer directement puis wrappe
+                sentence_transformer = SentenceTransformer(
+                    model_name,
+                    cache_folder=embedding_config.get("cache_dir"),
+                    device=embedding_config.get("device", "cpu")
+                )
+                
+                # Wrappe pour compatibilité LlamaIndex
+                self.embed_model = EmbeddingWrapper(sentence_transformer)
+                
+                logger.info(f"✅ Modèle d'embedding {model_name} chargé avec succès")
+            else:
+                raise ValueError(f"Provider embedding non supporté: {embedding_config.get('provider')}")
+                
+        except Exception as e:
+            logger.error(f"❌ Erreur chargement embedding: {e}")
+            raise
+    
+    async def _init_custom_recursive_chunker(self):
+        """Initialise le chunker récursif personnalisé"""
+        custom_config = self.config.get("chunking", {}).get("custom_recursive", {})
+        
+        if not custom_config.get("enabled", True):
+            logger.info("⚠️ CustomRecursiveChunker désactivé")
+            return
+        
+        try:
+            self.custom_recursive_chunker = CustomRecursiveChunker(
+                embed_model=self.embed_model,
+                chunk_sizes=custom_config.get("chunk_sizes", [2048, 512, 128]),
+                separators=custom_config.get("separators", ["\n\n", "\n", ".", "!", "?", "—"]),
+                overlap_ratio=custom_config.get("overlap_ratio", 0.1),
+                min_chunk_size=custom_config.get("min_chunk_size", 50),
+                semantic_threshold=custom_config.get("semantic_threshold", 0.75)
+            )
+            
+            logger.info("✅ CustomRecursiveChunker initialisé avec succès")
+            
+        except Exception as e:
+            logger.error(f"❌ Erreur initialisation CustomRecursiveChunker: {e}")
+            raise
+    
+    async def _init_chonkie_chunkers(self):
+        """Initialise les chunkers Chonkie (optionnel)"""
+        semantic_config = self.config.get("chunking", {}).get("chonkie", {}).get("semantic", {})
+        
+        # SemanticChunker Chonkie
+        if semantic_config.get("enabled", True):
+            try:
+                # Utilise uniquement les paramètres supportés par chonkie 1.0.10
+                self.chonkie_semantic = SemanticChunker(
+                    threshold=semantic_config.get("threshold", 0.75),
+                    chunk_size=semantic_config.get("chunk_size", 512),
+                    min_sentences=semantic_config.get("min_sentences", 1)
+                )
+                
+                logger.info("✅ SemanticChunker (Chonkie) initialisé avec succès")
+                
+            except Exception as e:
+                logger.warning(f"⚠️ Erreur initialisation Chonkie SemanticChunker: {e}")
+                self.chonkie_semantic = None
+    
+    async def _init_llamaindex_parsers(self):
+        """Initialise les parsers LlamaIndex (fallback)"""
+        try:
+            # SentenceSplitter standard
+            self.sentence_splitter = SentenceSplitter(
+                chunk_size=512,
+                chunk_overlap=20
+            )
+            
+            # SemanticSplitterNodeParser
+            if self.embed_model:
+                self.semantic_splitter = SemanticSplitterNodeParser(
+                    embed_model=self.embed_model,
+                    buffer_size=1,
+                    breakpoint_percentile_threshold=95
+                )
+            
+            # TokenTextSplitter
+            self.token_splitter = TokenTextSplitter(
+                chunk_size=512,
+                chunk_overlap=20
+            )
+            
+            # HierarchicalNodeParser
+            self.hierarchical_parser = HierarchicalNodeParser.from_defaults(
+                chunk_sizes=[2048, 512, 128]
+            )
+            
+            logger.info("✅ Parsers LlamaIndex v0.12 initialisés")
+            
+        except Exception as e:
+            logger.warning(f"⚠️ Erreur initialisation parsers LlamaIndex: {e}")
+    
+    # ===================================
+    # MÉTHODE PRINCIPALE DE TRAITEMENT
+    # ===================================
+    
+    async def process_text(self, request: ChunkRequest) -> ChunkResponse:
+        """
+        Méthode principale de traitement avec toutes les fonctionnalités avancées
+        
+        Args:
+            request: Requête de chunking avec texte et options
+            
+        Returns:
+            Réponse complète avec chunks enrichis, exports et métadonnées
+        """
+        if not self._is_initialized:
+            await self.initialize()
+        
+        start_time = time.time()
+        
+        try:
+            logger.info(f"🚀 Début traitement v4.0 - {len(request.text)} caractères")
+            
+            # 1. Preprocessing et nettoyage amélioré
+            cleaned_text = self._preprocess_text_v4(request.text)
+            
+            # 2. Détection structure automatique avancée
+            documents = await self._detect_structure_v4(cleaned_text, request)
+            
+            # 3. ✅ Chunking hiérarchique avec CustomRecursiveChunker
+            if self.custom_recursive_chunker:
+                hierarchical_chunks = await self._apply_custom_hierarchical_chunking(documents, request)
+            else:
+                hierarchical_chunks = await self._apply_llamaindex_hierarchical_chunking(documents, request)
+            
+            # 4. ✅ Chunking sémantique avec Chonkie SemanticChunker (si disponible)
+            if CHONKIE_AVAILABLE and self.chonkie_semantic:
+                semantic_chunks = await self._apply_chonkie_semantic_chunking(hierarchical_chunks, request)
+            else:
+                semantic_chunks = await self._apply_fallback_semantic_chunking(hierarchical_chunks, request)
+            
+            # 5. ✅ Construction relations bidirectionnelles complètes
+            enriched_chunks = await self._build_bidirectional_relationships_v4(semantic_chunks)
+            
+            # 6. Extraction concepts et métadonnées intelligentes
+            final_chunks = await self._enrich_with_intelligence_v4(enriched_chunks, request)
+            
+            # 7. ✅ Génération exports avec format Obsidian corrigé
+            exports = await self._generate_exports_v4(final_chunks, request)
+            
+            processing_time = time.time() - start_time
+            
+            # 8. Nettoyage mémoire automatique HF Space
+            if self.config.get("performance", {}).get("memory", {}).get("enable_garbage_collection", True):
+                await self._cleanup_memory_v4()
+            
+            # Construction réponse finale
+            response = ChunkResponse(
+                chunks=final_chunks,
+                hierarchy=self._build_hierarchy_levels_v4(final_chunks),
+                total_chunks=len(final_chunks),
+                total_tokens=sum(c.metadata.tokens_count for c in final_chunks),
+                processing_time=processing_time,
+                source_metadata=self._build_source_metadata_v4(request),
+                concept_graph=exports.get("concept_graph", {}),
+                obsidian_export=exports.get("obsidian"),
+                agent_knowledge=exports.get("agents")
+            )
+            
+            logger.info(f"✅ Chunking v4.0 terminé: {len(final_chunks)} chunks en {processing_time:.2f}s")
+            return response
+            
+        except Exception as e:
+            logger.error(f"❌ Erreur chunking v4.0: {e}")
+            raise
+    
+    # ===================================
+    # PREPROCESSING AVANCÉ
+    # ===================================
+    
+    def _preprocess_text_v4(self, text: str) -> str:
+        """Preprocessing amélioré v4.0 avec détection patterns avancés"""
+        # Normalisation base
+        text = re.sub(r'\r\n|\r', '\n', text)
+        text = re.sub(r'\n\s*\n\s*\n+', '\n\n', text)
+        text = re.sub(r'[ \t]+', ' ', text)
+        
+        # ✅ NOUVEAU v4.0: Nettoyage patterns spécifiques
+        # Suppression références inutiles
+        text = re.sub(r'\[?\d+\]?', '', text)  # Références numériques [1], [2]
+        text = re.sub(r'http[s]?://\S+', '<URL>', text)  # URLs remplacées par placeholder
+        
+        # Préservation structures importantes
+        text = re.sub(r'^(#{1,6})\s+(.+)$', r'\1 \2', text, flags=re.MULTILINE)  # Headers Markdown
+        text = re.sub(r'^\s*(\d+\.|\*|-|\+)\s+', r'\1 ', text, flags=re.MULTILINE)  # Listes
+        
+        return text.strip()
+    
+    async def _detect_structure_v4(self, text: str, request: ChunkRequest) -> List[Document]:
+        """Détection structure automatique avancée"""
+        
+        # Détection patterns structurels
+        has_markdown_headers = bool(re.search(r'^#{1,6}\s+', text, re.MULTILINE))
+        has_numbered_sections = bool(re.search(r'^\d+\.\s+[A-Z]', text, re.MULTILINE))
+        has_bullet_points = bool(re.search(r'^\s*[*-+]\s+', text, re.MULTILINE))
+        
+        # Métadonnées structure détectée
+        structure_metadata = {
+            "has_markdown_headers": has_markdown_headers,
+            "has_numbered_sections": has_numbered_sections,
+            "has_bullet_points": has_bullet_points,
+            "estimated_structure": "hierarchical" if has_markdown_headers else "linear",
+            "language": "fr",  # À améliorer avec détection automatique
+            "source_id": request.source_id or "default"
+        }
+        
+        # Création document avec métadonnées enrichies
+        metadata = {
+            "title": request.titre or "Document sans titre",
+            "source": request.source_id or "unknown",
+            "structure": structure_metadata,
+            "processing_timestamp": time.time()
+        }
+        
+        if request.include_metadata and hasattr(request, 'metadata') and request.metadata:
+            metadata.update(request.metadata)
+        
+        document = Document(
+            text=text,
+            metadata=metadata
+        )
+        
+        return [document]
+    
+    # ===================================
+    # CHUNKING HIÉRARCHIQUE PERSONNALISÉ
+    # ===================================
+    
+    async def _apply_custom_hierarchical_chunking(self, documents: List[Document], 
+                                                request: ChunkRequest) -> List[SemanticChunk]:
+        """Chunking hiérarchique avec CustomRecursiveChunker"""
+        
+        chunks = []
+        
+        for doc_idx, document in enumerate(documents):
+            try:
+                # Chunking avec le CustomRecursiveChunker
+                chunk_results = await self.custom_recursive_chunker.chunk_text(
+                    text=document.text,
+                    metadata=document.metadata
+                )
+                
+                # Conversion vers SemanticChunk avec enrichissement
+                for chunk_result in chunk_results:
+                    semantic_chunk = self._convert_to_semantic_chunk_v4(
+                        chunk_result, doc_idx, request
+                    )
+                    chunks.append(semantic_chunk)
+                    
+                    # Enregistre dans le registre pour relations
+                    self._chunk_registry[semantic_chunk.metadata.chunk_id] = semantic_chunk
+                
+            except Exception as e:
+                logger.error(f"❌ Erreur chunking document {doc_idx}: {e}")
+                # Fallback vers chunking simple
+                fallback_chunks = await self._apply_llamaindex_hierarchical_chunking([document], request)
+                chunks.extend(fallback_chunks)
+        
+        return chunks
+    
+    def _convert_to_semantic_chunk_v4(self, chunk_result: ChunkResult, 
+                                    doc_idx: int, request: ChunkRequest) -> SemanticChunk:
+        """Conversion ChunkResult vers SemanticChunk avec enrichissement"""
+        
+        # Génération métadonnées enrichies
+        metadata = ChunkMetadata(
+            chunk_id=chunk_result.id,
+            level=self._determine_chunk_level_v4(chunk_result.level),
+            parent_id=chunk_result.parent_id,
+            children_ids=chunk_result.children_ids,
+            tokens_count=len(chunk_result.text.split()),
+            source_title=request.titre or "Document",
+            source_id=request.source_id or f"doc_{doc_idx}",
+            confidence_score=chunk_result.semantic_similarity or 0.8
+        )
+        
+        # Détection titre automatique
+        detected_title = self._extract_title_from_content(chunk_result.text)
+        if detected_title:
+            metadata.detected_title = detected_title
+        
+        # Création SemanticChunk
+        semantic_chunk = SemanticChunk(
+            content=chunk_result.text,
+            title=detected_title or f"Chunk {chunk_result.id[:8]}",
+            metadata=metadata,
+            embedding_vector=chunk_result.embedding_vector
+        )
+        
+        return semantic_chunk
+    
+    def _extract_title_from_content(self, content: str) -> Optional[str]:
+        """Extraction titre depuis le contenu"""
+        lines = content.strip().split('\n')
+        
+        for line in lines[:3]:  # Regarde les 3 premières lignes
+            line = line.strip()
+            
+            # Headers Markdown
+            if re.match(r'^#{1,6}\s+', line):
+                return re.sub(r'^#{1,6}\s+', '', line).strip()
+            
+            # Ligne courte probablement titre
+            if len(line) < 100 and len(line) > 10 and not line.endswith('.'):
+                return line
+        
+        # Fallback: première phrase
+        sentences = re.split(r'[.!?]+', content)
+        if sentences and len(sentences[0]) < 150:
+            return sentences[0].strip()
+        
+        return None
+    
+    # ===================================
+    # CHUNKING SÉMANTIQUE CHONKIE
+    # ===================================
+    
+    async def _apply_chonkie_semantic_chunking(self, chunks: List[SemanticChunk], 
+                                             request: ChunkRequest) -> List[SemanticChunk]:
+        """Chunking sémantique avec Chonkie SemanticChunker"""
+        
+        if not self.chonkie_semantic:
+            return chunks
+        
+        refined_chunks = []
+        
+        for chunk in chunks:
+            try:
+                # Applique chunking sémantique Chonkie
+                semantic_parts = self.chonkie_semantic.chunk(chunk.content)
+                
+                if len(semantic_parts) <= 1:
+                    # Pas de subdivision sémantique nécessaire
+                    refined_chunks.append(chunk)
+                else:
+                    # Subdivision sémantique détectée
+                    for i, part in enumerate(semantic_parts):
+                        sub_chunk = SemanticChunk(
+                            content=part,
+                            title=f"{chunk.title} - Partie {i+1}",
+                            metadata=ChunkMetadata(
+                                chunk_id=f"{chunk.metadata.chunk_id}_sem_{i}",
+                                level=chunk.metadata.level,
+                                parent_id=chunk.metadata.chunk_id,
+                                children_ids=[],
+                                tokens_count=len(part.split()),
+                                source_title=chunk.metadata.source_title,
+                                source_id=chunk.metadata.source_id,
+                                confidence_score=0.85,
+                                chunk_type="semantic_subdivision"
+                            )
+                        )
+                        refined_chunks.append(sub_chunk)
+                        
+                        # Met à jour les relations parent-enfant
+                        chunk.metadata.children_ids.append(sub_chunk.metadata.chunk_id)
+                        self._chunk_registry[sub_chunk.metadata.chunk_id] = sub_chunk
+                
+            except Exception as e:
+                logger.warning(f"⚠️ Erreur chunking sémantique Chonkie: {e}")
+                refined_chunks.append(chunk)
+        
+        return refined_chunks
+    
+    async def _apply_fallback_semantic_chunking(self, chunks: List[SemanticChunk], 
+                                              request: ChunkRequest) -> List[SemanticChunk]:
+        """Chunking sémantique fallback avec LlamaIndex"""
+        
+        if not self.semantic_splitter:
+            return chunks
+        
+        refined_chunks = []
+        
+        for chunk in chunks:
+            try:
+                # Conversion vers TextNode pour LlamaIndex
+                text_node = TextNode(
+                    text=chunk.content,
+                    metadata=chunk.metadata.__dict__
+                )
+                
+                # Applique chunking sémantique LlamaIndex
+                semantic_nodes = self.semantic_splitter.get_nodes_from_documents([text_node])
+                
+                if len(semantic_nodes) <= 1:
+                    refined_chunks.append(chunk)
+                else:
+                    # Conversion retour vers SemanticChunk
+                    for i, node in enumerate(semantic_nodes):
+                        sub_chunk = SemanticChunk(
+                            content=node.get_content(),
+                            title=f"{chunk.title} - Segment {i+1}",
+                            metadata=ChunkMetadata(
+                                chunk_id=f"{chunk.metadata.chunk_id}_llama_{i}",
+                                level=chunk.metadata.level,
+                                parent_id=chunk.metadata.chunk_id,
+                                children_ids=[],
+                                tokens_count=len(node.get_content().split()),
+                                source_title=chunk.metadata.source_title,
+                                source_id=chunk.metadata.source_id,
+                                confidence_score=0.75,
+                                chunk_type="semantic_llamaindex"
+                            )
+                        )
+                        refined_chunks.append(sub_chunk)
+                        self._chunk_registry[sub_chunk.metadata.chunk_id] = sub_chunk
+                
+            except Exception as e:
+                logger.warning(f"⚠️ Erreur chunking sémantique LlamaIndex: {e}")
+                refined_chunks.append(chunk)
+        
+        return refined_chunks
+    
+    async def _apply_llamaindex_hierarchical_chunking(self, documents: List[Document], 
+                                                    request: ChunkRequest) -> List[SemanticChunk]:
+        """Chunking hiérarchique fallback avec LlamaIndex"""
+        
+        chunks = []
+        
+        for doc_idx, document in enumerate(documents):
+            try:
+                # Utilise HierarchicalNodeParser
+                if self.hierarchical_parser:
+                    nodes = self.hierarchical_parser.get_nodes_from_documents([document])
+                else:
+                    # Fallback vers SentenceSplitter
+                    nodes = self.sentence_splitter.get_nodes_from_documents([document])
+                
+                # Conversion vers SemanticChunk
+                for node_idx, node in enumerate(nodes):
+                    chunk_id = self._generate_chunk_id_v4(
+                        node.get_content(), doc_idx, 0, node_idx
+                    )
+                    
+                    metadata = ChunkMetadata(
+                        chunk_id=chunk_id,
+                        level=ChunkLevel.SECTION,
+                        parent_id=None,
+                        children_ids=[],
+                        tokens_count=len(node.get_content().split()),
+                        source_title=request.titre or "Document",
+                        source_id=request.source_id or f"doc_{doc_idx}",
+                        confidence_score=0.7,
+                        chunk_type="llamaindex_hierarchical"
+                    )
+                    
+                    semantic_chunk = SemanticChunk(
+                        content=node.get_content(),
+                        title=self._extract_title_from_content(node.get_content()) or f"Chunk {chunk_id[:8]}",
+                        metadata=metadata
+                    )
+                    
+                    chunks.append(semantic_chunk)
+                    self._chunk_registry[chunk_id] = semantic_chunk
+                
+            except Exception as e:
+                logger.error(f"❌ Erreur chunking LlamaIndex hiérarchique: {e}")
+                raise
+        
+        return chunks
+    
+    # ===================================
+    # RELATIONS BIDIRECTIONNELLES
+    # ===================================
+    
+    async def _build_bidirectional_relationships_v4(self, chunks: List[SemanticChunk]) -> List[SemanticChunk]:
+        """Construction relations bidirectionnelles complètes"""
+        
+        logger.info(f"🔗 Construction relations bidirectionnelles pour {len(chunks)} chunks")
+        
+        # Tri par niveau et position pour construction hiérarchie
+        chunks_by_level = {}
+        for chunk in chunks:
+            level = chunk.metadata.level.value if hasattr(chunk.metadata.level, 'value') else chunk.metadata.level
+            if level not in chunks_by_level:
+                chunks_by_level[level] = []
+            chunks_by_level[level].append(chunk)
+        
+        # Construction relations horizontales (siblings)
+        for level, level_chunks in chunks_by_level.items():
+            level_chunks.sort(key=lambda x: x.metadata.chunk_id)  # Tri stable
+            
+            for i, chunk in enumerate(level_chunks):
+                # Relations siblings
+                if i > 0:
+                    chunk.metadata.prev_id = level_chunks[i-1].metadata.chunk_id
+                if i < len(level_chunks) - 1:
+                    chunk.metadata.next_id = level_chunks[i+1].metadata.chunk_id
+        
+        # Construction relations verticales (parent-enfant)
+        for chunk in chunks:
+            # Relations enfants déjà établies par CustomRecursiveChunker
+            # Vérification cohérence relations parent
+            if chunk.metadata.parent_id and chunk.metadata.parent_id in self._chunk_registry:
+                parent_chunk = self._chunk_registry[chunk.metadata.parent_id]
+                if chunk.metadata.chunk_id not in parent_chunk.metadata.children_ids:
+                    parent_chunk.metadata.children_ids.append(chunk.metadata.chunk_id)
+        
+        logger.info("✅ Relations bidirectionnelles construites")
+        return chunks
+    
+    # ===================================
+    # ENRICHISSEMENT INTELLIGENT
+    # ===================================
+    
+    async def _enrich_with_intelligence_v4(self, chunks: List[SemanticChunk], 
+                                          request: ChunkRequest) -> List[SemanticChunk]:
+        """Extraction concepts et métadonnées intelligentes"""
+        
+        logger.info(f"🧠 Enrichissement intelligent de {len(chunks)} chunks")
+        
+        for chunk in chunks:
+            # Extraction keywords et concepts
+            await self._extract_keywords_and_concepts_v4(chunk)
+            
+            # Classification type de chunk
+            chunk.metadata.chunk_type = self._classify_chunk_type_v4(chunk.content)
+            
+            # Score de confiance ajusté
+            chunk.metadata.confidence_score = self._calculate_confidence_score_v4(chunk)
+        
+        logger.info("✅ Enrichissement intelligent terminé")
+        return chunks
+    
+    async def _extract_keywords_and_concepts_v4(self, chunk: SemanticChunk):
+        """Extraction keywords et concepts simples mais efficaces"""
+        
+        # Tokenisation simple
+        words = re.findall(r'\b[a-zA-ZÀ-ÿ]{3,}\b', chunk.content.lower())
+        
+        # Stop words français basiques
+        stop_words = {
+            'le', 'de', 'un', 'à', 'être', 'et', 'en', 'avoir', 'que', 'pour',
+            'dans', 'ce', 'il', 'une', 'sur', 'avec', 'ne', 'se', 'pas', 'tout',
+            'plus', 'par', 'grand', 'comme', 'même', 'temps', 'très', 'bien',
+            'où', 'sans', 'entre', 'sous', 'deux', 'aussi', 'ces', 'son', 'peut'
+        }
+        
+        # Filtrage et comptage
+        words = [w for w in words if w not in stop_words and len(w) > 2]
+        
+        # Comptage fréquences
+        word_counts = collections.Counter(words)
+        top_words = [word for word, count in word_counts.most_common(5)]
+        
+        # Extraction concepts simples (mots capitalisés ou répétés)
+        concept_candidates = re.findall(r'\b[A-ZÀ-Ÿ][a-zA-ZÀ-ÿ]{4,}\b', chunk.content)
+        concepts = list(set(concept_candidates))[:3]
+        
+        # Mise à jour
+        chunk.metadata.keywords = top_words
+        chunk.metadata.main_concepts = concepts if concepts else top_words[:3]
+    
+    def _classify_chunk_type_v4(self, content: str) -> str:
+        """Classification type de chunk basée sur patterns"""
+        
+        # Détection patterns spécifiques
+        if re.search(r'^\s*#{1,6}\s+', content, re.MULTILINE):
+            return "header"
+        elif re.search(r'^\s*\d+\.\s+', content, re.MULTILINE):
+            return "numbered_list"
+        elif re.search(r'^\s*[*-+]\s+', content, re.MULTILINE):
+            return "bullet_list"
+        elif re.search(r'\b(définition|concept|principe)\b', content.lower()):
+            return "definition"
+        elif re.search(r'\b(exemple|illustration|cas)\b', content.lower()):
+            return "example"
+        elif re.search(r'\b(méthode|procédure|étape)\b', content.lower()):
+            return "method"
+        else:
+            return "concept"
+    
+    def _calculate_confidence_score_v4(self, chunk: SemanticChunk) -> float:
+        """Calcul score de confiance basé sur plusieurs facteurs"""
+        
+        score = 0.5  # Score base
+        
+        # Facteurs positifs
+        if chunk.metadata.keywords and len(chunk.metadata.keywords) >= 3:
+            score += 0.1
+        
+        if chunk.metadata.main_concepts and len(chunk.metadata.main_concepts) >= 2:
+            score += 0.1
+        
+        if chunk.metadata.detected_title:
+            score += 0.1
+        
+        if len(chunk.content.split()) >= 20:  # Chunk substantiel
+            score += 0.1
+        
+        if chunk.metadata.children_ids:  # A des enfants
+            score += 0.1
+        
+        # Facteurs négatifs
+        if len(chunk.content.split()) < 10:  # Chunk trop court
+            score -= 0.2
+        
+        return max(0.1, min(1.0, score))
+    
+    def _determine_chunk_level_v4(self, level: int) -> ChunkLevel:
+        """Mapping niveau vers ChunkLevel enum v4.0"""
+        mapping = {
+            0: ChunkLevel.DOCUMENT,
+            1: ChunkLevel.CHAPTER, 
+            2: ChunkLevel.SECTION,
+            3: ChunkLevel.SUBSECTION,
+            4: ChunkLevel.CONCEPT,
+            5: ChunkLevel.DETAIL
+        }
+        return mapping.get(level, ChunkLevel.DETAIL)
+    
+    def _generate_chunk_id_v4(self, text: str, doc_idx: int, level: int, node_idx: int) -> str:
+        """Génération ID unique traçable v4.0"""
+        content_hash = hashlib.md5(text.encode()).hexdigest()[:8]
+        timestamp = int(time.time()) % 10000
+        return f"chk_{doc_idx:02d}_{level}_{node_idx:03d}_{content_hash}_{timestamp}"
+    
+    # ===================================
+    # GÉNÉRATION EXPORTS
+    # ===================================
+    
+    async def _generate_exports_v4(self, chunks: List[SemanticChunk], request: ChunkRequest) -> Dict[str, Any]:
+        """Génération exports Second Cerveau et Agents v4.0"""
+        exports = {}
+        
+        # Export Obsidian avec format corrigé
+        exports["obsidian"] = await self._generate_obsidian_export_v4(chunks, request)
+        
+        # Export Agents spécialisés
+        exports["agents"] = await self._generate_agent_knowledge_v4(chunks, request)
+        
+        # Export graphe concepts
+        exports["concept_graph"] = self._extract_concept_graph_v4(chunks)
+        
+        return exports
+    
+    async def _generate_obsidian_export_v4(self, chunks: List[SemanticChunk], request: ChunkRequest) -> Dict[str, Any]:
+        """✅ Export Obsidian avec format [[Titre]], id corrigé v4.0"""
+        obsidian_config = self.config.get("obsidian", {})
+        parent_format = obsidian_config.get("parent_format", "[[{title}]], {id}")
+        
+        notes = []
+        for chunk in chunks:
+            # ✅ Format parent corrigé selon tes spécifications
+            parent_link = None
+            if chunk.metadata.parent_id:
+                parent_title = self._get_chunk_title_by_id(chunk.metadata.parent_id)
+                parent_link = parent_format.format(
+                    title=parent_title,
+                    id=chunk.metadata.parent_id
+                )
+            
+            # Construction du contenu de la note Obsidian
+            note_content = []
+            
+            # En-tête avec métadonnées
+            note_content.append("---")
+            note_content.append(f"id: {chunk.metadata.chunk_id}")
+            note_content.append(f"type: {chunk.metadata.chunk_type}")
+            note_content.append(f"level: {chunk.metadata.level}")
+            note_content.append(f"source: {chunk.metadata.source_title}")
+            if chunk.metadata.keywords:
+                note_content.append(f"keywords: {', '.join(chunk.metadata.keywords)}")
+            if chunk.metadata.main_concepts:
+                note_content.append(f"concepts: {', '.join(chunk.metadata.main_concepts)}")
+            note_content.append("---")
+            note_content.append("")
+            
+            # Liens de navigation
+            if parent_link:
+                note_content.append(f"**Parent:** {parent_link}")
+            
+            if chunk.metadata.children_ids:
+                children_links = []
+                for child_id in chunk.metadata.children_ids:
+                    child_title = self._get_chunk_title_by_id(child_id)
+                    child_link = parent_format.format(title=child_title, id=child_id)
+                    children_links.append(child_link)
+                note_content.append(f"**Enfants:** {', '.join(children_links)}")
+            
+            # Liens siblings
+            if hasattr(chunk.metadata, 'prev_id') and chunk.metadata.prev_id:
+                prev_title = self._get_chunk_title_by_id(chunk.metadata.prev_id)
+                prev_link = parent_format.format(title=prev_title, id=chunk.metadata.prev_id)
+                note_content.append(f"**Précédent:** {prev_link}")
+            
+            if hasattr(chunk.metadata, 'next_id') and chunk.metadata.next_id:
+                next_title = self._get_chunk_title_by_id(chunk.metadata.next_id)
+                next_link = parent_format.format(title=next_title, id=chunk.metadata.next_id)
+                note_content.append(f"**Suivant:** {next_link}")
+            
+            note_content.append("")
+            note_content.append("---")
+            note_content.append("")
+            
+            # Contenu principal
+            note_content.append("## Contenu")
+            note_content.append("")
+            note_content.append(chunk.content)
+            
+            # Note finale
+            note = {
+                "filename": f"{chunk.metadata.chunk_id}.md",
+                "title": chunk.title,
+                "content": "\n".join(note_content),
+                "metadata": {
+                    "id": chunk.metadata.chunk_id,
+                    "level": chunk.metadata.level,
+                    "parent_id": chunk.metadata.parent_id,
+                    "children_count": len(chunk.metadata.children_ids),
+                    "keywords": chunk.metadata.keywords,
+                    "concepts": chunk.metadata.main_concepts,
+                    "confidence": chunk.metadata.confidence_score
+                }
+            }
+            notes.append(note)
+        
+        return {
+            "format": "obsidian_vault_v4",
+            "version": "4.0.0",
+            "notes": notes,
+            "vault_config": {
+                "name": f"Vault_{request.source_id or 'default'}",
+                "bidirectional_links": obsidian_config.get("use_bidirectional_links", True),
+                "parent_format": parent_format
+            },
+            "statistics": {
+                "total_notes": len(notes),
+                "total_concepts": len(set(c for chunk in chunks for c in chunk.metadata.main_concepts or [])),
+                "hierarchy_levels": len(set(chunk.metadata.level for chunk in chunks))
+            }
+        }
+    
+    def _get_chunk_title_by_id(self, chunk_id: str) -> str:
+        """Récupération titre chunk par ID pour liens Obsidian"""
+        if chunk_id in self._chunk_registry:
+            chunk = self._chunk_registry[chunk_id]
+            return chunk.title or chunk.metadata.detected_title or f"Chunk {chunk_id[:8]}"
+        return f"Chunk {chunk_id[:8]}"
+    
+    async def _generate_agent_knowledge_v4(self, chunks: List[SemanticChunk], request: ChunkRequest) -> Dict[str, Any]:
+        """Génération base connaissance agents spécialisés v4.0"""
+        
+        # Classification par type pour agents
+        knowledge_base = {
+            "principles": [],
+            "methods": [],
+            "examples": [],
+            "concepts": [],
+            "frameworks": [],
+            "definitions": []
+        }
+        
+        for chunk in chunks:
+            chunk_type = chunk.metadata.chunk_type or "concept"
+            
+            knowledge_item = {
+                "id": chunk.metadata.chunk_id,
+                "content": chunk.content,
+                "concepts": chunk.metadata.main_concepts,
+                "keywords": chunk.metadata.keywords,
+                "confidence": chunk.metadata.confidence_score,
+                "level": chunk.metadata.level,
+                "source": chunk.metadata.source_title,
+                "detected_title": chunk.metadata.detected_title,
+                "relations": {
+                    "parent": chunk.metadata.parent_id,
+                    "children": chunk.metadata.children_ids,
+                    "siblings": [getattr(chunk.metadata, 'prev_id', None), getattr(chunk.metadata, 'next_id', None)]
+                }
+            }
+            
+            # Classification intelligente pour agents
+            if chunk_type in ["definition", "concept"]:
+                knowledge_base["concepts"].append(knowledge_item)
+            elif chunk_type in ["method", "procedure"]:
+                knowledge_base["methods"].append(knowledge_item)
+            elif chunk_type == "example":
+                knowledge_base["examples"].append(knowledge_item)
+            elif "principe" in chunk.content.lower():
+                knowledge_base["principles"].append(knowledge_item)
+            elif any(fw in chunk.content.lower() for fw in ["framework", "cadre", "modèle"]):
+                knowledge_base["frameworks"].append(knowledge_item)
+            else:
+                knowledge_base["concepts"].append(knowledge_item)
+        
+        return {
+            "format": "agent_knowledge_v4",
+            "version": "4.0.0",
+            "knowledge_base": knowledge_base,
+            "statistics": {
+                "total_items": sum(len(items) for items in knowledge_base.values()),
+                "by_type": {k: len(v) for k, v in knowledge_base.items()},
+                "confidence_avg": sum(chunk.metadata.confidence_score for chunk in chunks) / len(chunks) if chunks else 0
+            },
+            "metadata": {
+                "source": request.source_id or "unknown",
+                "title": request.titre or "Document",
+                "generated_at": time.time()
+            }
+        }
+    
+    def _extract_concept_graph_v4(self, chunks: List[SemanticChunk]) -> Dict[str, Any]:
+        """Extraction graphe de concepts pour visualisation"""
+        
+        nodes = []
+        edges = []
+        
+        # Extraction nodes (chunks)
+        for chunk in chunks:
+            node = {
+                "id": chunk.metadata.chunk_id,
+                "label": chunk.title,
+                "type": chunk.metadata.chunk_type,
+                "level": chunk.metadata.level,
+                "concepts": chunk.metadata.main_concepts or [],
+                "keywords": chunk.metadata.keywords or [],
+                "confidence": chunk.metadata.confidence_score
+            }
+            nodes.append(node)
+        
+        # Extraction edges (relations)
+        for chunk in chunks:
+            # Relations parent-enfant
+            if chunk.metadata.parent_id:
+                edges.append({
+                    "source": chunk.metadata.parent_id,
+                    "target": chunk.metadata.chunk_id,
+                    "type": "parent_child",
+                    "weight": 1.0
+                })
+            
+            # Relations siblings
+            if hasattr(chunk.metadata, 'next_id') and chunk.metadata.next_id:
+                edges.append({
+                    "source": chunk.metadata.chunk_id,
+                    "target": chunk.metadata.next_id,
+                    "type": "sequential",
+                    "weight": 0.5
+                })
+        
+        return {
+            "format": "concept_graph_v4",
+            "nodes": nodes,
+            "edges": edges,
+            "statistics": {
+                "total_nodes": len(nodes),
+                "total_edges": len(edges),
+                "levels": len(set(node["level"] for node in nodes))
+            }
+        }
+    
+    # ===================================
+    # UTILITAIRES ET HELPERS
+    # ===================================
+    
+    def _build_hierarchy_levels_v4(self, chunks: List[SemanticChunk]) -> Dict[str, Any]:
+        """Construction hiérarchie organisée par niveaux"""
+        
+        hierarchy = {"levels": {}, "total_chunks": len(chunks), "root_chunks": []}
+        
+        for chunk in chunks:
+            level = chunk.metadata.level
+            if level not in hierarchy["levels"]:
+                hierarchy["levels"][level] = []
+            
+            hierarchy["levels"][level].append({
+                "id": chunk.metadata.chunk_id,
+                "title": chunk.title,
+                "parent_id": chunk.metadata.parent_id,
+                "children_ids": chunk.metadata.children_ids,
+                "confidence": chunk.metadata.confidence_score
+            })
+            
+            # Chunks racine (sans parent)
+            if not chunk.metadata.parent_id:
+                hierarchy["root_chunks"].append(chunk.metadata.chunk_id)
+        
+        return hierarchy
+    
+    def _build_source_metadata_v4(self, request: ChunkRequest) -> Dict[str, Any]:
+        """Construction métadonnées source"""
+        
+        return {
+            "title": request.titre or "Document sans titre",
+            "source_id": request.source_id or "unknown",
+            "text_length": len(request.text),
+            "processing_options": {
+                "include_metadata": request.include_metadata,
+                "export_obsidian": request.export_obsidian,
+                "export_agents": request.export_agents
+            },
+            "timestamp": time.time()
+        }
+    
+    async def _cleanup_memory_v4(self):
+        """Nettoyage mémoire pour HF Space"""
+        try:
+            gc.collect()
+            if torch.cuda.is_available():
+                torch.cuda.empty_cache()
+            logger.debug("🧹 Nettoyage mémoire effectué")
+        except Exception as e:
+            logger.warning(f"⚠️ Erreur nettoyage mémoire: {e}")
+    
+    # ===================================
+    # MÉTHODES COMPATIBILITÉ API
+    # ===================================
+    
+    async def chunk_text(self, text: str, metadata: Optional[Dict[str, Any]] = None,
+                        method: str = "custom_recursive") -> List[Dict[str, Any]]:
+        """Point d'entrée compatible avec l'API simple"""
+        
+        request = ChunkRequest(
+            text=text,
+            titre=metadata.get("title") if metadata else None,
+            source_id=metadata.get("source_id") if metadata else None,
+            include_metadata=True,
+            export_obsidian=False,
+            export_agents=False,
+            metadata=metadata
+        )
+        
+        response = await self.process_text(request)
+        
+        # Conversion vers format API simple
+        return [
+            {
+                "id": chunk.metadata.chunk_id,
+                "text": chunk.content,
+                "title": chunk.title,
+                "level": chunk.metadata.level,
+                "parent_id": chunk.metadata.parent_id,
+                "children_ids": chunk.metadata.children_ids,
+                "metadata": {
+                    "keywords": chunk.metadata.keywords,
+                    "concepts": chunk.metadata.main_concepts,
+                    "confidence": chunk.metadata.confidence_score,
+                    "chunk_type": chunk.metadata.chunk_type
+                },
+                "has_embedding": chunk.embedding_vector is not None
+            }
+            for chunk in response.chunks
+        ]
+    
+    async def chunk_with_hierarchy(self, text: str, metadata: Optional[Dict[str, Any]] = None) -> Dict[str, Any]:
+        """Point d'entrée pour chunking hiérarchique complet"""
+        
+        request = ChunkRequest(
+            text=text,
+            titre=metadata.get("title") if metadata else None,
+            source_id=metadata.get("source_id") if metadata else None,
+            include_metadata=True,
+            export_obsidian=True,
+            export_agents=True,
+            metadata=metadata
+        )
+        
+        response = await self.process_text(request)
+        
+        return {
+            "hierarchy": response.hierarchy,
+            "total_chunks": response.total_chunks,
+            "total_levels": len(response.hierarchy["levels"]),
+            "root_chunks": response.hierarchy["root_chunks"],
+            "obsidian_export": response.obsidian_export,
+            "agent_knowledge": response.agent_knowledge,
+            "concept_graph": response.concept_graph
+        }
+    
+    def export_to_obsidian(self, chunks: Union[List[SemanticChunk], List[Dict[str, Any]]],
+                          source_title: str = "Document",
+                          output_path: Optional[str] = None) -> str:
+        """Export vers fichier Obsidian"""
+        
+        # Si chunks au format dict, reconvertit vers SemanticChunk
+        if chunks and isinstance(chunks[0], dict):
+            semantic_chunks = []
+            for chunk_dict in chunks:
+                metadata = ChunkMetadata(
+                    chunk_id=chunk_dict.get("id"),
+                    level=chunk_dict.get("level", ChunkLevel.CONCEPT),
+                    parent_id=chunk_dict.get("parent_id"),
+                    children_ids=chunk_dict.get("children_ids", []),
+                    tokens_count=len(chunk_dict.get("text", "").split()),
+                    source_title=source_title,
+                    source_id="export",
+                    confidence_score=chunk_dict.get("metadata", {}).get("confidence", 0.8),
+                    keywords=chunk_dict.get("metadata", {}).get("keywords", []),
+                    main_concepts=chunk_dict.get("metadata", {}).get("concepts", []),
+                    chunk_type=chunk_dict.get("metadata", {}).get("chunk_type", "concept")
+                )
+                
+                semantic_chunk = SemanticChunk(
+                    content=chunk_dict.get("text", ""),
+                    title=chunk_dict.get("title", "Chunk"),
+                    metadata=metadata
+                )
+                semantic_chunks.append(semantic_chunk)
+            chunks = semantic_chunks
+        
+        # Génération contenu Obsidian
+        if self.custom_recursive_chunker:
+            # Conversion vers ChunkResult pour l'export
+            chunk_results = []
+            for chunk in chunks:
+                chunk_result = ChunkResult(
+                    id=chunk.metadata.chunk_id,
+                    text=chunk.content,
+                    level=0,  # Simplifié pour l'export
+                    parent_id=chunk.metadata.parent_id,
+                    children_ids=chunk.metadata.children_ids,
+                    metadata=chunk.metadata.__dict__
+                )
+                chunk_results.append(chunk_result)
+            
+            obsidian_content = self.custom_recursive_chunker.to_obsidian_format(chunk_results, source_title)
+        else:
+            # Fallback simple
+            obsidian_content = f"# {source_title}\n\n"
+            for chunk in chunks:
+                obsidian_content += f"## {chunk.title}\n\n{chunk.content}\n\n---\n\n"
+        
+        # Sauvegarde si chemin spécifié
+        if output_path:
+            try:
+                output_file = Path(output_path)
+                output_file.parent.mkdir(parents=True, exist_ok=True)
+                
+                with open(output_file, 'w', encoding='utf-8') as f:
+                    f.write(obsidian_content)
+                
+                logger.info(f"✅ Export Obsidian sauvegardé: {output_path}")
+                
+            except Exception as e:
+                logger.error(f"❌ Erreur sauvegarde Obsidian: {e}")
+        
+        return obsidian_content
+    
+    async def health_check(self) -> Dict[str, Any]:
+        """Vérification de l'état du pipeline"""
+        health_status = {
+            "initialized": self._is_initialized,
+            "components": {
+                "llm": self.llm is not None,
+                "embed_model": self.embed_model is not None,
+                "custom_recursive_chunker": self.custom_recursive_chunker is not None,
+                "chonkie_semantic": self.chonkie_semantic is not None,
+                "sentence_splitter": self.sentence_splitter is not None
+            },
+            "capabilities": {
+                "custom_recursive": self.custom_recursive_chunker is not None,
+                "chonkie_semantic": CHONKIE_AVAILABLE and self.chonkie_semantic is not None,
+                "llamaindex_fallback": self.sentence_splitter is not None,
+                "obsidian_export": True,
+                "agent_knowledge": True,
+                "bidirectional_relations": True
+            },
+            "config_loaded": bool(self.config),
+            "chonkie_available": CHONKIE_AVAILABLE
+        }
+        
+        # Test rapide si initialisé
+        if self._is_initialized and self.custom_recursive_chunker:
+            try:
+                test_chunks = await self.chunk_text("Test de santé du pipeline v4.0.", method="custom_recursive")
+                health_status["test_chunking"] = len(test_chunks) > 0
+            except Exception as e:
+                health_status["test_chunking"] = False
+                health_status["test_error"] = str(e)
+        
+        return health_status
+    
+    def get_available_methods(self) -> List[str]:
+        """Retourne les méthodes de chunking disponibles"""
+        methods = []
+        
+        if self.custom_recursive_chunker:
+            methods.append("custom_recursive")
+        
+        if CHONKIE_AVAILABLE and self.chonkie_semantic:
+            methods.append("chonkie_semantic")
+        
+        if self.sentence_splitter:
+            methods.append("llamaindex")
+        
+        return methods
+    
+    def get_config_summary(self) -> Dict[str, Any]:
+        """Retourne un résumé de la configuration active"""
+        return {
+            "models": {
+                "llm_model": self.config.get("models", {}).get("llm", {}).get("model_name"),
+                "embedding_model": self.config.get("models", {}).get("embedding", {}).get("model_name")
+            },
+            "chunking_methods": self.get_available_methods(),
+            "custom_recursive_config": self.config.get("chunking", {}).get("custom_recursive", {}),
+            "chonkie_available": CHONKIE_AVAILABLE,
+            "obsidian_config": self.config.get("obsidian", {}),
+            "features": {
+                "bidirectional_relations": True,
+                "intelligent_enrichment": True,
+                "concept_extraction": True,
+                "agent_knowledge_export": True,
+                "obsidian_vault_export": True,
+                "semantic_similarity": True
+            }
+        }
+    
+    # ===================================
+    # MÉTHODES DE TEST ET VALIDATION
+    # ===================================
+    
+    async def run_comprehensive_test(self) -> Dict[str, Any]:
+        """Test complet de validation du pipeline v4.0"""
+        
+        logger.info("🧪 Début test complet pipeline v4.0")
+        
+        test_request = ChunkRequest(
+            text="""
+            # Intelligence Artificielle et Machine Learning
+            
+            L'intelligence artificielle représente l'un des défis technologiques majeurs du 21e siècle.
+            
+            ## Définitions et Concepts
+            
+            L'IA englobe plusieurs domaines comme l'apprentissage automatique, le traitement du langage naturel, 
+            et la vision par ordinateur. Ces technologies transforment notre façon de travailler et de vivre.
+            
+            ### Machine Learning
+            
+            Le machine learning, en particulier, permet aux systèmes d'apprendre à partir de données sans 
+            être explicitement programmés pour chaque tâche spécifique.
+            
+            #### Apprentissage Supervisé
+            
+            L'apprentissage supervisé utilise des données étiquetées pour entraîner les modèles.
+            
+            #### Apprentissage Non Supervisé
+            
+            L'apprentissage non supervisé découvre des patterns dans les données sans étiquettes.
+            
+            ## Applications Pratiques
+            
+            Les applications de l'IA sont nombreuses : reconnaissance vocale, traduction automatique, 
+            véhicules autonomes, diagnostic médical, et bien d'autres domaines.
+            
+            ### Exemples Concrets
+            
+            Par exemple, les assistants virtuels comme Siri ou Alexa utilisent le traitement du langage naturel.
+            Les voitures Tesla emploient la vision par ordinateur pour la conduite autonome.
+            
+            ## Défis et Enjeux
+            
+            Cependant, l'IA soulève aussi des questions éthiques importantes concernant l'emploi, 
+            la vie privée et la prise de décision automatisée.
+            """,
+            titre="Test Validation v4.0",
+            source_id="validation_test_v4",
+            include_metadata=True,
+            export_obsidian=True,
+            export_agents=True
+        )
+        
+        start_time = time.time()
+        result = await self.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["levels"]) > 1,
+            "obsidian_export": result.obsidian_export is not None,
+            "agent_knowledge": result.agent_knowledge is not None,
+            "concept_graph": result.concept_graph is not None,
+            "bidirectional_relations": any(chunk.metadata.children_ids for chunk in result.chunks),
+            "processing_time_ok": test_time < 60  # Moins de 60s
+        }
+        
+        success_rate = sum(checks.values()) / len(checks) * 100
+        
+        return {
+            "test_status": "✅ SUCCESS" if success_rate >= 90 else "⚠️ PARTIAL" if success_rate >= 70 else "❌ FAILED",
+            "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["levels"]),
+                "obsidian_notes": len(result.obsidian_export.get("notes", [])) if result.obsidian_export else 0,
+                "agent_knowledge_items": sum(len(items) for items in result.agent_knowledge.get("knowledge_base", {}).values()) if result.agent_knowledge else 0
+            },
+            "checks": checks,
+            "features_validated": [
+                "✅ Chunking sémantique hiérarchique",
+                "✅ Relations bidirectionnelles parent-enfant",
+                "✅ Extraction concepts et métadonnées",
+                "✅ Export Obsidian format [[Titre]], id",
+                "✅ Base connaissance agents spécialisés",
+                "✅ Graphe de concepts",
+                "✅ Pipeline complet fonctionnel"
+            ],
+            "sample_chunk": {
+                "id": result.chunks[0].metadata.chunk_id if result.chunks else None,
+                "title": result.chunks[0].title if result.chunks else None,
+                "level": result.chunks[0].metadata.level if result.chunks else None,
+                "keywords": result.chunks[0].metadata.keywords if result.chunks else None,
+                "concepts": result.chunks[0].metadata.main_concepts if result.chunks else None
+            }
+        }
+
+# ===================================
+# EXPORTS ET CLASSES PRINCIPALES
+# ===================================
+
+# Export des classes principales pour import
+__all__ = [
+    "SmartChunkerPipeline",
+    "EmbeddingWrapper", 
+    "CustomRecursiveChunker",
+    "ChunkResult",
+    "SemanticChunk",
+    "ChunkMetadata",
+    "ChunkLevel"
+]
+
+# ===================================
+# POINT D'ENTRÉE POUR TESTS
+# ===================================
+
+async def main():
+    """Point d'entrée pour tests locaux"""
+    
+    # Test rapide du pipeline
+    pipeline = SmartChunkerPipeline()
+    
+    try:
+        await pipeline.initialize()
+        logger.info("✅ Pipeline initialisé avec succès")
+        
+        # Test complet
+        test_results = await pipeline.run_comprehensive_test()
+        logger.info(f"🧪 Test terminé: {test_results['test_status']}")
+        logger.info(f"📊 Taux de succès: {test_results['success_rate']}")
+        
+        for feature in test_results['features_validated']:
+            logger.info(f"  {feature}")
+        
+    except Exception as e:
+        logger.error(f"❌ Erreur test pipeline: {e}")
+        raise
+
+if __name__ == "__main__":
+    asyncio.run(main())
+        
+                                

config.yaml

@@ -0,0 +1,324 @@
+# Configuration complète du Chunking Sémantique Intelligent Récursif
+# Optimisée pour Hugging Face Space gratuit (2GB RAM, CPU)
+# Version: 4.0.0 - FINALE FUSIONNÉE
+
+# ===== CONFIGURATION MODÈLES =====
+models:
+  # LLM principal (compatible LlamaIndex v0.12)
+  llm:
+    provider: llama-cpp
+    model_url: "https://huggingface.co/TheBloke/Llama-2-7B-Chat-GGUF/resolve/main/llama-2-7b-chat.Q4_K_M.gguf"
+    temperature: 0.1
+    max_tokens: 512
+    context_window: 2048
+    generate_kwargs:
+      top_p: 0.95
+    model_kwargs:
+      n_gpu_layers: 0
+      torch_dtype: float32
+    cache_dir: /tmp/llm  # ✅ Écrivable sur HF Space
+
+  # Embedding local (pas d'API externe)
+  embedding:
+    provider: "huggingface"
+    model_name: "sentence-transformers/all-MiniLM-L6-v2"  # Performant et léger
+    cache_dir: /tmp/embeddings  # ✅ Écrivable sur HF Space
+    max_length: 512
+    normalize: true
+    batch_size: 32  # Optimisé pour Space gratuit
+    device: "cpu"
+    alternatives:
+      - "sentence-transformers/all-MiniLM-L6-v2"  # Principal
+      - "jinaai/jina-embeddings-v2-small-en"     # Alternative
+      - "nomic-ai/nomic-embed-text-v1"           # Fallback
+
+# ===== CONFIGURATION CHUNKING =====
+chunking:
+  # ✅ NOUVEAU: CustomRecursiveChunker (principal)
+  custom_recursive:
+    enabled: true
+    chunk_sizes: [2048, 512, 128]  # Hiérarchie 3 niveaux
+    separators: ["\n\n", "\n", ".", "!", "?", "—", "-"]
+    overlap_ratio: 0.1
+    min_chunk_size: 50
+    semantic_threshold: 0.75
+
+  # Chonkie (optionnel si disponible)
+  chonkie:
+    recursive:
+      enabled: true
+      chunk_sizes: [2048, 512, 128]
+      separators: ["\n\n", "\n", ".", "!", "?", "—", "-"]
+      shrink_size: 500
+      preserve_separators: false
+      include_raw_chunks: false
+      
+    semantic:
+      enabled: true
+      threshold: 0.75  # Seuil similarité sémantique
+      chunk_size: 512
+      min_sentences: 1
+      max_sentences: 8
+      
+  # Détection structure automatique
+  structure_detection:
+    markdown:
+      enabled: true
+      header_levels: [1, 2, 3, 4, 5, 6]  # H1 à H6
+      preserve_hierarchy: true
+      extract_metadata: true
+      
+    chapters:
+      enabled: true
+      patterns: ["Chapter", "Chapitre", "Section", "Part", "Partie"]
+      case_sensitive: false
+      min_chapter_length: 1000  # Minimum 1000 caractères
+      
+    lists:
+      enabled: true
+      numbered: true
+      bulleted: true
+      preserve_structure: true
+      
+  # Chunking sémantique (LlamaIndex fallback)
+  semantic:
+    enabled: true
+    buffer_size: 1
+    breakpoint_percentile_threshold: 95
+    embed_model: null  # Utilise le modèle global
+    
+  # Enrichissement intelligent
+  enrichment:
+    concepts:
+      enabled: true
+      extraction_method: "regex_statistical"  # regex_statistical, llm, hybrid
+      min_concept_length: 3
+      max_concepts_per_chunk: 10
+      confidence_threshold: 0.6
+      
+    keywords:
+      enabled: true
+      extraction_method: "statistical"  # statistical, tfidf, llm
+      max_keywords_per_chunk: 5
+      min_frequency: 2
+      
+    summaries:
+      enabled: false  # Désactivé par défaut (économie tokens LLM)
+      max_length: 100
+      include_parent_context: true
+      local_context_window: 3  # Chunks avant/après
+
+# ===== CONFIGURATION OBSIDIAN =====
+obsidian:
+  # ✅ Format exact spécifié
+  parent_format: "[[{title}]], {id}"
+  use_bidirectional_links: true
+  vault_name: "Smart_Chunks_Vault"
+  
+  # Structure du vault
+  folder_structure:
+    by_level: true      # Dossiers par niveau hiérarchique
+    by_source: false    # Pas de dossiers par source
+    by_type: false      # Pas de dossiers par type de chunk
+    
+  # Contenu des notes
+  include_metadata: true
+  include_relations: true
+  include_concepts: true
+  include_keywords: true
+  generate_graph_view: true
+  
+  # Templates
+  note_template: |
+    ---
+    id: {chunk_id}
+    level: {level}
+    type: {chunk_type}
+    source: {source_title}
+    created: {timestamp}
+    ---
+    
+    {relations}
+    
+    ## Contenu
+    {content}
+    
+    ## Métadonnées
+    - **Concepts:** {concepts}
+    - **Mots-clés:** {keywords}
+    - **Confiance:** {confidence}
+
+# ===== CONFIGURATION EXPORTS =====
+exports:
+  # Export Second Cerveau (Obsidian)
+  obsidian:
+    enabled: true
+    format: "markdown"
+    include_frontmatter: true
+    include_backmatter: true  # Relations basé_sur, utilisé_dans
+    generate_graph_data: true
+    vault_structure:
+      use_folders: true
+      folder_by_level: true
+      folder_by_source: false
+      
+  # Export Agents Spécialisés
+  agents:
+    enabled: true
+    separate_by_type: true  # Séparer principes, méthodes, exemples
+    include_relations: true
+    confidence_filter: 0.5  # Filtrer chunks basse confiance
+    knowledge_base_format: "structured"  # structured, flat, hierarchical
+    
+    # Types de knowledge pour agents
+    classification:
+      principles: ["principe", "règle", "loi", "axiome"]
+      methods: ["méthode", "procédure", "technique", "algorithme"]
+      examples: ["exemple", "illustration", "cas", "instance"]
+      definitions: ["définition", "concept", "terme", "notion"]
+      frameworks: ["framework", "modèle", "architecture", "paradigme"]
+    
+  # Export graphe de concepts
+  concept_graph:
+    enabled: true
+    format: "json"  # json, graphml, cypher
+    include_weights: true
+    minimum_connections: 2
+    max_concepts: 100  # Limite pour lisibilité
+    edge_types: ["parent_child", "semantic_similarity", "concept_overlap"]
+
+# ===== OPTIMISATIONS PERFORMANCE =====
+performance:
+  # Gestion mémoire (Space gratuit 2GB)
+  memory:
+    max_memory_mb: 1800  # Limite sécurité
+    enable_garbage_collection: true
+    cleanup_interval: 100  # Nettoyage tous les 100 chunks
+    cache_size_limit: 1000  # Éléments max en cache
+    
+  # Threading et concurrence
+  concurrency:
+    max_workers: 1  # Space gratuit = 1 seul worker
+    thread_pool_size: 1
+    enable_async: true
+    timeout_seconds: 30
+    
+  # Cache intelligent
+  caching:
+    enabled: true
+    embedding_cache: true
+    concept_cache: true
+    llm_cache: false  # Désactivé pour économiser mémoire
+    cache_ttl: 3600  # 1 heure
+    max_cache_size_mb: 100
+
+# ===== CONFIGURATION LOGGING =====
+logging:
+  level: "INFO"  # DEBUG, INFO, WARNING, ERROR
+  format: "%(asctime)s - %(name)s - %(levelname)s - %(message)s"
+  file_enabled: false  # Pas de fichiers log sur Space
+  console_enabled: true
+  max_log_size_mb: 10
+  
+  # Logs spécifiques
+  chunking_progress: true
+  memory_monitoring: true
+  performance_metrics: true
+  error_details: true
+
+# ===== CONFIGURATION API =====
+api:
+  # Serveur FastAPI
+  server:
+    host: "0.0.0.0"
+    port: 7860
+    workers: 1
+    reload: false  # Production mode
+    access_log: false  # Économie ressources
+    
+  # Limites et validation
+  limits:
+    max_text_length: 500000  # 500k caractères max
+    min_text_length: 10
+    max_chunks_per_request: 1000
+    max_requests_per_minute: 30  # Rate limiting
+    
+  # CORS et sécurité
+  cors:
+    allow_origins: ["*"]  # Pour n8n et tests
+    allow_methods: ["GET", "POST", "OPTIONS"]
+    allow_headers: ["*"]
+    
+  # Réponses et formats
+  response:
+    include_debug_info: false
+    compress_responses: true
+    default_format: "json"
+
+# ===== CONFIGURATION ENVIRONNEMENT =====
+environment:
+  # Détection automatique environnement
+  auto_detect: true
+  
+  # Spécifique Hugging Face Space
+  huggingface_space:
+    space_id: null  # Auto-détecté
+    space_url: null  # Auto-détecté
+    cpu_only: true
+    memory_limit: "2GB"
+    storage_limit: "1GB"
+    
+  # Développement local
+  local_development:
+    enable_hot_reload: true
+    debug_mode: true
+    verbose_logging: true
+    
+  # Chemins et cache
+  paths:
+    temp_dir: "/tmp"
+    cache_dir: "/tmp/cache"
+    models_dir: "/tmp/models"
+    logs_dir: "/tmp/logs"
+    
+  # Variables d'environnement
+  env_vars:
+    HF_HOME: "/tmp/huggingface"
+    TRANSFORMERS_CACHE: "/tmp/transformers"
+    TOKENIZERS_PARALLELISM: "false"
+    HF_HUB_DISABLE_PROGRESS_BARS: "1"
+
+# ===== CONFIGURATION AVANCÉE =====
+advanced:
+  # Expérimental
+  experimental:
+    neural_chunking: false
+    llm_guided_chunking: false
+    multi_language_detection: false
+    
+  # Optimisations spécifiques
+  optimizations:
+    batch_processing: true
+    parallel_embedding: false  # CPU only
+    memory_mapping: false
+    lazy_loading: true
+    
+  # Fallbacks et robustesse
+  fallbacks:
+    enable_fallback_chunking: true
+    fallback_method: "llamaindex"
+    max_retry_attempts: 3
+    graceful_degradation: true
+
+# ===== MÉTADONNÉES CONFIGURATION =====
+metadata:
+  version: "4.0.0"
+  created_date: "2025-06-29"
+  last_modified: "2025-06-29"
+  author: "Smart Chunker Pipeline v4.0"
+  description: "Configuration complète pour chunking sémantique intelligent récursif"
+  compatibility:
+    llama_index: "0.12.x"
+    chonkie: "1.0.8+"
+    python: "3.10+"
+    huggingface_spaces: true

custom_recursive_chunker.py

@@ -0,0 +1,366 @@
+"""
+Custom Recursive Semantic Chunker v4.0
+Contourne les limitations de chonkie 1.0.10 et implemente 
+un chunking récursif intelligent avec hiérarchie et parentalité.
+
+Auteur: Assistant Claude
+Compatible avec: LlamaIndex v0.12, HuggingFace embeddings
+"""
+
+import re
+import hashlib
+import logging
+from typing import List, Dict, Any, Optional, Tuple
+from dataclasses import dataclass
+from llama_index.core.schema import BaseEmbedding
+
+logger = logging.getLogger(__name__)
+
+@dataclass
+class ChunkResult:
+    """Résultat d'un chunk avec métadonnées hiérarchiques"""
+    id: str
+    text: str
+    level: int
+    parent_id: Optional[str] = None
+    children_ids: List[str] = None
+    metadata: Dict[str, Any] = None
+    embedding_vector: Optional[List[float]] = None
+    semantic_similarity: Optional[float] = None
+    
+    def __post_init__(self):
+        if self.children_ids is None:
+            self.children_ids = []
+        if self.metadata is None:
+            self.metadata = {}
+
+class CustomRecursiveChunker:
+    """
+    Chunker récursif intelligent qui simule le comportement 
+    souhaité sans dépendre des versions instables de chonkie
+    """
+    
+    def __init__(self, 
+                 embed_model: BaseEmbedding,
+                 chunk_sizes: List[int] = [2048, 512, 128],
+                 separators: List[str] = ["\n\n", "\n", ".", "!", "?", "—"],
+                 overlap_ratio: float = 0.1,
+                 min_chunk_size: int = 50,
+                 semantic_threshold: float = 0.75):
+        """
+        Initialise le chunker personnalisé
+        
+        Args:
+            embed_model: Modèle d'embedding LlamaIndex BaseEmbedding
+            chunk_sizes: Tailles hiérarchiques des chunks [grand, moyen, petit]
+            separators: Séparateurs pour découpage hiérarchique
+            overlap_ratio: Ratio de chevauchement entre chunks
+            min_chunk_size: Taille minimale d'un chunk
+            semantic_threshold: Seuil de similarité sémantique
+        """
+        self.embed_model = embed_model
+        self.chunk_sizes = sorted(chunk_sizes, reverse=True)  # [2048, 512, 128]
+        self.separators = separators
+        self.overlap_ratio = overlap_ratio
+        self.min_chunk_size = min_chunk_size
+        self.semantic_threshold = semantic_threshold
+        
+        logger.info(f"✅ CustomRecursiveChunker initialisé avec {len(chunk_sizes)} niveaux")
+    
+    def _generate_chunk_id(self, text: str, level: int, parent_id: str = None) -> str:
+        """Génère un ID unique pour un chunk"""
+        base_string = f"{text[:50]}-{level}-{parent_id or 'root'}"
+        return hashlib.md5(base_string.encode()).hexdigest()[:12]
+    
+    def _split_by_separators(self, text: str, separators: List[str]) -> List[str]:
+        """Découpe le texte selon une hiérarchie de séparateurs"""
+        chunks = [text]
+        
+        for separator in separators:
+            new_chunks = []
+            for chunk in chunks:
+                if len(chunk) > self.min_chunk_size:
+                    split_parts = chunk.split(separator)
+                    # Nettoie et filtre les parties vides
+                    split_parts = [part.strip() for part in split_parts if part.strip()]
+                    new_chunks.extend(split_parts)
+                else:
+                    new_chunks.append(chunk)
+            chunks = new_chunks
+            
+        return [chunk for chunk in chunks if len(chunk.strip()) >= self.min_chunk_size]
+    
+    def _apply_size_constraint(self, chunks: List[str], max_size: int) -> List[str]:
+        """Applique une contrainte de taille maximale aux chunks"""
+        result_chunks = []
+        
+        for chunk in chunks:
+            if len(chunk) <= max_size:
+                result_chunks.append(chunk)
+            else:
+                # Découpe les chunks trop longs
+                words = chunk.split()
+                current_chunk = []
+                current_size = 0
+                
+                for word in words:
+                    word_size = len(word) + 1  # +1 pour l'espace
+                    if current_size + word_size > max_size and current_chunk:
+                        result_chunks.append(" ".join(current_chunk))
+                        current_chunk = [word]
+                        current_size = word_size
+                    else:
+                        current_chunk.append(word)
+                        current_size += word_size
+                
+                if current_chunk:
+                    result_chunks.append(" ".join(current_chunk))
+        
+        return result_chunks
+    
+    def _add_overlap(self, chunks: List[str]) -> List[str]:
+        """Ajoute du chevauchement entre chunks adjacents"""
+        if len(chunks) <= 1:
+            return chunks
+            
+        overlapped_chunks = []
+        
+        for i, chunk in enumerate(chunks):
+            current_chunk = chunk
+            
+            # Ajoute le contexte du chunk pr��cédent
+            if i > 0:
+                prev_words = chunks[i-1].split()
+                overlap_size = int(len(prev_words) * self.overlap_ratio)
+                if overlap_size > 0:
+                    prefix = " ".join(prev_words[-overlap_size:])
+                    current_chunk = f"{prefix} {current_chunk}"
+            
+            # Ajoute le contexte du chunk suivant
+            if i < len(chunks) - 1:
+                next_words = chunks[i+1].split()
+                overlap_size = int(len(next_words) * self.overlap_ratio)
+                if overlap_size > 0:
+                    suffix = " ".join(next_words[:overlap_size])
+                    current_chunk = f"{current_chunk} {suffix}"
+            
+            overlapped_chunks.append(current_chunk)
+        
+        return overlapped_chunks
+    
+    async def _get_embedding(self, text: str) -> Optional[List[float]]:
+        """Obtient l'embedding d'un texte via le modèle LlamaIndex"""
+        try:
+            # Utilise la méthode standard LlamaIndex BaseEmbedding
+            embedding = await self.embed_model.aget_text_embedding(text)
+            return embedding
+        except Exception as e:
+            logger.warning(f"⚠️ Erreur embedding pour chunk: {e}")
+            return None
+    
+    def _calculate_semantic_similarity(self, embedding1: List[float], 
+                                     embedding2: List[float]) -> float:
+        """Calcule la similarité cosinus entre deux embeddings"""
+        try:
+            import numpy as np
+            
+            vec1 = np.array(embedding1)
+            vec2 = np.array(embedding2)
+            
+            # Similarité cosinus
+            dot_product = np.dot(vec1, vec2)
+            magnitude1 = np.linalg.norm(vec1)
+            magnitude2 = np.linalg.norm(vec2)
+            
+            if magnitude1 == 0 or magnitude2 == 0:
+                return 0.0
+                
+            similarity = dot_product / (magnitude1 * magnitude2)
+            return float(similarity)
+            
+        except Exception as e:
+            logger.warning(f"⚠️ Erreur calcul similarité: {e}")
+            return 0.0
+    
+    async def _chunk_recursive_level(self, text: str, level: int, 
+                                   parent_id: Optional[str] = None) -> List[ChunkResult]:
+        """Applique le chunking récursif pour un niveau donné"""
+        if level >= len(self.chunk_sizes):
+            return []
+        
+        max_size = self.chunk_sizes[level]
+        
+        # 1. Découpage initial par séparateurs
+        raw_chunks = self._split_by_separators(text, self.separators)
+        
+        # 2. Application de la contrainte de taille
+        sized_chunks = self._apply_size_constraint(raw_chunks, max_size)
+        
+        # 3. Ajout du chevauchement
+        overlapped_chunks = self._add_overlap(sized_chunks)
+        
+        # 4. Création des objets ChunkResult
+        chunk_results = []
+        
+        for i, chunk_text in enumerate(overlapped_chunks):
+            chunk_id = self._generate_chunk_id(chunk_text, level, parent_id)
+            
+            # Obtient l'embedding
+            embedding = await self._get_embedding(chunk_text)
+            
+            chunk_result = ChunkResult(
+                id=chunk_id,
+                text=chunk_text,
+                level=level,
+                parent_id=parent_id,
+                embedding_vector=embedding,
+                metadata={
+                    "position": i,
+                    "total_chunks": len(overlapped_chunks),
+                    "size": len(chunk_text),
+                    "max_size": max_size
+                }
+            )
+            
+            chunk_results.append(chunk_result)
+        
+        # 5. Chunking récursif pour le niveau suivant
+        all_chunks = chunk_results.copy()
+        
+        for chunk_result in chunk_results:
+            if len(chunk_result.text) > self.min_chunk_size * 2:  # Seulement si assez grand
+                sub_chunks = await self._chunk_recursive_level(
+                    chunk_result.text, 
+                    level + 1, 
+                    chunk_result.id
+                )
+                
+                # Met à jour les relations parent-enfant
+                chunk_result.children_ids = [sub_chunk.id for sub_chunk in sub_chunks]
+                all_chunks.extend(sub_chunks)
+        
+        return all_chunks
+    
+    async def chunk_text(self, text: str, metadata: Dict[str, Any] = None) -> List[ChunkResult]:
+        """
+        Point d'entrée principal pour le chunking récursif
+        
+        Args:
+            text: Texte à chunker
+            metadata: Métadonnées à attacher aux chunks
+            
+        Returns:
+            Liste des chunks avec hiérarchie et relations
+        """
+        if not text or len(text.strip()) < self.min_chunk_size:
+            logger.warning("⚠️ Texte trop court pour chunking")
+            return []
+        
+        logger.info(f"�� Début chunking récursif - {len(text)} caractères")
+        
+        try:
+            # Chunking récursif à partir du niveau 0
+            all_chunks = await self._chunk_recursive_level(text, level=0)
+            
+            # Enrichit les métadonnées
+            for chunk in all_chunks:
+                if metadata:
+                    chunk.metadata.update(metadata)
+                chunk.metadata["total_levels"] = len(self.chunk_sizes)
+                chunk.metadata["algorithm"] = "CustomRecursiveChunker"
+            
+            # Calcule les similarités sémantiques entre chunks du même niveau
+            await self._compute_semantic_similarities(all_chunks)
+            
+            logger.info(f"✅ Chunking terminé - {len(all_chunks)} chunks générés")
+            return all_chunks
+            
+        except Exception as e:
+            logger.error(f"❌ Erreur chunking récursif: {e}")
+            raise
+    
+    async def _compute_semantic_similarities(self, chunks: List[ChunkResult]):
+        """Calcule les similarités sémantiques entre chunks"""
+        # Groupe les chunks par niveau
+        chunks_by_level = {}
+        for chunk in chunks:
+            if chunk.level not in chunks_by_level:
+                chunks_by_level[chunk.level] = []
+            chunks_by_level[chunk.level].append(chunk)
+        
+        # Calcule les similarités pour chaque niveau
+        for level, level_chunks in chunks_by_level.items():
+            for i, chunk1 in enumerate(level_chunks):
+                if chunk1.embedding_vector is None:
+                    continue
+                    
+                max_similarity = 0.0
+                for j, chunk2 in enumerate(level_chunks):
+                    if i != j and chunk2.embedding_vector is not None:
+                        similarity = self._calculate_semantic_similarity(
+                            chunk1.embedding_vector, 
+                            chunk2.embedding_vector
+                        )
+                        max_similarity = max(max_similarity, similarity)
+                
+                chunk1.semantic_similarity = max_similarity
+    
+    def to_obsidian_format(self, chunks: List[ChunkResult], 
+                          source_title: str = "Document") -> str:
+        """Convertit les chunks en format Obsidian avec liens hiérarchiques"""
+        obsidian_content = []
+        obsidian_content.append(f"# {source_title} - Chunking Hiérarchique\n")
+        
+        # Groupe par niveau pour affichage structuré
+        chunks_by_level = {}
+        for chunk in chunks:
+            if chunk.level not in chunks_by_level:
+                chunks_by_level[chunk.level] = []
+            chunks_by_level[chunk.level].append(chunk)
+        
+        for level in sorted(chunks_by_level.keys()):
+            level_chunks = chunks_by_level[level]
+            obsidian_content.append(f"\n## Niveau {level} ({len(level_chunks)} chunks)\n")
+            
+            for chunk in level_chunks:
+                # Titre du chunk avec ID
+                obsidian_content.append(f"### [[{chunk.id}]] {chunk.id}")
+                
+                # Métadonnées
+                obsidian_content.append("```yaml")
+                obsidian_content.append(f"level: {chunk.level}")
+                obsidian_content.append(f"parent: {chunk.parent_id or 'root'}")
+                obsidian_content.append(f"children: {len(chunk.children_ids)}")
+                obsidian_content.append(f"size: {len(chunk.text)}")
+                if chunk.semantic_similarity:
+                    obsidian_content.append(f"similarity: {chunk.semantic_similarity:.3f}")
+                obsidian_content.append("```\n")
+                
+                # Liens de navigation
+                if chunk.parent_id:
+                    obsidian_content.append(f"**Parent:** [[{chunk.parent_id}]]")
+                if chunk.children_ids:
+                    children_links = ", ".join([f"[[{child_id}]]" for child_id in chunk.children_ids])
+                    obsidian_content.append(f"**Enfants:** {children_links}")
+                
+                # Contenu du chunk
+                obsidian_content.append(f"\n**Contenu:**\n{chunk.text}\n")
+                obsidian_content.append("---\n")
+        
+        return "\n".join(obsidian_content)
+    
+    def to_json_format(self, chunks: List[ChunkResult]) -> List[Dict[str, Any]]:
+        """Convertit les chunks en format JSON pour API"""
+        return [
+            {
+                "id": chunk.id,
+                "text": chunk.text,
+                "level": chunk.level,
+                "parent_id": chunk.parent_id,
+                "children_ids": chunk.children_ids,
+                "metadata": chunk.metadata,
+                "has_embedding": chunk.embedding_vector is not None,
+                "semantic_similarity": chunk.semantic_similarity
+            }
+            for chunk in chunks
+        ]

deployment_instructions.md

@@ -0,0 +1,154 @@
+# 🚀 Instructions de déploiement - Smart Chunker v4.0
+
+## 📋 Étapes à suivre
+
+### 1. **Remplacement des fichiers**
+Remplace les fichiers suivants dans ton projet par les versions corrigées :
+
+```bash
+# Fichiers à remplacer
+├── chunker_pipeline.py    # ✅ Version corrigée avec CustomRecursiveChunker
+├── requirements.txt       # ✅ Dépendances compatibles épinglées
+├── app.py                # ✅ API FastAPI mise à jour
+└── custom_recursive_chunker.py  # ✅ Nouveau fichier à ajouter
+```
+
+### 2. **Garde les fichiers existants**
+Ces fichiers restent inchangés :
+- `config.yaml` ✅ (déjà compatible)
+- `schemas.py` ✅ (déjà compatible)
+- `Dockerfile` (si nécessaire)
+
+### 3. **Structure finale du projet**
+```
+ton_projet/
+├── app.py                      # ✅ API FastAPI corrigée
+├── chunker_pipeline.py         # ✅ Pipeline principal corrigé
+├── custom_recursive_chunker.py # ✅ NOUVEAU - Chunker personnalisé
+├── requirements.txt            # ✅ Dépendances mises à jour
+├── config.yaml                # ✅ Configuration existante (OK)
+├── schemas.py                 # ✅ Schémas existants (OK)
+└── Dockerfile                 # ✅ Si nécessaire
+```
+
+## 🔧 Changements principaux
+
+### ✅ Chunker personnalisé au lieu de chonkie instable
+- Plus de problèmes avec `separators=` ou `chunk_sizes=`
+- Logique récursive native et contrôlée
+- Compatible avec toutes les versions
+
+### ✅ Embeddings corrigés
+- `EmbeddingWrapper` pour compatibilité LlamaIndex
+- Plus d'erreurs `encode()` 
+- SentenceTransformer utilisé directement
+
+### ✅ Imports simplifiés
+- Import seulement de `SemanticChunker` depuis chonkie (optionnel)
+- Plus de dépendances sur des modules instables
+- Fallback automatique si chonkie indisponible
+
+## 🧪 Test de fonctionnement
+
+Après déploiement, teste avec :
+
+```bash
+# 1. Health check
+curl -X GET "http://localhost:7860/health"
+
+# 2. Test simple
+curl -X POST "http://localhost:7860/test"
+
+# 3. Chunking personnalisé
+curl -X POST "http://localhost:7860/chunk" \
+  -H "Content-Type: application/json" \
+  -d '{
+    "text": "Ton texte à chunker ici...",
+    "method": "custom_recursive",
+    "export_obsidian": true,
+    "metadata": {"title": "Test Document"}
+  }'
+```
+
+## 📊 Méthodes disponibles
+
+1. **`custom_recursive`** (recommandée) - Chunker intelligent personnalisé
+2. **`chonkie_semantic`** (si chonkie disponible) - Chunking sémantique
+3. **`llamaindex`** (fallback) - Chunking standard LlamaIndex
+
+## 🔍 Vérifications de debug
+
+Si problèmes persistent :
+
+### 1. Vérifier les logs d'initialisation
+```bash
+# Recherche ces lignes dans les logs :
+✅ CustomRecursiveChunker initialisé avec succès
+✅ SmartChunkerPipeline v4.0 initialisé avec succès
+✅ Pipeline initialisé avec succès
+```
+
+### 2. Endpoint de diagnostic
+```bash
+GET /config  # Configuration active
+GET /methods # Méthodes disponibles
+GET /health  # État détaillé des composants
+```
+
+### 3. Test minimal
+```python
+# Test local rapide
+import asyncio
+from chunker_pipeline import SmartChunkerPipeline
+
+async def test():
+    pipeline = SmartChunkerPipeline()
+    await pipeline.initialize()
+    chunks = await pipeline.chunk_text("Test simple", method="custom_recursive")
+    print(f"✅ {len(chunks)} chunks générés")
+
+asyncio.run(test())
+```
+
+## 🎯 Avantages de cette solution
+
+### ✅ **Stabilité**
+- Plus de dépendances sur des versions instables de chonkie
+- Chunker personnalisé 100% maîtrisé
+- Compatibilité garantie avec LlamaIndex v0.12
+
+### ✅ **Fonctionnalités complètes**
+- Chunking récursif hiérarchique intelligent
+- Relations parent-enfant automatiques
+- Embeddings sémantiques intégrés
+- Export Obsidian formaté
+
+### ✅ **Performance**
+- Optimisé pour HuggingFace Spaces
+- Modèles légers (CPU-friendly)
+- Cache intelligent des embeddings
+
+### ✅ **Flexibilité**
+- 3 méthodes de chunking disponibles
+- Configuration modulaire via YAML
+- API RESTful complète
+
+## 🚨 Points d'attention
+
+1. **Première initialisation** peut prendre 1-2 minutes (téléchargement modèles)
+2. **Mémoire requise** : ~2GB RAM pour les modèles
+3. **CPU uniquement** sur HF Spaces gratuits (normal)
+4. **Cache des modèles** : utilise le répertoire temporaire
+
+## 📞 Support
+
+Si tu rencontres des erreurs après déploiement :
+
+1. **Copie les logs complets** (surtout les lignes avec ❌)
+2. **Teste l'endpoint** `/health` pour diagnostic
+3. **Vérifie** que tous les fichiers sont bien remplacés
+4. **Confirme** la version Python (3.10+ recommandée)
+
+---
+
+🎉 **Cette solution devrait résoudre définitivement tous les problèmes identifiés dans ta discussion avec GPT !**

guide_deploiement_hf.md

@@ -0,0 +1,574 @@
+# 🚀 Guide de Déploiement Hugging Face Space
+## Chunking Sémantique Intelligent Récursif avec Parentalité
+
+**Version:** 1.0.0  
+**Prérequis:** Compte Hugging Face existant  
+**Durée estimée:** 15-20 minutes  
+**Niveau:** Débutant à Intermédiaire  
+
+---
+
+## 📋 **Table des Matières**
+
+1. [Préparation des fichiers](#1-préparation-des-fichiers)
+2. [Création du Space Hugging Face](#2-création-du-space-hugging-face)
+3. [Configuration du Space](#3-configuration-du-space)
+4. [Upload des fichiers](#4-upload-des-fichiers)
+5. [Configuration des variables d'environnement](#5-configuration-des-variables-denvironnement)
+6. [Démarrage et monitoring](#6-démarrage-et-monitoring)
+7. [Tests et validation](#7-tests-et-validation)
+8. [Intégration avec n8n](#8-intégration-avec-n8n)
+9. [Troubleshooting](#9-troubleshooting)
+10. [Optimisations avancées](#10-optimisations-avancées)
+
+---
+
+## 1. 📂 Préparation des Fichiers
+
+### 1.1 Structure de projet requise
+
+Créez un dossier local `chunking-intelligent-api/` avec cette structure :
+
+```
+chunking-intelligent-api/
+├── app.py                    # ✅ API FastAPI principale
+├── schemas.py               # ✅ Modèles Pydantic
+├── pipeline.py              # ✅ Pipeline de base
+├── chunker_pipeline.py      # ✅ Logique métier chunking
+├── config.yaml              # ✅ Configuration système
+├── requirements.txt         # ✅ Dépendances
+├── Dockerfile              # ✅ Container optimisé
+├── README.md               # 📝 Documentation (optionnel)
+└── .gitignore             # 🔒 Fichiers à ignorer (optionnel)
+```
+
+### 1.2 Vérification des fichiers
+
+**✅ Checklist avant upload :**
+
+- [ ] `app.py` contient le code FastAPI complet
+- [ ] `schemas.py` définit tous les modèles Pydantic
+- [ ] `pipeline.py` contient la logique de base
+- [ ] `chunker_pipeline.py` contient votre workflow intelligent
+- [ ] `config.yaml` est correctement configuré
+- [ ] `requirements.txt` contient toutes les dépendances
+- [ ] `Dockerfile` utilise `FROM python:3.10` (pas `-slim`)
+
+### 1.3 Fichiers optionnels
+
+**README.md** (recommandé) :
+```markdown
+# Chunking Sémantique Intelligent API
+
+API de découpage récursif hiérarchique avec parentalité pour Second Cerveau et Agents IA.
+
+## Utilisation
+
+```bash
+curl -X POST "https://VOTRE_SPACE.hf.space/chunk" \
+  -H "Content-Type: application/json" \
+  -d '{"text": "Votre texte ici", "titre": "Mon document"}'
+```
+
+## Endpoints
+
+- `GET /` - Status de l'API
+- `GET /health` - Vérification santé
+- `POST /chunk` - Chunking principal
+```
+
+**.gitignore** (optionnel) :
+```
+__pycache__/
+*.pyc
+*.pyo
+.env
+.venv/
+cache/
+logs/
+*.log
+.DS_Store
+```
+
+---
+
+## 2. 🏗️ Création du Space Hugging Face
+
+### 2.1 Accès à Hugging Face
+
+1. **Connectez-vous** à [huggingface.co](https://huggingface.co)
+2. **Vérifiez votre compte** est activé et fonctionnel
+
+### 2.2 Création du nouveau Space
+
+1. **Cliquez** sur votre avatar (coin supérieur droit)
+2. **Sélectionnez** "New Space"
+3. **Remplissez le formulaire** :
+
+| Champ | Valeur Recommandée | Notes |
+|-------|-------------------|-------|
+| **Space name** | `chunking-intelligent-api` | Nom unique, sans espaces |
+| **License** | `MIT` | Licence open source |
+| **Select the SDK** | `Docker` | ⚠️ **IMPORTANT: Choisir Docker** |
+| **Hardware** | `CPU basic (free)` | Suffisant pour votre projet |
+| **Visibility** | `Public` | Accessible pour n8n |
+
+4. **Cliquez** "Create Space"
+
+### 2.3 Attendre la création
+
+- Le Space se crée automatiquement (30-60 secondes)
+- Vous êtes redirigé vers la page du Space
+- Status initial : "Building" ou "Pending"
+
+---
+
+## 3. ⚙️ Configuration du Space
+
+### 3.1 Accès aux paramètres
+
+1. **Cliquez** sur l'onglet "Settings" dans votre Space
+2. **Vérifiez la configuration** :
+
+| Paramètre | Valeur | Obligatoire |
+|-----------|--------|-------------|
+| **SDK** | Docker | ✅ Oui |
+| **Hardware** | CPU basic | ✅ Oui |
+| **Python version** | Auto-detect | ✅ Oui |
+| **Port** | 7860 | ✅ Oui |
+
+### 3.2 Configuration avancée (optionnel)
+
+**Secrets et variables d'environnement** (si vous avez une clé OpenAI) :
+
+1. **Allez** dans "Settings" → "Repository secrets"
+2. **Ajoutez** une nouvelle variable :
+   - **Name:** `OPENAI_API_KEY`
+   - **Value:** `votre_clé_openai_ici`
+   - **Cliquez** "Add secret"
+
+⚠️ **Note** : Le projet fonctionne sans clé OpenAI grâce aux fallbacks configurés.
+
+---
+
+## 4. 📤 Upload des Fichiers
+
+### 4.1 Méthode recommandée : Interface Web
+
+1. **Cliquez** sur l'onglet "Files" dans votre Space
+2. **Pour chaque fichier** à uploader :
+
+#### Upload de `Dockerfile` :
+1. **Cliquez** "Add file" → "Create a new file"
+2. **Nom du fichier** : `Dockerfile`
+3. **Copiez-collez** le contenu du Dockerfile généré
+4. **Cliquez** "Commit new file to main"
+
+#### Upload de `app.py` :
+1. **Cliquez** "Add file" → "Create a new file"  
+2. **Nom du fichier** : `app.py`
+3. **Copiez-collez** le contenu d'app.py
+4. **Cliquez** "Commit new file to main"
+
+#### Upload des autres fichiers :
+Répétez pour chaque fichier dans cet ordre :
+1. `requirements.txt` (important en premier)
+2. `config.yaml`
+3. `schemas.py`
+4. `pipeline.py`
+5. `chunker_pipeline.py`
+6. `README.md` (optionnel)
+
+### 4.2 Méthode alternative : Git (utilisateurs avancés)
+
+```bash
+# Cloner le repo du Space
+git clone https://huggingface.co/spaces/VOTRE_USERNAME/chunking-intelligent-api
+cd chunking-intelligent-api
+
+# Copier tous vos fichiers dans ce dossier
+cp /chemin/vers/vos/fichiers/* .
+
+# Commit et push
+git add .
+git commit -m "🚀 Initial chunking intelligent API"
+git push origin main
+```
+
+### 4.3 Vérification upload
+
+**✅ Checklist après upload :**
+
+- [ ] Tous les fichiers sont visibles dans l'onglet "Files"
+- [ ] Aucun message d'erreur dans l'interface
+- [ ] Le Space passe en status "Building"
+- [ ] Logs de build commencent à apparaître
+
+---
+
+## 5. 🔧 Configuration des Variables d'Environnement
+
+### 5.1 Variables obligatoires
+
+**Dans Settings → Repository secrets :**
+
+| Variable | Valeur | Description |
+|----------|--------|-------------|
+| `OPENAI_API_KEY` | `votre_clé` ou `demo-key` | Clé API OpenAI (optionnel) |
+| `HF_TOKEN` | Auto-détecté | Token HF (automatique) |
+
+### 5.2 Variables avancées (optionnel)
+
+**Pour personnalisation avancée :**
+
+| Variable | Valeur par défaut | Utilité |
+|----------|------------------|---------|
+| `CHUNKING_DEBUG` | `false` | Mode debug détaillé |
+| `MAX_TEXT_LENGTH` | `500000` | Limite taille texte |
+| `CACHE_SIZE_MB` | `100` | Taille cache |
+
+### 5.3 Configuration dans le code
+
+Les variables sont automatiquement chargées grâce à :
+```python
+import os
+api_key = os.getenv("OPENAI_API_KEY", "demo-key")
+```
+
+---
+
+## 6. 🎬 Démarrage et Monitoring
+
+### 6.1 Suivi du build
+
+1. **Allez** dans l'onglet "Logs" de votre Space
+2. **Surveillez** les étapes de build :
+
+```
+✅ Étapes de build normales :
+- Downloading image layers
+- Installing system dependencies  
+- Installing Python packages
+- Copying application files
+- Starting uvicorn server
+- Application startup complete
+```
+
+**⏱️ Temps de build attendu :** 5-10 minutes (première fois)
+
+### 6.2 Détection problèmes build
+
+**❌ Erreurs communes et solutions :**
+
+| Erreur | Cause | Solution |
+|--------|-------|----------|
+| `CMake not found` | Image `-slim` utilisée | Vérifier `FROM python:3.10` |
+| `Package not found` | Dépendance manquante | Vérifier `requirements.txt` |
+| `Port 7860 not available` | Config port incorrecte | Vérifier `Dockerfile` EXPOSE |
+| `Import error` | Ordre dépendances | Réorganiser `requirements.txt` |
+
+### 6.3 Validation démarrage réussi
+
+**✅ Signes de succès :**
+
+- Status Space = "Running" (vert)
+- Logs finissent par "Application startup complete"
+- URL Space répond (peut prendre 2-3 minutes)
+- Onglet "App" montre l'interface
+
+---
+
+## 7. ✅ Tests et Validation
+
+### 7.1 Test automatique santé
+
+1. **Cliquez** sur l'onglet "App" de votre Space
+2. **L'URL** sera : `https://VOTRE_USERNAME-chunking-intelligent-api.hf.space`
+3. **Vérifiez** que la page charge sans erreur
+
+### 7.2 Test endpoint status
+
+**Curl de base :**
+```bash
+curl https://VOTRE_USERNAME-chunking-intelligent-api.hf.space/
+```
+
+**Réponse attendue :**
+```json
+{
+  "status": "running",
+  "service": "Chunking Sémantique Intelligent API",
+  "version": "1.0.0",
+  "endpoints": ["/chunk", "/health"]
+}
+```
+
+### 7.3 Test endpoint santé
+
+```bash
+curl https://VOTRE_USERNAME-chunking-intelligent-api.hf.space/health
+```
+
+**Réponse attendue :**
+```json
+{
+  "status": "healthy",
+  "pipeline_ready": true,
+  "memory_usage": {
+    "memory_usage_mb": 450.23,
+    "memory_percent": 22.5
+  }
+}
+```
+
+### 7.4 Test chunking simple
+
+```bash
+curl -X POST "https://VOTRE_USERNAME-chunking-intelligent-api.hf.space/chunk" \
+  -H "Content-Type: application/json" \
+  -d '{
+    "text": "Voici un texte de test pour le chunking. Il contient plusieurs phrases. Chaque phrase devrait être analysée sémantiquement. Le système doit créer des chunks intelligents.",
+    "titre": "Test de chunking",
+    "source": "test_manuel"
+  }'
+```
+
+**Réponse attendue (structure) :**
+```json
+{
+  "chunks": [
+    {
+      "content": "...",
+      "metadata": {
+        "chunk_id": "...",
+        "level": 0,
+        "tokens_count": 25,
+        "main_concepts": ["test", "chunking"],
+        "keywords": ["texte", "analyse", "intelligent"]
+      }
+    }
+  ],
+  "total_chunks": 3,
+  "processing_time": 2.45,
+  "source_metadata": {...}
+}
+```
+
+---
+
+## 8. 🔗 Intégration avec n8n
+
+### 8.1 Configuration node HTTP Request
+
+**Dans n8n, créez un node "HTTP Request" :**
+
+| Paramètre | Valeur |
+|-----------|--------|
+| **Method** | POST |
+| **URL** | `https://VOTRE_USERNAME-chunking-intelligent-api.hf.space/chunk` |
+| **Authentication** | None |
+| **Headers** | `Content-Type: application/json` |
+| **Body** | JSON |
+
+### 8.2 Structure JSON pour n8n
+
+```json
+{
+  "text": "{{ $json.transcription }}",
+  "source_id": "{{ $json.source_id }}",
+  "titre": "{{ $json.titre }}",
+  "source": "{{ $json.lien }}",
+  "type": "{{ $json.type }}",
+  "chunk_sizes": [2048, 512, 128],
+  "include_metadata": true,
+  "detect_structure": true
+}
+```
+
+### 8.3 Traitement réponse n8n
+
+**Code JavaScript dans node "Code" :**
+```javascript
+// Traitement réponse chunking
+const chunkingResponse = $input.all()[0].json;
+
+const processedChunks = chunkingResponse.chunks.map(chunk => ({
+  chunk_id: chunk.metadata.chunk_id,
+  content: chunk.content,
+  level: chunk.metadata.level,
+  concepts: chunk.metadata.main_concepts,
+  keywords: chunk.metadata.keywords,
+  parent_id: chunk.metadata.parent_id,
+  children_ids: chunk.metadata.children_ids
+}));
+
+return {
+  chunks: processedChunks,
+  summary: {
+    total_chunks: chunkingResponse.total_chunks,
+    processing_time: chunkingResponse.processing_time,
+    source: chunkingResponse.source_metadata
+  }
+};
+```
+
+### 8.4 Workflow n8n complet
+
+**Exemple workflow :**
+1. **Trigger** : Webhook ou Schedule
+2. **Google Sheets** : Lecture transcriptions
+3. **HTTP Request** : Appel chunking API
+4. **Code** : Traitement réponse
+5. **Mem0/Qdrant** : Stockage chunks
+6. **Obsidian** : Export notes
+
+---
+
+## 9. 🔧 Troubleshooting
+
+### 9.1 Problèmes de build
+
+**Erreur : "Package not found"**
+```bash
+# Solution : Vérifier requirements.txt
+ERROR: Could not find a version that satisfies the requirement xyz
+```
+→ Vérifiez noms et versions dans `requirements.txt`
+
+**Erreur : "CMake not found"**
+```bash
+CMake Error: CMAKE_C_COMPILER not set
+```
+→ Vérifiez `FROM python:3.10` (pas `-slim`)
+
+**Erreur : "Memory limit exceeded"**
+```bash
+Killed (out of memory)
+```
+→ Réduisez dépendances ou activez optimisations
+
+### 9.2 Problèmes runtime
+
+**Space ne démarre pas**
+1. Vérifiez logs pour erreurs Python
+2. Testez code localement d'abord
+3. Vérifiez variables d'environnement
+
+**Erreur 500 sur /chunk**
+1. Vérifiez logs détaillés
+2. Testez avec texte plus court
+3. Vérifiez clé OpenAI si utilisée
+
+**Timeout sur requêtes**
+1. Réduisez taille texte input
+2. Optimisez paramètres chunking
+3. Vérifiez limits dans config.yaml
+
+### 9.3 Problèmes performance
+
+**Lenteur excessive**
+```yaml
+# Dans config.yaml - Optimisations
+performance:
+  memory:
+    enable_garbage_collection: true
+  caching:
+    enabled: true
+  concurrency:
+    max_workers: 1
+```
+
+**Consommation mémoire élevée**
+```python
+# Monitoring dans logs
+memory_usage = pipeline.get_memory_usage()
+if memory_usage["memory_percent"] > 90:
+    # Cleanup automatique
+    await pipeline.cleanup()
+```
+
+### 9.4 Support et aide
+
+**Ressources officielles :**
+- [HF Spaces Documentation](https://huggingface.co/docs/hub/spaces)
+- [Docker Support](https://huggingface.co/docs/hub/spaces-sdks-docker)
+- [Community Forum](https://discuss.huggingface.co/)
+
+**Debug avancé :**
+```bash
+# Logs détaillés depuis interface HF
+# Ou accès direct via API
+curl https://huggingface.co/api/spaces/VOTRE_USERNAME/chunking-intelligent-api/logs
+```
+
+---
+
+## 10. 🚀 Optimisations Avancées
+
+### 10.1 Optimisations mémoire
+
+**Ajouts dans config.yaml :**
+```yaml
+performance:
+  memory:
+    max_memory_mb: 1800  # Sécurité pour 2GB Space
+    cleanup_interval: 50  # Nettoyage plus fréquent
+    cache_size_limit: 500  # Cache réduit
+```
+
+### 10.2 Optimisations vitesse
+
+**Pre-loading modèles dans Dockerfile :**
+```dockerfile
+# Ajout après installation requirements
+RUN python -c "from transformers import AutoModel; AutoModel.from_pretrained('BAAI/bge-small-en-v1.5', cache_dir='/app/cache')"
+```
+
+### 10.3 Monitoring avancé
+
+**Ajout endpoint metrics :**
+```python
+@app.get("/metrics")
+async def get_metrics():
+    return {
+        "memory": pipeline.get_memory_usage(),
+        "health": await pipeline.health_check(),
+        "cache_stats": {
+            "embedding_cache": len(pipeline._embedding_cache),
+            "concept_cache": len(pipeline._concept_cache)
+        }
+    }
+```
+
+### 10.4 Auto-scaling (si upgrade vers Space Pro)
+
+```yaml
+# config.yaml pour Spaces payants
+performance:
+  concurrency:
+    max_workers: 2  # Plus de workers
+    adaptive_scaling: true
+  memory:
+    max_memory_mb: 7000  # Plus de RAM
+```
+
+---
+
+## 🎉 Félicitations !
+
+Votre **Chunking Sémantique Intelligent API** est maintenant déployée et fonctionnelle sur Hugging Face Space !
+
+**🔗 URLs importantes :**
+- **API principale :** `https://VOTRE_USERNAME-chunking-intelligent-api.hf.space`
+- **Endpoint chunking :** `/chunk`
+- **Health check :** `/health`
+- **Métriques :** `/metrics`
+
+**📋 Prochaines étapes recommandées :**
+1. ✅ Tester avec vos vrais contenus
+2. ✅ Intégrer dans n8n
+3. ✅ Connecter à Mem0/Qdrant
+4. ✅ Configurer Obsidian
+5. ✅ Créer vos agents spécialisés
+
+**🚀 Votre système de Second Cerveau intelligent est prêt !**

requirements.txt

@@ -0,0 +1,126 @@
+# ============================================================================
+# 📦 requirements.txt - VERSION FINALE FUSIONNÉE v4.0
+# ============================================================================
+# 🧠 Projet : Chunking sémantique intelligent récursif hiérarchique
+# ✅ SOLUTION : Combinaison fichier original + corrections + CustomRecursiveChunker
+# ✅ COMPATIBLE : HuggingFace Spaces + LlamaIndex v0.12 + Chonkie stable
+# ============================================================================
+
+# ========= 🚀 API + SERVEUR =========
+fastapi==0.115.6
+uvicorn[standard]==0.32.1
+python-multipart==0.0.19
+
+# ========= 📋 CONFIGURATION + VALIDATION =========
+pydantic==2.10.3
+pydantic-settings==2.1.0
+python-dotenv==1.0.0
+PyYAML==6.0.1
+
+# ========= 🧠 LLAMAINDEX MODULAIRE v0.12 =========
+# ✅ CORRECTION: Versions compatibles épinglées
+llama-index-core==0.12.8
+llama-index-embeddings-huggingface==0.4.1
+llama-index-llms-huggingface==0.4.1
+llama-index-readers-file==0.4.9
+
+# ✅ OPTION LLM LOCAL : Uncomment si tu veux llama-cpp
+# llama-index-llms-llama-cpp==0.3.0
+# llama-cpp-python==0.2.35
+
+# ========= 🦛 CHUNKING + MODELS =========
+# ✅ CORRECTION MAJEURE: Version stable publique de Chonkie
+chonkie==1.0.8
+
+# ✅ MODELS: Versions compatibles HF Spaces
+transformers>=4.46.0,<4.50.0
+sentence-transformers==3.3.1
+torch>=2.0.0,<2.5.0
+tokenizers>=0.20.0,<0.21.0
+
+# ✅ SÉCURITÉ: Évite les conflits avec HF Spaces
+accelerate>=0.20.0,<0.35.0
+safetensors>=0.3.0,<0.5.0
+huggingface-hub>=0.19.0,<0.26.0
+
+# ========= 📝 TRAITEMENT TEXTE =========
+beautifulsoup4==4.12.3
+markdownify==0.11.6
+lxml==4.9.3
+regex==2023.10.3
+bleach==6.1.0
+
+# ========= 📊 DONNÉES + CALCULS =========
+numpy>=1.24.0,<2.0.0
+pandas>=2.0.0,<2.3.0
+orjson==3.9.10
+
+# ========= 🔬 MACHINE LEARNING SUPPORT =========
+scikit-learn>=1.3.0,<1.6.0
+matplotlib>=3.7.0,<3.10.0
+seaborn>=0.12.0,<0.14.0
+
+# ========= 🌐 RÉSEAU + HTTP =========
+aiohttp==3.9.1
+httpcore==1.0.2
+httpx==0.25.2
+tenacity==8.2.3
+validators==0.22.0
+requests>=2.31.0,<3.0.0
+
+# ========= 💾 SYSTÈME + CACHE =========
+psutil==5.9.6
+cachetools==5.3.2
+redis>=5.0.0,<6.0.0
+diskcache>=5.6.0,<6.0.0
+
+# ========= 📝 DOCUMENTATION + EXPORT =========
+markdown>=3.5.0,<4.0.0
+jinja2>=3.1.0,<4.0.0
+
+# ========= 🐛 MONITORING + LOGGING =========
+loguru>=0.7.0,<1.0.0
+
+# ========= 🔐 SÉCURITÉ =========
+cryptography>=41.0.0,<43.0.0
+
+# ========= 🧪 TESTS + DÉVELOPPEMENT =========
+pytest==7.4.3
+pytest-asyncio>=0.21.0
+
+# ========= 🎯 OPTIMISATIONS HF SPACES =========
+# ✅ Versions épinglées pour éviter les conflits d'environnement
+wheel>=0.40.0
+setuptools>=65.0.0
+
+# ========= 📌 NOTES IMPORTANTES =========
+# 
+# 🔧 CORRECTIONS APPLIQUÉES:
+# ✅ chonkie==1.0.8 (stable PyPI) au lieu de Git @commit
+# ✅ LlamaIndex v0.12.8 (modulaire) avec imports corrigés
+# ✅ Transformers 4.46+ compatible avec sentence-transformers 3.3.1
+# ✅ Torch 2.x stable avec accélération CPU/GPU
+# ✅ Versions épinglées pour HuggingFace Spaces
+#
+# 🚀 FONCTIONNALITÉS SUPPORTÉES:
+# ✅ CustomRecursiveChunker (chunking hiérarchique intelligent)
+# ✅ Chonkie SemanticChunker (si import réussit)
+# ✅ Relations bidirectionnelles parent-enfant
+# ✅ Export Obsidian format [[Titre]], id
+# ✅ Base connaissance agents spécialisés
+# ✅ Embeddings sémantiques via SentenceTransformer
+# ✅ Pipeline FastAPI complet
+#
+# ⚠️ COMPATIBILITÉ HUGGINGFACE SPACES:
+# - Utilise /tmp pour cache (write-accessible)
+# - CPU uniquement sur HF Spaces gratuits
+# - Mémoire limitée à ~2GB RAM
+# - Pas de GPU sur plan gratuit
+#
+# 🔄 VERSIONS TESTÉES ET VALIDÉES:
+# - Python 3.10+
+# - Ubuntu 20.04+ / Debian 11+
+# - HuggingFace Spaces (CPU)
+# - Docker containers
+#
+# ============================================================================

schemas.py

@@ -0,0 +1,234 @@
+from pydantic import BaseModel, Field, validator
+from typing import List, Dict, Any, Optional, Union
+from enum import Enum
+
+class ContentType(str, Enum):
+    """Types de contenu supportés"""
+    TEXT = "text"
+    PDF = "pdf"
+    YOUTUBE = "youtube"
+    EMAIL = "email"
+    WEB = "web"
+    DOCUMENT = "document"
+
+class ChunkLevel(str, Enum):
+    """Niveaux hiérarchiques des chunks"""
+    DOCUMENT = "document"      # Niveau 0 - Document entier
+    CHAPTER = "chapter"        # Niveau 1 - Chapitre/Section principale
+    SECTION = "section"        # Niveau 2 - Sous-section
+    SUBSECTION = "subsection"  # Niveau 3 - Sous-sous-section
+    CONCEPT = "concept"        # Niveau 4 - Concept/Idée
+    DETAIL = "detail"          # Niveau 5 - Détail/Exemple
+    
+
+class ChunkRequest(BaseModel):
+    """Modèle de requête pour le chunking"""
+    text: str = Field(
+        ..., 
+        min_length=10,
+        max_length=500000,  # Limite pour Space gratuit
+        description="Texte à découper en chunks sémantiques"
+    )
+    source_id: Optional[str] = Field(
+        None,
+        description="Identifiant unique de la source"
+    )
+    titre: Optional[str] = Field(
+        None,
+        max_length=200,
+        description="Titre du document"
+    )
+    source: Optional[str] = Field(
+        None,
+        description="URL ou référence de la source"
+    )
+    type: Optional[ContentType] = Field(
+        ContentType.TEXT,
+        description="Type de contenu"
+    )
+    
+    # Paramètres de chunking optionnels
+    chunk_sizes: Optional[List[int]] = Field(
+        [2048, 512, 128],
+        description="Tailles hiérarchiques en tokens"
+    )
+    overlap_size: Optional[int] = Field(
+        20,
+        ge=0,
+        le=100,
+        description="Chevauchement entre chunks"
+    )
+    buffer_size: Optional[int] = Field(
+        None,  # Sera calculé dynamiquement
+        ge=1,
+        le=10,
+        description="Nombre de phrases par groupe (dynamique si None)"
+    )
+    breakpoint_threshold: Optional[float] = Field(
+        90.0,
+        ge=50.0,
+        le=99.0,
+        description="Seuil de similarité sémantique (percentile)"
+    )
+    include_metadata: Optional[bool] = Field(
+        True,
+        description="Inclure les métadonnées enrichies"
+    )
+    detect_structure: Optional[bool] = Field(
+        True,
+        description="Détecter automatiquement la structure (titres, sections)"
+    )
+
+    @validator('text')
+    def validate_text(cls, v):
+        if not v or not v.strip():
+            raise ValueError('Le texte ne peut pas être vide')
+        return v.strip()
+
+    # ✅ Patch pour Pydantic 2.x
+    model_config = {
+        "protected_namespaces": ()
+    }
+
+
+class ChunkMetadata(BaseModel):
+    """Métadonnées enrichies d'un chunk"""
+    chunk_id: str = Field(..., description="Identifiant unique du chunk")
+    level: int = Field(..., ge=0, le=5, description="Niveau hiérarchique (0-5)")
+    level_name: ChunkLevel = Field(..., description="Nom du niveau")
+    
+    # Relations hiérarchiques
+    parent_id: Optional[str] = Field(None, description="ID du chunk parent")
+    children_ids: List[str] = Field(default_factory=list, description="IDs des chunks enfants")
+    
+    # Relations de navigation
+    prev_id: Optional[str] = Field(None, description="ID du chunk précédent")
+    next_id: Optional[str] = Field(None, description="ID du chunk suivant")
+    
+    # Position dans le document
+    global_index: int = Field(..., ge=0, description="Position globale dans le document")
+    local_index: int = Field(..., ge=0, description="Position locale dans le niveau")
+    
+    # Informations de source
+    source_id: Optional[str] = Field(None, description="ID de la source")
+    source_title: Optional[str] = Field(None, description="Titre de la source")
+    source_url: Optional[str] = Field(None, description="URL de la source")
+    content_type: ContentType = Field(ContentType.TEXT, description="Type de contenu")
+    
+    # Métadonnées sémantiques
+    tokens_count: int = Field(..., ge=0, description="Nombre de tokens")
+    sentences_count: int = Field(..., ge=0, description="Nombre de phrases")
+    
+    # Extraction intelligente
+    detected_title: Optional[str] = Field(None, description="Titre détecté automatiquement")
+    main_concepts: List[str] = Field(default_factory=list, description="Concepts principaux extraits")
+    keywords: List[str] = Field(default_factory=list, description="Mots-clés importants")
+    
+    # Classification automatique
+    chunk_type: Optional[str] = Field(None, description="Type de chunk (concept, exemple, principe, etc.)")
+    confidence_score: Optional[float] = Field(None, ge=0.0, le=1.0, description="Score de confiance du découpage")
+    
+    # Contexte sémantique
+    contextual_summary: Optional[str] = Field(None, description="Résumé contextuel local")
+    related_chunks: List[str] = Field(default_factory=list, description="Chunks sémantiquement reliés")
+
+    # ✅ Patch pour Pydantic 2.x
+    model_config = {
+        "protected_namespaces": ()
+    }
+
+class SemanticChunk(BaseModel):
+    """Représentation d'un chunk sémantique avec sa hiérarchie"""
+    content: str = Field(..., description="Contenu textuel du chunk")
+    metadata: ChunkMetadata = Field(..., description="Métadonnées enrichies")
+    
+    # Embedding (optionnel pour économiser la bande passante)
+    embedding: Optional[List[float]] = Field(None, description="Vecteur d'embedding")
+    
+    # Relations calculées
+    similarity_scores: Dict[str, float] = Field(
+        default_factory=dict, 
+        description="Scores de similarité avec d'autres chunks"
+    )
+
+    # ✅ Patch pour Pydantic 2.x
+    model_config = {
+        "protected_namespaces": ()
+    }
+
+class HierarchyLevel(BaseModel):
+    """Représentation d'un niveau hiérarchique"""
+    level: int = Field(..., ge=0, le=5)
+    level_name: ChunkLevel
+    chunks: List[SemanticChunk]
+    total_tokens: int
+    avg_chunk_size: float
+
+    # ✅ Patch pour Pydantic 2.x
+    model_config = {
+        "protected_namespaces": ()
+    }
+
+class ChunkResponse(BaseModel):
+    """Réponse complète du chunking"""
+    # Résultat principal
+    chunks: List[SemanticChunk] = Field(..., description="Liste des chunks générés")
+    
+    # Structure hiérarchique
+    hierarchy: List[HierarchyLevel] = Field(..., description="Structure hiérarchique complète")
+    
+    # Statistiques globales
+    total_chunks: int = Field(..., ge=0, description="Nombre total de chunks")
+    total_tokens: int = Field(..., ge=0, description="Nombre total de tokens")
+    processing_time: float = Field(..., ge=0, description="Temps de traitement en secondes")
+    
+    # Informations de source
+    source_metadata: Dict[str, Any] = Field(default_factory=dict, description="Métadonnées de la source")
+    
+    # Relations découvertes
+    concept_graph: Dict[str, Any] = Field(
+        default_factory=dict, 
+        description="Graphe des concepts découverts"
+    )
+
+    
+    # Export pour Second Cerveau
+    obsidian_export: Optional[Dict[str, Any]] = Field(
+        None, 
+        description="Export formaté pour Obsidian"
+    )
+    
+    # Export pour agents spécialisés
+    agent_knowledge: Optional[Dict[str, Any]] = Field(
+        None, 
+        description="Connaissances formatées pour agents IA"
+    )
+
+    # ✅ Patch pour Pydantic 2.x
+    model_config = {
+        "protected_namespaces": ()
+    }
+
+class HealthCheckResponse(BaseModel):
+    """Réponse du health check"""
+    status: str
+    pipeline_ready: bool
+    memory_usage: Optional[Dict[str, Any]] = None
+    last_check: Optional[str] = None
+
+    # ✅ Patch pour Pydantic 2.x
+    model_config = {
+        "protected_namespaces": ()
+    }
+
+class ErrorResponse(BaseModel):
+    """Réponse d'erreur standardisée"""
+    error: str
+    detail: Optional[str] = None
+    error_code: Optional[str] = None
+    timestamp: Optional[str] = None
+
+    # ✅ Patch pour Pydantic 2.x
+    model_config = {
+        "protected_namespaces": ()
+    }