Parcourir la source

Nouvelle version fonctionnelle

augustin.podvin il y a 8 mois
Parent
commit
f0c5f46e13

+ 2 - 0
.env.example

@@ -14,6 +14,8 @@ SCW_API_KEY=
 # Vide = projet par défaut. Sinon: project_id (ex: d7d5949a-c2bb-484a-b973-e05a83510efd)
 SCW_ENDPOINT=
 SCW_MODEL=mistral-small-3.2-24b-instruct-2506
+# Optionnel : pour afficher les dépenses Scaleway sur le dashboard /developpeur (clé avec droit BillingReadOnly)
+# SCW_ORGANIZATION_ID=   # ID organisation. Si absent, SCW_ENDPOINT est utilisé comme project_id
 
 # Wiki Intersel (obligatoire pour le scraping)
 WIKI_USERNAME=

+ 113 - 0
Documents/Architecture.md

@@ -0,0 +1,113 @@
+# Architecture de l'application
+
+Documentation du conditionnement et de l'architecture du chatbot RAG (Retrieval-Augmented Generation).
+
+---
+
+## Vue d'ensemble
+
+Application Flask de **chatbot documentaire** qui répond aux questions à partir du contenu du wiki Intersel. Le flux repose sur :
+
+1. **Indexation** : scraping du wiki → découpage en chunks → embeddings → index FAISS
+2. **Requête** : question utilisateur → recherche hybride (FAISS + BM25 + rerank) → contexte + LLM → réponse
+
+---
+
+## Composants principaux
+
+| Composant | Rôle | Fichiers / modules |
+|-----------|------|--------------------|
+| **Scraping** | Récupération des pages wiki (Dokuwiki), détection des changements par hash | `src/agent_ai/scraping.py`, `src/agent_ai/auth.py` |
+| **Chunking** | Découpage sémantique du texte (phrases, overlap) | `src/agent_ai/chunking.py` |
+| **Pipeline d'indexation** | Orchestration : scrape → chunks → embeddings → FAISS | `src/utils/processing.py` |
+| **State** | État global (chunks, index FAISS, modèle d'embedding, mémoire) | `src/service/state.py` |
+| **Recherche hybride** | FAISS + BM25 + MMR (diversité) + cross-encoder (rerank) | `src/service/embedding_service.py` |
+| **Mémoire longue durée** | Stockage des Q/R passées dans un index FAISS dédié | `src/service/memory_service.py` |
+| **QA / LLM** | Vérification sécurité, construction du prompt, appel Mistral (Scaleway) | `src/service/qa_service.py` |
+| **API** | Routes Flask (chat, health, status, trigger-indexation) | `src/app.py`, `src/api/*.py` |
+
+---
+
+## Flux de données
+
+### 1. Indexation (pipeline)
+
+```
+wiki.intersel.fr (Dokuwiki)
+        │
+        ▼  scrape_pages() — session authentifiée, crawl limité (voir Choix_techniques.md)
+        │
+  raw_pages.json / page_hashes.json / urls.json
+        │
+        ▼  update_chunks() — clean_text + semantic_chunking
+        │
+  All_chunks.json (chunk_id, text, url, word_count, token_count)
+        │
+        ▼  build_and_save_index() — SentenceTransformer + FAISS (cosine)
+        │
+  faiss_index.index
+        │
+        ▼  pipeline_status.json (last_run, duration, chunk_count, scraping_stats)
+```
+
+- **Première indexation** : pas de `All_chunks.json` ni `faiss_index.index` → scrape complet, chunking, construction de l’index.
+- **Mise à jour incrémentale** : fichiers présents → scrape, mise à jour des pages modifiées (hash), reconstruction de l’index.
+
+### 2. Réponse à une question (QA)
+
+```
+Question utilisateur (POST /qa_chain)
+        │
+        ▼  quote_keywords() — spaCy, mise entre guillemets des noms/entités
+        │
+        ▼  detect_topic_smart() — similarité avec l’historique de chat
+        │
+        ▼  _is_safe_query() — LLM Scaleway (sécurité)
+        │
+        ▼  hybrid_search() — FAISS + BM25 + MMR + cross-encoder → top N chunks
+        │
+        ▼  Contexte = mémoire longue durée (topic) + chat récent (topic) + chunks
+        │
+        ▼  call_scaleway_llama3() — Mistral, réponse factuelle
+        │
+        ▼  save_memory_entry() — sauvegarde Q/R en mémoire longue durée
+        │
+  Réponse + sources (chunk_id + URL)
+```
+
+En cas d’erreur (ou contexte vide), **fallback SerpAPI** (recherche Google + résumé LLM).
+
+---
+
+## Fichiers de données (répertoire `src/data/`)
+
+| Fichier | Description |
+|---------|-------------|
+| `urls.json` | Liste des URLs wiki connues (crawl) |
+| `page_hashes.json` | Hash MD5 du contenu par URL (détection des modifications) |
+| `raw_pages.json` | Contenu brut des pages (url, text) |
+| `All_chunks.json` | Chunks avec métadonnées (chunk_id, text, url, etc.) |
+| `faiss_index.index` | Index FAISS (vecteurs normalisés, similarité cosinus) |
+| `pipeline_status.json` | Dernier run du pipeline (durée, chunk_count, erreurs, scraping_stats) |
+| `memory_chunks.json` | Entrées de la mémoire longue durée (Q/R) |
+| `faiss_memory_index.index` | Index FAISS pour la mémoire longue durée |
+
+---
+
+## Démarrage et santé
+
+- **Démarrage** : `auto_login()` (wiki), `init_memory()`, puis si `ready=False` → exécution du pipeline d’indexation et rechargement du state.
+- **Scheduler** : toutes les 24 h, `run_full_update()` (pipeline + rechargement du state).
+- **Healthcheck** : `GET /api/health` → 200 si chunks et index présents et valides, 503 sinon.
+- **Statut** : `GET /api/status` → détails du dernier pipeline (durée, chunks, scraping_stats).
+- **Indexation manuelle** : `POST /api/trigger-indexation` → lance le pipeline et recharge le state.
+
+---
+
+## Dépendances externes
+
+- **Wiki** : authentification (WIKI_USERNAME, WIKI_PASSWORD) pour le scraping.
+- **Scaleway** : API Mistral (SCW_API_KEY, SCW_ENDPOINT, SCW_MODEL) pour génération et filtre de sécurité.
+- **SerpAPI** (optionnel) : fallback en cas d’erreur ou de contexte vide (SERPAPI_API_KEY).
+
+Les choix techniques (limites, modèles, seuils) sont décrits dans **Choix_techniques.md**.

+ 114 - 0
Documents/Choix_techniques.md

@@ -0,0 +1,114 @@
+# Choix techniques et limites
+
+Documentation des décisions implicites, limites et paramètres importants de l’application.
+
+---
+
+## Scraping wiki
+
+### Limite d’URLs : 100 max
+
+- **Où** : `src/agent_ai/scraping.py`, constante `MAX_URLS_TO_SCRAPE = 100`.
+- **Effet** :
+  - Le crawl s’arrête après avoir **visité** au plus 100 URLs (pages découvertes en suivant les liens depuis la page d’accueil).
+  - La liste finale `all_urls` (anciennes URLs + URLs du crawl) est **tronquée à 100** avant d’appeler `fetch_all_pages_content`.
+- **Raison** : limiter le temps de scraping, la charge sur le wiki et la taille des données (chunks, index).
+- **Modifier** : changer la valeur de `MAX_URLS_TO_SCRAPE` dans `scraping.py` (et éventuellement documenter ici).
+
+### URLs prises en compte
+
+Une URL est valide si (`is_valid_wiki_url`) :
+
+- Domaine `wiki.intersel.fr`
+- Pas de `do=` dans la query (exclut les pages d’édition)
+- Pas d’extension `.jpg`, `.png`, `.pdf`, `.docx`, `.xlsx`
+- Pas de `#` dans l’URL
+
+### Authentification
+
+- Connexion au wiki via formulaire (token CSRF), session HTTP persistante.
+- Identifiants dans `.env` : `WIKI_USERNAME`, `WIKI_PASSWORD`.
+
+---
+
+## Indexation (chunks, FAISS)
+
+### Modèles
+
+- **Embeddings** : `sentence-transformers/all-mpnet-base-v2` (processing + state).
+- **Cross-encoder** (rerank) : `cross-encoder/ms-marco-MiniLM-L-6-v2` (state).
+- **Chunking** : découpage sémantique par phrases avec overlap (voir `src/agent_ai/chunking.py`).
+
+### Première indexation vs mise à jour incrémentale
+
+- **Première indexation** : aucun fichier `All_chunks.json` ou `faiss_index.index` → scrape (limité à 100 URLs), chunking complet, construction de l’index.
+- **Mise à jour incrémentale** : fichiers présents → scrape, mise à jour uniquement des pages dont le hash a changé, puis reconstruction de l’index.
+
+---
+
+## QA (questions / réponses)
+
+### LLM
+
+- **API** : Scaleway (compatible OpenAI), modèle par défaut `mistral-small-3.2-24b-instruct-2506`.
+- **Variables** : `SCW_API_KEY`, `SCW_ENDPOINT` (optionnel), `SCW_MODEL`.
+
+### Recherche hybride
+
+- **FAISS** : top 200 candidats (paramètre `top_k_candidates`).
+- **BM25** : pondération selon la longueur de la requête (courte → 0.7, etc.).
+- **MMR** : diversité des chunks (éviter le doublon), lambda 0.7.
+- **Cross-encoder** : rerank des passages, score final = 0.4 × hybride + 0.6 × cross-encoder.
+- **Top final** : 20 chunks envoyés au LLM.
+
+### Topic / mémoire
+
+- **Détection de topic** : similarité (embedding) avec l’historique de chat ; seuil 0.7 pour réutiliser un topic existant.
+- **Mémoire longue durée** : Q/R sauvegardées dans un index FAISS séparé ; récupération des plus pertinentes (top_k=20) puis filtrage par topic pour le contexte.
+
+### Sécurité
+
+- Chaque question passe par un **filtre de sécurité** (LLM) : refus si contenu sensible ou malveillant (mot de passe, carte bancaire, hacking, etc.).
+
+### Fallback
+
+- Si erreur ou contexte vide : recherche **SerpAPI** (Google) + résumé par le LLM. Nécessite `SERPAPI_API_KEY` (optionnel).
+
+---
+
+## API et configuration
+
+### Routes documentées
+
+- `GET /api/health` : santé (chunks + index chargés) → 200 ou 503.
+- `GET /api/status` : statut détaillé du pipeline (dernier run, durée, chunk_count, scraping_stats).
+- `POST /api/trigger-indexation` : lancement manuel du pipeline + rechargement du state.
+
+### Limites côté app
+
+- **Taille max payload** : 16 Mo (`MAX_CONTENT_LENGTH`).
+- **Longueur max message chat** : 2000 caractères (`CHAT_MAX_CHARS`).
+- **Anti-spam** : message vide, répétition de caractères (≥ 50), trop d’URLs (≥ 5) → rejet.
+
+---
+
+## Scheduler
+
+- **Intervalle** : 24 h (APScheduler, `run_full_update`).
+- **Verrou** : une seule exécution du pipeline à la fois (`update_lock`).
+
+---
+
+## Résumé des constantes à connaître
+
+| Élément | Valeur / emplacement |
+|--------|----------------------|
+| URLs max à scraper | 100 — `scraping.py` → `MAX_URLS_TO_SCRAPE` |
+| Workers scraping | 2 — `ThreadPoolExecutor(max_workers=2)` |
+| Top candidats recherche | 200 — `embedding_service.py` → `top_k_candidates` |
+| Top chunks final | 20 — `top_k_final` |
+| Seuil topic | 0.7 — `qa_service.py` → `detect_topic_smart` |
+| MMR lambda | 0.7 — `embedding_service.py` → `mmr_lambda` |
+| Intervalle scheduler | 24 h — `app.py` → `scheduler.add_job(..., hours=24)` |
+
+Pour l’architecture globale et le conditionnement de l’application, voir **Architecture.md**.

+ 4 - 0
README.md

@@ -20,6 +20,10 @@ docker-compose up --build
 
 L'application sera accessible sur http://localhost:5000
 
+## Dashboard développeur
+
+La page **/developpeur** affiche le monitoring (santé, pipeline, scraping, mémoire, config). Elle peut aussi afficher les **dépenses API Scaleway** du mois en cours : définir `SCW_ORGANIZATION_ID` dans le `.env` (ou utiliser `SCW_ENDPOINT` comme project_id) et s'assurer que la clé API a le droit **BillingReadOnly** dans la console Scaleway.
+
 ## Lancement en local (sans Docker, pour le debug)
 
 ```powershell

+ 1 - 1
install_local.ps1

@@ -44,6 +44,6 @@ pip install python-magic-bin
 # 4. Post-install: spaCy + NLTK
 Write-Host "`n4. Modèle spaCy + NLTK..." -ForegroundColor Cyan
 python -m spacy download fr_core_news_sm
-python -c "import nltk; nltk.download('punkt')"
+python -c "import nltk; nltk.download('punkt'); nltk.download('punkt_tab')"
 
 Write-Host "`nTerminé. Lancez: .\run_local.ps1" -ForegroundColor Green

+ 1 - 1
setup_venv.ps1

@@ -57,7 +57,7 @@ pip install python-magic-bin
 # 6. Post-install: spaCy + NLTK
 Write-Host "`n4. Modèle spaCy + NLTK..." -ForegroundColor Cyan
 python -m spacy download fr_core_news_sm
-python -c "import nltk; nltk.download('punkt')"
+python -c "import nltk; nltk.download('punkt'); nltk.download('punkt_tab')"
 
 Write-Host "`n=== Installation terminée ===" -ForegroundColor Green
 Write-Host "Pour lancer l'app: .\run_local.ps1" -ForegroundColor Green

+ 2 - 1
src/agent_ai/chunking.py

@@ -5,7 +5,8 @@ import tiktoken
 import numpy as np
 from typing import List
 
-nltk.download('punkt')
+nltk.download('punkt', quiet=True)
+nltk.download('punkt_tab', quiet=True)
 
 tokenizer = tiktoken.get_encoding("cl100k_base")
 model = SentenceTransformer('sentence-transformers/all-mpnet-base-v2')

+ 15 - 5
src/agent_ai/scraping.py

@@ -14,6 +14,9 @@ data_dir = os.path.join(base_dir, 'data')
 BASE_URL = "https://wiki.intersel.fr/"
 VISITED = set()
 
+# Nombre maximum d'URLs à scraper (crawl + fetch). Voir Documents/Choix_techniques.md.
+MAX_URLS_TO_SCRAPE = 15
+
 USER_AGENTS = [
     "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/115.0.0.0 Safari/537.36"
 ]
@@ -93,7 +96,7 @@ def crawl_wiki(start_url, existing_urls):
     visited = set(existing_urls)
     to_visit = [start_url]
 
-    while to_visit:  # plus de limite sur la taille de visited
+    while to_visit and len(visited) < MAX_URLS_TO_SCRAPE:
         current_url = to_visit.pop(0)
         if current_url in visited:
             continue
@@ -143,11 +146,11 @@ def scrape_pages():
         print("🚀 Crawling initial du wiki")
         urls = []
 
-    # Nouveau crawl
+    # Nouveau crawl (limité à MAX_URLS_TO_SCRAPE)
     crawled_urls = crawl_wiki(start_url, urls)
-    all_urls = sorted(set(urls + crawled_urls))
+    all_urls = sorted(set(urls + crawled_urls))[:MAX_URLS_TO_SCRAPE]
 
-    print(f"🌐 Total URLs à vérifier : {len(all_urls)}")
+    print(f"🌐 Total URLs à vérifier (max {MAX_URLS_TO_SCRAPE}) : {len(all_urls)}")
 
     # Scraping des pages
     pages, new_hashes = fetch_all_pages_content(all_urls, old_hashes)
@@ -184,4 +187,11 @@ def scrape_pages():
     print(f"🔗 URLs enregistrées dans '{urls_path}'")
     print(f"🔐 Hashes des pages enregistrés dans '{hashes_path}'")
 
-    return [{"url": url, "text": text} for url, text in cleaned_raw_pages.items()]
+    pages_list = [{"url": url, "text": text} for url, text in cleaned_raw_pages.items()]
+    failed_urls = [u for u in all_urls if u not in cleaned_raw_pages]
+    stats = {
+        "total_urls": len(all_urls),
+        "pages_with_content": len(cleaned_raw_pages),
+        "failed_urls": failed_urls,
+    }
+    return pages_list, stats

+ 43 - 0
src/api/admin_routes.py

@@ -0,0 +1,43 @@
+# admin_routes.py
+"""Routes admin : trigger indexation. Health et status sont définis dans app.py."""
+import logging
+from flask import Blueprint, jsonify
+from src.utils.processing import full_update_pipeline, update_lock
+
+logger = logging.getLogger(__name__)
+admin_blueprint = Blueprint("admin", __name__)
+
+
+@admin_blueprint.route("/trigger-indexation", methods=["POST"])
+def trigger_indexation():
+    """
+    Déclenche manuellement le pipeline d'indexation.
+    Recharge le state après exécution.
+    """
+    if update_lock.locked():
+        return jsonify({
+            "error": "Une indexation est déjà en cours.",
+            "status": "running",
+        }), 409
+
+    try:
+        result = full_update_pipeline()
+
+        # Recharger le state dans l'app
+        from src.service.state import state, load_chunks_and_index
+        state["all_chunks"], state["index"] = load_chunks_and_index()
+
+        return jsonify({
+            "status": "success",
+            "mode": result.get("mode"),
+            "duration_seconds": result.get("duration_seconds"),
+            "chunk_count": result.get("chunk_count"),
+            "scraping_stats": result.get("scraping_stats"),
+            "error": result.get("error"),
+        }), 200
+    except Exception as e:
+        logger.exception("Erreur lors du trigger indexation: %s", e)
+        return jsonify({
+            "status": "error",
+            "error": str(e),
+        }), 500

+ 68 - 3
src/app.py

@@ -1,5 +1,4 @@
 from dotenv import load_dotenv
-from src.utils.processing import full_update_pipeline
 from flask import Flask, jsonify, render_template, request, abort
 from apscheduler.schedulers.background import BackgroundScheduler
 import logging
@@ -7,11 +6,13 @@ from flask_cors import CORS
 import os
 
 from src.service.memory_service import init_memory
-from src.utils.processing import run_full_update
+from src.utils.processing import run_full_update, full_update_pipeline, get_pipeline_status
+from src.service.state import state, load_chunks_and_index
+from src.service.scaleway_billing_service import get_scaleway_consumption
 from src.api.qa_routes import qa_blueprint
 from src.api.file_routes import file_blueprint
+from src.api.admin_routes import admin_blueprint
 from src.service.auth_service import auto_login
-from src.service.state import state
 from src.api.routes import main
 from src.models import db
 
@@ -51,12 +52,65 @@ def create_app():
     app.register_blueprint(qa_blueprint)
     app.register_blueprint(file_blueprint, url_prefix="/api")
     app.register_blueprint(main, url_prefix="/api")
+    app.register_blueprint(admin_blueprint, url_prefix="/api")
+
+    # Routes admin (health, status, trigger-indexation) - aussi sur blueprint pour cohérence
+    @app.route("/api/health", methods=["GET"])
+    def health():
+        """Healthcheck : chunks et index chargés ?"""
+        status = get_pipeline_status()
+        http_status = 200 if status.get("ready") else 503
+        return jsonify({
+            "ready": status["ready"],
+            "chunk_count": status.get("chunk_count", 0),
+            "message": "Application prête" if status["ready"] else "Indexation requise (chunks ou index manquants)",
+        }), http_status
+
+    @app.route("/api/status", methods=["GET"])
+    def pipeline_status():
+        """Statut détaillé du pipeline."""
+        return jsonify(get_pipeline_status()), 200
+
+    @app.route("/api/dashboard", methods=["GET"])
+    def dashboard():
+        """Données agrégées pour la page Développeur (monitoring)."""
+        pipeline = get_pipeline_status()
+        return jsonify({
+            "health": {
+                "ready": pipeline.get("ready", False),
+                "chunk_count": pipeline.get("chunk_count", 0),
+                "message": "Application prête" if pipeline.get("ready") else "Indexation requise",
+            },
+            "pipeline": {
+                "last_run": pipeline.get("last_run"),
+                "duration_seconds": pipeline.get("duration_seconds"),
+                "mode": pipeline.get("mode"),
+                "error": pipeline.get("error"),
+                "scraping_stats": pipeline.get("scraping_stats"),
+            },
+            "memory": {
+                "entries_count": len(state.get("memory_chunks", [])),
+            },
+            "chat": {
+                "history_count": len(state.get("chat_history", [])),
+            },
+            "config": {
+                "scw_api_set": bool(os.getenv("SCW_API_KEY")),
+                "wiki_username_set": bool(os.getenv("WIKI_USERNAME")),
+                "wiki_password_set": bool(os.getenv("WIKI_PASSWORD")),
+            },
+            "scaleway_billing": get_scaleway_consumption() or {},
+        }), 200
 
     # Routes
     @app.route("/")
     def home():
         return render_template("index.html")
 
+    @app.route("/developpeur")
+    def developpeur():
+        return render_template("developpeur.html")
+
     @app.route("/register")
     def register():
         return render_template("register.html")
@@ -79,6 +133,17 @@ if __name__ == "__main__":
     auto_login()
     init_memory()
 
+    # Indexation au démarrage si chunks/index manquants (healthcheck)
+    status = get_pipeline_status()
+    if not status.get("ready"):
+        logger.info("Indexation manquante : lancement du pipeline au démarrage...")
+        try:
+            full_update_pipeline()
+            state["all_chunks"], state["index"] = load_chunks_and_index()
+            logger.info("State chargé après indexation initiale (%d chunks).", len(state.get("all_chunks", [])))
+        except Exception as e:
+            logger.error("Échec indexation au démarrage : %s", e)
+
     # Scheduler for periodic tasks
     scheduler = BackgroundScheduler()
     scheduler.add_job(run_full_update, "interval", hours=24)

+ 2 - 1
src/service/evaluation_service.py

@@ -18,7 +18,8 @@ import ast
 
 # ---- Init ----
 load_dotenv(override=True)
-nltk.download('punkt')
+nltk.download('punkt', quiet=True)
+nltk.download('punkt_tab', quiet=True)
 
 # ---- Embedding model ----
 embedding_model = SentenceTransformer('sentence-transformers/all-roberta-large-v1')

+ 17 - 3
src/service/qa_service.py

@@ -243,6 +243,14 @@ def process_question(question: str) -> Tuple[Dict[str, Any], int]:
         all_chunks = state.get("all_chunks", [])
         if not all_chunks:
             logger.warning("No chunks found in state; using empty context.")
+            interaction["latency"] = round(time.time() - start_time, 4)
+            msg = (
+                "Aucune base documentaire chargée. Lancez l'indexation du wiki pour pouvoir poser des questions.\n\n"
+                "• En ligne de commande : POST /api/trigger-indexation\n"
+                "• Ou redémarrez l'application (l'indexation se lance au démarrage si les fichiers sont absents).\n\n"
+                "Vérifiez que WIKI_USERNAME et WIKI_PASSWORD sont renseignés dans le fichier .env."
+            )
+            return {"answer": msg, "interaction": interaction}, 200
         state["chunk_urls"] = [
             chunk.get("url", "URL inconnue") if isinstance(chunk, dict) else "URL inconnue"
             for chunk in all_chunks
@@ -308,9 +316,15 @@ def process_question(question: str) -> Tuple[Dict[str, Any], int]:
 
         prompt = (
             "Réponds en français, de manière factuelle, structurée et précise, "
-            "en te basant uniquement sur le contexte fourni. "
-            "Indique l'identifiant exact du chunk utilisé entre crochets. "
-            "Ne fais aucune supposition non justifiée et indique les données manquantes.\n\n"
+            "en te basant uniquement sur le contexte fourni (extraits du wiki Intersel). "
+            "Indique l'identifiant exact du chunk utilisé entre crochets quand tu t'appuies sur un passage.\n\n"
+            "Règles importantes :\n"
+            "- Si le contexte ne contient aucune information pertinente pour répondre à la question, "
+            "réponds uniquement : « D'après le contexte fourni (wiki Intersel), il n'y a pas d'information "
+            "permettant de répondre à cette question. » Puis liste éventuellement les thèmes ou types de documents "
+            "qui manqueraient (ex. : documentation sur les CMS, les technologies utilisées, etc.).\n"
+            "- Ne mentionne jamais de clé API, d'erreur technique, de modèle ou de problème d'accès comme « données manquantes ».\n"
+            "- Ne fais aucune supposition non justifiée.\n\n"
             f"{memory_section}{recent_context}{top_context}\n\nQuestion : {corrected_question}"
         )
         interaction["steps"].append({"step": "prompt_creation", "details": "Prompt generated for Llama3"})

+ 117 - 0
src/service/scaleway_billing_service.py

@@ -0,0 +1,117 @@
+# scaleway_billing_service.py
+"""Récupération des dépenses Scaleway (API Billing) pour affichage dashboard."""
+
+import os
+import logging
+from datetime import datetime
+from typing import Optional
+
+import requests
+
+logger = logging.getLogger(__name__)
+
+SCW_BILLING_URL = "https://api.scaleway.com/billing/v2beta1/consumptions"
+
+
+def _money_to_euro(amount: dict) -> float:
+    """Convertit un objet Money (units + nanos) en montant EUR."""
+    if not amount:
+        return 0.0
+    units = int(amount.get("units", 0) or 0)
+    nanos = int(amount.get("nanos", 0) or 0)
+    return units + (nanos / 1_000_000_000)
+
+
+def get_scaleway_consumption(
+    billing_period: Optional[str] = None,
+) -> Optional[dict]:
+    """
+    Appelle l'API Billing Scaleway pour le mois courant (ou billing_period YYYY-MM).
+    Retourne un dict avec total_eur, currency, consumptions (liste par catégorie), error.
+    Retourne None si la config (clé API + organization_id ou project_id) n'est pas disponible.
+    """
+    secret_key = os.getenv("SCW_API_KEY") or os.getenv("SCW_SECRET_KEY")
+    org_id = os.getenv("SCW_ORGANIZATION_ID", "").strip()
+    project_id = os.getenv("SCW_ENDPOINT", "").strip()
+    if project_id.lower() == "default":
+        project_id = ""
+
+    if not secret_key:
+        return None
+
+    params = {}
+    if org_id:
+        params["organization_id"] = org_id
+    elif project_id:
+        params["project_id"] = project_id
+    else:
+        # Pas d'org ni de project : on ne peut pas appeler l'API
+        return None
+
+    if billing_period:
+        params["billing_period"] = billing_period
+    # Sinon pas de billing_period = mois courant
+
+    try:
+        r = requests.get(
+            SCW_BILLING_URL,
+            headers={
+                "X-Auth-Token": secret_key,
+                "Content-Type": "application/json",
+            },
+            params=params,
+            timeout=10,
+        )
+        r.raise_for_status()
+        data = r.json()
+    except requests.RequestException as e:
+        logger.warning("Scaleway Billing API error: %s", e)
+        return {
+            "total_eur": None,
+            "currency": "EUR",
+            "consumptions": [],
+            "error": str(e),
+            "period": billing_period or _current_month(),
+        }
+    except Exception as e:
+        logger.exception("Unexpected error fetching Scaleway billing")
+        return {
+            "total_eur": None,
+            "currency": "EUR",
+            "consumptions": [],
+            "error": str(e),
+            "period": billing_period or _current_month(),
+        }
+
+    consumptions = data.get("consumptions") if isinstance(data, dict) else []
+    if not isinstance(consumptions, list):
+        consumptions = []
+
+    total_eur = 0.0
+    items = []
+    for c in consumptions:
+        if not isinstance(c, dict):
+            continue
+        amount = c.get("total_amount") or c.get("amount") or c.get("total_untaxed") or {}
+        value = _money_to_euro(amount)
+        total_eur += value
+        category = c.get("category_name") or c.get("category") or "Autre"
+        items.append({"category": category, "amount_eur": round(value, 2)})
+
+    # Fallback: total à la racine (certaines réponses d'API)
+    if total_eur == 0 and isinstance(data, dict):
+        root_total = data.get("total_amount") or data.get("total_untaxed")
+        if root_total:
+            total_eur = _money_to_euro(root_total)
+
+    return {
+        "total_eur": round(total_eur, 2),
+        "currency": "EUR",
+        "consumptions": items,
+        "error": None,
+        "period": billing_period or _current_month(),
+    }
+
+
+def _current_month() -> str:
+    return datetime.utcnow().strftime("%Y-%m")

+ 234 - 0
src/templates/developpeur.html

@@ -0,0 +1,234 @@
+<!DOCTYPE html>
+<html lang="fr">
+<head>
+  <meta charset="UTF-8" />
+  <meta name="viewport" content="width=device-width, initial-scale=1" />
+  <title>Développeur – Monitoring</title>
+  <link rel="stylesheet" href="https://fonts.googleapis.com/css2?family=Inter:wght@400;600&display=swap" />
+  <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/font-awesome/6.5.0/css/all.min.css" />
+  <style>
+    * { box-sizing: border-box; }
+    body {
+      margin: 0;
+      font-family: 'Inter', sans-serif;
+      background: #f4f6f8;
+      color: #333;
+      min-height: 100vh;
+    }
+    .header {
+      background: #07468f;
+      color: white;
+      padding: 1rem 1.5rem;
+      display: flex;
+      justify-content: space-between;
+      align-items: center;
+    }
+    .header h1 { margin: 0; font-size: 1.35rem; }
+    .header a {
+      color: rgba(255,255,255,0.9);
+      text-decoration: none;
+      font-size: 0.95rem;
+    }
+    .header a:hover { text-decoration: underline; }
+    .main {
+      max-width: 900px;
+      margin: 0 auto;
+      padding: 1.5rem;
+    }
+    .toolbar {
+      display: flex;
+      gap: 0.75rem;
+      margin-bottom: 1.5rem;
+    }
+    .btn {
+      padding: 0.5rem 1rem;
+      border: none;
+      border-radius: 8px;
+      cursor: pointer;
+      font-weight: 600;
+      font-size: 0.9rem;
+    }
+    .btn-primary { background: #07468f; color: white; }
+    .btn-primary:hover { background: #053a75; }
+    .btn-secondary { background: #e0e0e0; color: #333; }
+    .btn-secondary:hover { background: #d0d0d0; }
+    .btn:disabled { opacity: 0.6; cursor: not-allowed; }
+    .card {
+      background: white;
+      border-radius: 10px;
+      box-shadow: 0 1px 4px rgba(0,0,0,0.08);
+      padding: 1.25rem;
+      margin-bottom: 1rem;
+    }
+    .card h2 {
+      margin: 0 0 0.75rem 0;
+      font-size: 1.1rem;
+      color: #07468f;
+      display: flex;
+      align-items: center;
+      gap: 0.5rem;
+    }
+    .status-row { display: flex; align-items: center; gap: 0.5rem; margin: 0.35rem 0; }
+    .badge {
+      display: inline-block;
+      padding: 0.2rem 0.5rem;
+      border-radius: 6px;
+      font-size: 0.8rem;
+      font-weight: 600;
+    }
+    .badge-ok { background: #d4edda; color: #155724; }
+    .badge-warn { background: #fff3cd; color: #856404; }
+    .badge-error { background: #f8d7da; color: #721c24; }
+    .mono { font-family: ui-monospace, monospace; font-size: 0.9rem; }
+    .message { margin-top: 0.75rem; padding: 0.75rem; background: #f8f9fa; border-radius: 6px; font-size: 0.9rem; }
+    #loading { text-align: center; padding: 2rem; color: #666; }
+    #error { color: #c00; margin-bottom: 1rem; }
+    .scraping-table { width: 100%; border-collapse: collapse; font-size: 0.9rem; }
+    .scraping-table th, .scraping-table td { padding: 0.4rem 0.5rem; text-align: left; }
+    .scraping-table th { color: #555; }
+  </style>
+</head>
+<body>
+  <div class="header">
+    <h1><i class="fas fa-tools"></i> Développeur – Monitoring</h1>
+    <a href="/"><i class="fas fa-arrow-left"></i> Retour au chat</a>
+  </div>
+  <div class="main">
+    <div class="toolbar">
+      <button class="btn btn-secondary" id="btnRefresh" title="Rafraîchir"><i class="fas fa-sync-alt"></i> Rafraîchir</button>
+      <button class="btn btn-primary" id="btnIndexation" title="Lancer l'indexation"><i class="fas fa-database"></i> Lancer l'indexation</button>
+    </div>
+    <div id="error"></div>
+    <div id="content">
+      <div id="loading">Chargement du statut…</div>
+    </div>
+  </div>
+  <script>
+    const content = document.getElementById('content');
+    const errEl = document.getElementById('error');
+    const btnRefresh = document.getElementById('btnRefresh');
+    const btnIndexation = document.getElementById('btnIndexation');
+
+    function showError(msg) {
+      errEl.textContent = msg;
+      errEl.style.display = msg ? 'block' : 'none';
+    }
+
+    function render(d) {
+      const health = d.health || {};
+      const pipeline = d.pipeline || {};
+      const memory = d.memory || {};
+      const chat = d.chat || {};
+      const config = d.config || {};
+      const scraping = pipeline.scraping_stats || {};
+      const billing = d.scaleway_billing || {};
+
+      const ready = health.ready;
+      content.innerHTML = `
+        <div class="card">
+          <h2><i class="fas fa-heartbeat"></i> Santé (healthcheck)</h2>
+          <div class="status-row">
+            <span class="badge ${ready ? 'badge-ok' : 'badge-error'}">${ready ? 'Prêt' : 'Non prêt'}</span>
+            <span>Chunks indexés : <strong>${health.chunk_count ?? 0}</strong></span>
+            <span class="mono" style="font-size:0.8rem; color:#666;">(index FAISS)</span>
+          </div>
+          <div class="message">${health.message || '-'}</div>
+        </div>
+        <div class="card">
+          <h2><i class="fas fa-cogs"></i> Pipeline – Métadonnées</h2>
+          <div class="status-row">Dernière exécution : <span class="mono">${pipeline.last_run || 'Jamais'}</span></div>
+          <div class="status-row">Durée totale : <span>${pipeline.duration_seconds != null ? pipeline.duration_seconds + ' s' : '-'}</span></div>
+          <div class="status-row">Mode : <span class="mono">${pipeline.mode || '-'}</span></div>
+          ${pipeline.error ? `<div class="status-row"><span class="badge badge-error">Erreur</span> <span>${pipeline.error}</span></div>` : ''}
+        </div>
+        <div class="card">
+          <h2><i class="fas fa-spider"></i> Étape 1 – Scraping (crawl)</h2>
+          ${scraping.total_urls != null ? `
+          <table class="scraping-table">
+            <tr><th>total_urls</th><td>${scraping.total_urls}</td></tr>
+            <tr><th>pages_with_content</th><td>${scraping.pages_with_content ?? '-'}</td></tr>
+            <tr><th>failed_urls</th><td>${(scraping.failed_urls && scraping.failed_urls.length) || 0}</td></tr>
+          </table>
+          ` : '<div class="message">Aucune donnée (indexation non exécutée)</div>'}
+        </div>
+        <div class="card">
+          <h2><i class="fas fa-puzzle-piece"></i> Étape 2 – Chunking (sémantique)</h2>
+          <div class="status-row">Chunks produits : <strong>${health.chunk_count ?? 0}</strong></div>
+          <div class="message" style="font-size:0.85rem;">Découpage par similarité sémantique (NLTK + SentenceTransformer)</div>
+        </div>
+        <div class="card">
+          <h2><i class="fas fa-vector-square"></i> Étape 3 – Embeddings & index FAISS</h2>
+          <div class="status-row">Vecteurs (embeddings) : <strong>${health.chunk_count ?? 0}</strong></div>
+          <div class="message" style="font-size:0.85rem;">all-mpnet-base-v2 → IndexFlatIP (cosine similarity)</div>
+        </div>
+        <div class="card">
+          <h2><i class="fas fa-memory"></i> Mémoire & Chat</h2>
+          <div class="status-row">Mémoire longue durée : <strong>${memory.entries_count ?? 0}</strong> entrées</div>
+          <div class="status-row">Historique chat (session) : <strong>${chat.history_count ?? 0}</strong> échanges</div>
+        </div>
+        <div class="card">
+          <h2><i class="fas fa-euro-sign"></i> Dépenses API Scaleway</h2>
+          ${Object.keys(billing).length ? `
+          <div class="status-row">Période : <strong>${billing.period || 'Mois courant'}</strong></div>
+          ${billing.error ? `<div class="status-row"><span class="badge badge-warn">Erreur API</span> <span>${billing.error}</span></div>` : ''}
+          ${billing.total_eur != null && !billing.error ? `
+          <div class="status-row">Total mois : <strong>${billing.total_eur.toFixed(2)} ${billing.currency || 'EUR'}</strong></div>
+          ${(billing.consumptions && billing.consumptions.length) ? `
+          <table class="scraping-table" style="margin-top:0.5rem;">
+            <tr><th>Catégorie</th><th>Montant</th></tr>
+            ${billing.consumptions.map(c => `<tr><td>${c.category}</td><td>${c.amount_eur != null ? c.amount_eur.toFixed(2) + ' €' : '-'}</td></tr>`).join('')}
+          </table>
+          ` : ''}
+          ` : `
+          <div class="message">Définir <span class="mono">SCW_ORGANIZATION_ID</span> (ou utiliser <span class="mono">SCW_ENDPOINT</span> comme project_id) et une clé API avec droit <strong>BillingReadOnly</strong> pour afficher les dépenses.</div>
+          `}
+        </div>
+        <div class="card">
+          <h2><i class="fas fa-key"></i> Configuration (.env)</h2>
+          <div class="status-row"><span class="badge ${config.scw_api_set ? 'badge-ok' : 'badge-warn'}">SCW_API_KEY</span> ${config.scw_api_set ? 'Défini' : 'Non défini'}</div>
+          <div class="status-row"><span class="badge ${config.wiki_username_set ? 'badge-ok' : 'badge-warn'}">WIKI_USERNAME</span> ${config.wiki_username_set ? 'Défini' : 'Non défini'}</div>
+          <div class="status-row"><span class="badge ${config.wiki_password_set ? 'badge-ok' : 'badge-warn'}">WIKI_PASSWORD</span> ${config.wiki_password_set ? 'Défini' : 'Non défini'}</div>
+        </div>
+      `;
+    }
+
+    async function load() {
+      showError('');
+      content.innerHTML = '<div id="loading">Chargement du statut…</div>';
+      try {
+        const r = await fetch('/api/dashboard');
+        if (!r.ok) throw new Error('Erreur ' + r.status);
+        const data = await r.json();
+        render(data);
+      } catch (e) {
+        showError('Impossible de charger le dashboard : ' + e.message);
+        content.innerHTML = '';
+      }
+    }
+
+    btnRefresh.addEventListener('click', load);
+
+    btnIndexation.addEventListener('click', async () => {
+      btnIndexation.disabled = true;
+      showError('');
+      try {
+        const r = await fetch('/api/trigger-indexation', { method: 'POST' });
+        const data = await r.json().catch(() => ({}));
+        if (r.status === 409) {
+          showError('Une indexation est déjà en cours.');
+        } else if (!r.ok) {
+          showError(data.error || 'Erreur ' + r.status);
+        } else {
+          showError('');
+          await load();
+        }
+      } catch (e) {
+        showError('Erreur : ' + e.message);
+      }
+      btnIndexation.disabled = false;
+    });
+
+    load();
+  </script>
+</body>
+</html>

+ 2 - 1
src/templates/index.html

@@ -365,8 +365,9 @@
   <div class="chat-container">
     <div class="chat-header">📎 Chatbot Documentaire</div>
 <div class="header-buttons">
+  <a href="/developpeur" class="theme-toggle" title="Monitoring développeur" style="text-decoration:none;color:inherit;font-size:0.9rem;">🔧 Dev</a>
   <button class="theme-toggle" id="themeToggle" title="Changer de thème">🌙</button>
-<button class="fas fa-user-alt" id="signupBtn" title="Créer un compte" onclick="window.location.href='/register';"></button>
+  <button class="fas fa-user-alt" id="signupBtn" title="Créer un compte" onclick="window.location.href='/register';"></button>
 </div>
 
     <div class="chat-body">

+ 157 - 25
src/utils/processing.py

@@ -1,6 +1,7 @@
 import os
 import json
 import re
+import time
 import faiss
 import numpy as np
 from sentence_transformers import SentenceTransformer
@@ -8,6 +9,7 @@ from src.agent_ai.chunking import semantic_chunking
 from src.agent_ai.scraping import scrape_pages
 from threading import Lock
 import logging
+from datetime import datetime
 
 logging.basicConfig(level=logging.DEBUG, format='%(asctime)s - %(levelname)s - %(message)s')
 logger = logging.getLogger(__name__)
@@ -23,6 +25,7 @@ os.makedirs(data_dir, exist_ok=True)
 CHUNKS_FILE = os.path.join(data_dir, "All_chunks.json")
 INDEX_FILE = os.path.join(data_dir, "faiss_index.index")
 RAW_PAGES_FILE = os.path.join(data_dir, "raw_pages.json")
+PIPELINE_STATUS_FILE = os.path.join(data_dir, "pipeline_status.json")
 
 # === Embedding Model ===
 #model = SentenceTransformer('sentence-transformers/all-roberta-large-v1')
@@ -121,43 +124,172 @@ def build_and_save_index(chunks):
     return index
 
 
-# === Full Pipeline ===
-
-def full_update_pipeline():
-    print("🔄 Pipeline complet déclenché...")
-
-    if os.path.exists(CHUNKS_FILE):
-        print("📄 Fichier de chunks trouvé. Chargement en cours...")
+# === Pipeline status (logs & monitoring) ===
+
+def _load_pipeline_status():
+    """Charge le statut du dernier pipeline depuis le fichier."""
+    if not os.path.exists(PIPELINE_STATUS_FILE):
+        return {
+            "last_run": None,
+            "duration_seconds": None,
+            "chunk_count": 0,
+            "mode": None,
+            "error": None,
+            "scraping_stats": None,
+            "ready": False,
+        }
+    try:
+        with open(PIPELINE_STATUS_FILE, "r", encoding="utf-8") as f:
+            return json.load(f)
+    except Exception as e:
+        logger.warning("Impossible de charger pipeline_status.json: %s", e)
+        return {"last_run": None, "duration_seconds": None, "chunk_count": 0, "error": str(e), "ready": False}
+
+
+def _save_pipeline_status(status: dict):
+    """Sauvegarde le statut du pipeline (durée, chunks, erreurs)."""
+    try:
+        with open(PIPELINE_STATUS_FILE, "w", encoding="utf-8") as f:
+            json.dump(status, f, ensure_ascii=False, indent=2)
+    except Exception as e:
+        logger.warning("Impossible de sauvegarder pipeline_status.json: %s", e)
+
+
+def get_pipeline_status():
+    """Retourne le statut du pipeline (pour /api/status). Met à jour 'ready' selon l'état actuel."""
+    status = _load_pipeline_status()
+    chunks_ok = os.path.exists(CHUNKS_FILE) and os.path.getsize(CHUNKS_FILE) > 2
+    index_ok = os.path.exists(INDEX_FILE) and os.path.getsize(INDEX_FILE) > 0
+    status["ready"] = bool(chunks_ok and index_ok)
+    return status
+
+
+# === Première indexation (aucun chunk/index existant) ===
+
+def _run_first_indexation() -> dict:
+    """
+    Première indexation complète : scrape tout le wiki, chunk, build index.
+    Appelée quand All_chunks.json et faiss_index.index n'existent pas.
+    """
+    logger.info("🔄 Première indexation : scraping complet du wiki...")
+    pages_list, scraping_stats = scrape_pages()
+    page_dict = {p["url"]: p["text"] for p in pages_list if "url" in p and "text" in p}
+
+    if not page_dict:
+        return {
+            "mode": "first_indexation",
+            "error": "Aucune page récupérée lors du scraping.",
+            "scraping_stats": scraping_stats,
+            "chunk_count": 0,
+        }
+
+    chunks = update_chunks(page_dict)
+    build_and_save_index(chunks)
+    return {
+        "mode": "first_indexation",
+        "error": None,
+        "scraping_stats": scraping_stats,
+        "chunk_count": len(chunks),
+    }
+
+
+# === Mise à jour incrémentale (chunks/index déjà présents) ===
+
+def _run_incremental_update() -> dict:
+    """
+    Mise à jour incrémentale : scrape, détecte les pages modifiées (hash),
+    met à jour uniquement les chunks concernés, reconstruit l'index.
+    """
+    logger.info("🔄 Mise à jour incrémentale : détection des pages modifiées...")
+    pages_list, scraping_stats = scrape_pages()
+    page_dict = {p["url"]: p["text"] for p in pages_list if "url" in p and "text" in p}
+
+    # Même si aucune page modifiée, on garde les chunks existants
+    if not page_dict:
         chunks = load_chunks_from_file()
+        return {
+            "mode": "incremental_update",
+            "error": None,
+            "scraping_stats": scraping_stats,
+            "chunk_count": len(chunks),
+            "pages_updated": 0,
+        }
+
+    chunks = update_chunks(page_dict)
+    build_and_save_index(chunks)
+    return {
+        "mode": "incremental_update",
+        "error": None,
+        "scraping_stats": scraping_stats,
+        "chunk_count": len(chunks),
+        "pages_updated": len(page_dict),
+    }
+
+
+# === Pipeline unifié ===
+
+def full_update_pipeline() -> dict:
+    """
+    Pipeline unifié : distingue clairement première indexation vs mise à jour incrémentale.
+    Retourne un dict avec mode, durée, chunk_count, erreurs, scraping_stats.
+    """
+    start = time.time()
+    chunks_exist = os.path.exists(CHUNKS_FILE)
+    index_exists = os.path.exists(INDEX_FILE)
+
+    if not chunks_exist or not index_exists:
+        result = _run_first_indexation()
     else:
-        print("🕸️ Aucun fichier de chunks trouvé. Scraping des pages...")
-        pages = scrape_pages()
-        page_dict = {p["url"]: p["text"] for p in pages if "url" in p and "text" in p}
-
-        if not page_dict:
-            print("⚠️ Aucune page récupérée.")
-            return
+        result = _run_incremental_update()
+
+    result["duration_seconds"] = round(time.time() - start, 2)
+    result["last_run"] = datetime.utcnow().isoformat() + "Z"
+
+    # Persister le statut pour monitoring
+    status = {
+        "last_run": result["last_run"],
+        "duration_seconds": result["duration_seconds"],
+        "chunk_count": result["chunk_count"],
+        "mode": result["mode"],
+        "error": result.get("error"),
+        "scraping_stats": result.get("scraping_stats"),
+        "ready": result.get("error") is None and result["chunk_count"] > 0,
+    }
+    _save_pipeline_status(status)
+
+    logger.info(
+        "✅ Pipeline terminé en %.2fs | mode=%s | chunks=%d",
+        result["duration_seconds"],
+        result["mode"],
+        result["chunk_count"],
+    )
+    return result
 
-        chunks = update_chunks(page_dict)
-        #save_chunks_to_file(chunks)
-
-    if os.path.exists(INDEX_FILE):
-        print("📦 Fichier d'index trouvé. Chargement non nécessaire.")
-        index = faiss.read_index(INDEX_FILE)
-    else:
-        print("📦 Aucun fichier d'index trouvé. Construction de l'index...")
-        build_and_save_index(chunks)
 
 # ----------------- LOCK POUR MISE À JOUR -----------------------
 update_lock = Lock()
 
+
 def run_full_update():
+    """Appelé par le scheduler. Exécute le pipeline et recharge le state."""
     if update_lock.locked():
         logger.info("Mise à jour déjà en cours, nouvelle exécution ignorée.")
         return
     with update_lock:
         logger.info("🔄 Lancement du pipeline via le scheduler...")
         try:
-            full_update_pipeline()
+            result = full_update_pipeline()
+            from src.service.state import state, load_chunks_and_index
+            state["all_chunks"], state["index"] = load_chunks_and_index()
+            logger.info("State rechargé après mise à jour (%d chunks).", len(state.get("all_chunks", [])))
         except Exception as e:
-            logger.error(f"Erreur pendant la mise à jour complète : {e}")
+            logger.error("Erreur pendant la mise à jour complète : %s", e)
+            _save_pipeline_status({
+                "last_run": datetime.utcnow().isoformat() + "Z",
+                "duration_seconds": None,
+                "chunk_count": 0,
+                "mode": None,
+                "error": str(e),
+                "scraping_stats": None,
+                "ready": False,
+            })