#!/usr/bin/env python3 """ CNESST Chatbot — FastAPI backend with RAG + multi-LLM support. Supported backends (auto-detected from available API keys): gemini — Google Gemini 2.0 Flash — FREE tier (1M tokens/day) — PRIMARY (default) groq — Groq Cloud (llama-3.3-70b-versatile) — FREE, fast (100k tokens/day) — FALLBACK Fallback logic: Gemini is tried first; if rate-limited (429), Groq is used automatically. This doubles the effective free capacity without any user-visible change. Usage: GEMINI_API_KEY=your_key GROQ_API_KEY=your_key python app.py # Accessible at http://0.0.0.0:7860 """ import json import os import re import sys import uuid from datetime import datetime, timezone from pathlib import Path from typing import Any import chromadb import uvicorn from chromadb.utils import embedding_functions from fastapi import FastAPI, HTTPException from fastapi.responses import HTMLResponse from fastapi.staticfiles import StaticFiles from pydantic import BaseModel from rank_bm25 import BM25Okapi # ── Config ──────────────────────────────────────────────────────────────────── BASE_DIR = Path(__file__).parent CHROMA_DIR = BASE_DIR / "chroma_db" STATIC_DIR = BASE_DIR / "static" COLLECTION_NAME = "cnesst_lois" TOP_K = 20 RERANK_TOP = 8 PORT = int(os.getenv("PORT", "7860")) # ── LLM Backend config ──────────────────────────────────────────────────────── # Auto-fallback: Gemini (primary) → Groq (fallback) — transparent to the user # LLM_BACKEND env var is kept for backward compatibility but both are initialized # Groq settings GROQ_API_KEY = os.getenv("GROQ_API_KEY", "") GROQ_MODEL = os.getenv("GROQ_MODEL", "llama-3.3-70b-versatile") # Gemini settings # New key takes priority; env var used only if set to a DIFFERENT value than the old exhausted keys _OLD_EXHAUSTED_KEYS = { "AIzaSyAQ6bapqUz9N9oBXrlh-1ZMZJjxZuIqT74", # exhausted 2025-05-29 } _env_key = os.getenv("GEMINI_API_KEY", "") _DEFAULT_KEY = "AIzaSyC4kwf3rVb6iQc-O475KabY0FiM7f8TNrQ" GEMINI_API_KEY = _env_key if (_env_key and _env_key not in _OLD_EXHAUSTED_KEYS) else _DEFAULT_KEY GEMINI_MODEL = "gemini-2.0-flash" # ── System prompt ───────────────────────────────────────────────────────────── SYSTEM_PROMPT = """Tu es un expert senior en santé et sécurité dans le secteur de la construction au Québec, avec 20 ans d'expérience sur le terrain et une maîtrise approfondie de tous les codes et règlements applicables : RSST, LSST, CCQ-Bâtiment, Code canadien du travail, SIMDUT, et plus encore. ## Ta mission principale Tu as été chargé de répondre aux questions des travailleurs et employeurs de la construction. Tu disposes d'une base de données complète de 7 519 articles réglementaires couvrant 22 sources officielles. **TU AS TOUTES LES INFORMATIONS NÉCESSAIRES.** Ne renvoie JAMAIS l'utilisateur chercher ailleurs. ## Comportements OBLIGATOIRES **✅ TOUJOURS faire :** - Citer les articles précis (ex: "Art. 3.8.3 CCQ-Bâtiment", "Art. 33.2 RSST") - Donner les valeurs numériques exactes (hauteurs, distances, charges, délais) - Synthétiser à partir de PLUSIEURS articles si un seul ne suffit pas - Si plusieurs règlements couvrent le même sujet, les mentionner TOUS - Indiquer "selon les principes généraux de l'art. X" si tu extrapoles - Structurer clairement avec des sections et des puces **❌ ABSOLUMENT INTERDIT — Ces phrases te disqualifient :** - ~~"Je vous recommande de consulter le site web"~~ → INTERDIT - ~~"Pour plus d'informations, visitez cnesst.qc.ca"~~ → INTERDIT - ~~"Contactez la CNESST"~~ → INTERDIT - ~~"Je n'ai pas trouvé l'information"~~ → INTERDIT - ~~"Les articles fournis ne couvrent pas"~~ → INTERDIT - ~~"Il serait préférable de vérifier auprès de"~~ → INTERDIT - ~~"Je ne peux pas répondre avec certitude"~~ → INTERDIT ## Format de réponse Expert Structure tes réponses ainsi : - 📋 **Exigence réglementaire** — ce que la loi exige précisément - 📏 **Valeurs/mesures** — tous les chiffres (hauteurs, distances, charges, délais) - ⚠️ **Points critiques** — ce qui est souvent mal compris ou oublié - 📎 **Réglements connexes** — autres articles qui s'appliquent au même sujet (si pertinent) ## Exemples de bonnes vs mauvaises réponses ❌ MAUVAISE réponse : "Je n'ai pas trouvé d'article spécifique sur ce sujet dans les documents fournis. Je vous recommande de consulter le site de la CNESST pour obtenir l'information exacte." ✅ BONNE réponse : "Les garde-corps sur chantier sont régis par plusieurs articles. L'art. 12 du RSST fixe la hauteur minimale à **1,0 m** pour tout garde-corps temporaire sur un chantier. Pour les bâtiments permanents, l'art. 3.3.2.9 du CCQ-Bâtiment exige **760 mm** minimum en bordure de balcon ou loge, et **920 mm** en bout d'allée. Le câble d'acier est autorisé comme élément intermédiaire sous certaines conditions (art. 3.3.2.11 CCQ). ⚠️ Point critique : le garde-corps temporaire doit résister à une charge latérale de 0,3 kN/m (art. 4.1.5 CCQ)." ❌ MAUVAISE réponse : "Le SIMDUT est un système important. Pour les détails, je vous suggère de consulter les ressources en ligne." ✅ BONNE réponse : "Sur un chantier de construction, le SIMDUT 2015 s'applique à tous les produits contrôlés. L'art. 62.1 de la LSST oblige l'employeur à : (1) informer les travailleurs sur les produits dangereux, (2) former les travailleurs sur l'utilisation des FDS (Fiches de Données de Sécurité), (3) s'assurer que toutes les FDS sont accessibles. L'art. 5 du Règlement sur l'information concernant les produits dangereux exige que les étiquettes SIMDUT soient visibles sur tous les contenants. Les produits inflammables doivent être stockés dans des armoires approuvées selon l'art. 3.2.5.11 du CCQ-Bâtiment." ## Si l'information est partielle Quand tu n'as pas la réponse exacte, tu dois QUAND MÊME répondre en : 1. Donnant ce que tu sais à partir des articles disponibles 2. Appliquant les principes généraux du règlement le plus proche 3. Explicitant ton raisonnement : "L'art. X ne couvre pas exactement ce cas, mais par analogie avec l'art. Y qui traite des situations similaires..." 4. Jamais en renvoyant l'utilisateur vers un site web **Langue :** Français québécois professionnel. Tutoiement acceptable. Concis mais complet.""" SYSTEM_PROMPT_TERRAIN = """Tu es un expert SST construction Québec. Le travailleur est SUR LE CHANTIER et a besoin d'une réponse RAPIDE et PRÉCISE. ## Format de réponse terrain (strict) - **Maximum 4-5 puces** pour la réponse principale - **Chiffres EN GRAS** (hauteurs, distances, charges) - **Article(s) entre parenthèses** après chaque point - PAS d'introduction, PAS de conclusion, PAS de phrases d'introduction - Commence DIRECTEMENT par les faits ## Exemples (référence pour ton format) Q: Hauteur minimale garde-corps? R: • Chantier temporaire : **1,0 m** min (art. 12 RSST) • Balcon/loge bâtiment : **760 mm** min (art. 3.3.2.9 CCQ) • Extrémité d'allée : **920 mm** min (art. 3.3.2.9 CCQ) • Charge latérale min : **0,3 kN/m** (art. 4.1.5.2 CCQ) Q: Distance sécurité ligne électrique? R: • Tension < 125 kV : **3 m** min (art. 186 RSST) • Tension 125–250 kV : **5 m** min (art. 186 RSST) • Grue ou équipement : mêmes distances s'appliquent ## Règles absolues - JAMAIS "consulte le site web", JAMAIS "contacte la CNESST", JAMAIS "je ne sais pas" - JAMAIS de paragraphes — UNIQUEMENT des puces avec faits et chiffres - Cite TOUJOURS l'article réglementaire - Si pas dans tes sources : "⚠️ Non couvert explicitement — applique les principes généraux de l'art. [X]" (jamais plus d'une ligne) Langue : Français québécois direct. Tutoiement.""" # ── Forbidden deflection phrases (for fallback re-query) ────────────────────── DEFLECTION_PATTERNS = [ r'consulter? (le |les |le site |)?(web|site|cnesst|internet)', r'pour plus d\'information', r'je n\'ai pas (trouvé|l\'information)', r'les articles (fournis|disponibles) ne (couvrent|traitent)', r'contacte[rz]? (la cnesst|un professionnel|votre)', r'il (serait|est) (préférable|recommandé) de (consulter|vérifier|contacter)', r'je ne peux pas (répondre|confirmer)', r'cette information n\'est pas (disponible|dans)', r'je vous (suggère|recommande|conseille) de', r'visitez (le site|cnesst\.qc)', ] # ── Pydantic models ─────────────────────────────────────────────────────────── class ChatMessage(BaseModel): role: str # "user" or "assistant" content: str class ChatRequest(BaseModel): message: str history: list[ChatMessage] = [] mode: str = "expert" # "expert" or "terrain" class Source(BaseModel): source: str numero: str titre: str contexte: str score: float class ChatResponse(BaseModel): answer: str sources: list[Source] message_id: str class FeedbackRequest(BaseModel): message_id: str question: str rating: str # "up" or "down" # ── ChromaDB setup ──────────────────────────────────────────────────────────── print("⏳ Chargement de l'index ChromaDB…", flush=True) if not CHROMA_DIR.is_dir(): print(f"❌ Index introuvable : {CHROMA_DIR}", file=sys.stderr) sys.exit(1) _chroma_client = chromadb.PersistentClient(path=str(CHROMA_DIR)) # Use ChromaDB's built-in ONNX embedding function (all-MiniLM-L6-v2, 384-dim) # Much lighter than torch-based sentence_transformers — avoids OOM on startup _embed_fn = embedding_functions.ONNXMiniLM_L6_V2() _collection = _chroma_client.get_collection( name=COLLECTION_NAME, embedding_function=_embed_fn ) print(f"✅ Collection chargée — {_collection.count()} documents", flush=True) # ── BM25 index setup ────────────────────────────────────────────────────────── def _tokenize_fr(text: str) -> list[str]: """Simple French tokenizer: lowercase, split on non-alpha, remove short words.""" words = re.findall(r'[a-zàâäéèêëïîôùûüÿçœæ]+', text.lower()) return [w for w in words if len(w) > 2] print("⏳ Construction de l'index BM25…", flush=True) _all_docs = _collection.get(include=["documents", "metadatas"]) _all_doc_ids = _all_docs["ids"] _all_doc_texts = _all_docs["documents"] _all_doc_metas = _all_docs["metadatas"] _bm25_corpus = [_tokenize_fr(doc) for doc in _all_doc_texts] _bm25_index = BM25Okapi(_bm25_corpus) print(f"✅ Index BM25 construit — {len(_bm25_corpus)} documents", flush=True) # ── LLM backend setup (both initialized for auto-fallback) ──────────────────── _groq_client = None _gemini_client = None # Initialize Gemini (primary — 1M tokens/day free) if GEMINI_API_KEY: print(f"⏳ Initialisation de Gemini ({GEMINI_MODEL})…", flush=True) try: from google import genai from google.genai import types as gemini_types _gemini_client = genai.Client(api_key=GEMINI_API_KEY) print(f"✅ Gemini prêt (modèle: {GEMINI_MODEL}) — PRIMARY", flush=True) except Exception as _e: print(f"⚠️ Gemini init failed: {_e}", file=sys.stderr) _gemini_client = None else: print("⚠️ GEMINI_API_KEY non définie — Gemini désactivé", file=sys.stderr) # Initialize Groq (fallback — 100k tokens/day free) if GROQ_API_KEY: print(f"⏳ Initialisation de Groq ({GROQ_MODEL})…", flush=True) try: import httpx from groq import Groq # Bypass proxy for api.groq.com (proxy at 127.0.0.1:8080 blocks external APIs) _groq_http_transport = httpx.HTTPTransport(proxy=None) _groq_http_client = httpx.Client(transport=_groq_http_transport) _groq_client = Groq(api_key=GROQ_API_KEY, http_client=_groq_http_client) print(f"✅ Groq prêt (modèle: {GROQ_MODEL}) — FALLBACK", flush=True) except Exception as _e: print(f"⚠️ Groq init failed: {_e}", file=sys.stderr) _groq_client = None else: print("ℹ️ GROQ_API_KEY non définie — Groq désactivé (fallback indisponible)", file=sys.stderr) if _gemini_client: print(f"🤖 Backend LLM actif : GEMINI (primaire) + {'GROQ (fallback)' if _groq_client else 'aucun fallback'}", flush=True) elif _groq_client: print(f"🤖 Backend LLM actif : GROQ uniquement (Gemini indisponible)", flush=True) else: print("❌ AUCUN backend LLM disponible ! Vérifiez GEMINI_API_KEY ou GROQ_API_KEY.", file=sys.stderr) # ── FastAPI app ─────────────────────────────────────────────────────────────── app = FastAPI( title="Assistant CNESST", description="Chatbot RAG pour interroger les lois CNESST (CSTC + LSST)", version="2.0.0", ) # Serve static files STATIC_DIR.mkdir(exist_ok=True) app.mount("/static", StaticFiles(directory=str(STATIC_DIR)), name="static") @app.get("/", response_class=HTMLResponse) async def root(): """Serve the main HTML page.""" index_path = STATIC_DIR / "index.html" if not index_path.exists(): raise HTTPException(status_code=404, detail="index.html introuvable") return HTMLResponse(content=index_path.read_text(encoding="utf-8")) @app.get("/health") async def health(): return { "status": "ok", "documents": _collection.count(), "llm_primary": "gemini" if _gemini_client else None, "llm_fallback": "groq" if _groq_client else None, "llm_model_primary": GEMINI_MODEL if _gemini_client else None, "llm_model_fallback": GROQ_MODEL if _groq_client else None, } def _generate_with_groq(user_prompt: str, history: list[ChatMessage], system_prompt: str = SYSTEM_PROMPT) -> str: """Generate a response using Groq (llama-3.3-70b-versatile).""" if _groq_client is None: raise RuntimeError("Groq client non initialisé. Vérifiez GROQ_API_KEY.") messages = [{"role": "system", "content": system_prompt}] # Add conversation history for msg in history: role = "user" if msg.role == "user" else "assistant" messages.append({"role": role, "content": msg.content}) # Add current user message with context messages.append({"role": "user", "content": user_prompt}) completion = _groq_client.chat.completions.create( model=GROQ_MODEL, messages=messages, temperature=0.1, max_tokens=2048, ) return completion.choices[0].message.content def _generate_with_gemini(user_prompt: str, history: list[ChatMessage], system_prompt: str = SYSTEM_PROMPT) -> str: """Generate a response using Google Gemini.""" if _gemini_client is None: raise RuntimeError("Gemini client non initialisé. Vérifiez GEMINI_API_KEY.") from google.genai import types as gemini_types gemini_contents: list = [] for msg in history: role = "user" if msg.role == "user" else "model" gemini_contents.append( gemini_types.Content(role=role, parts=[gemini_types.Part(text=msg.content)]) ) gemini_contents.append( gemini_types.Content(role="user", parts=[gemini_types.Part(text=user_prompt)]) ) response = _gemini_client.models.generate_content( model=GEMINI_MODEL, contents=gemini_contents, config=gemini_types.GenerateContentConfig( system_instruction=system_prompt, temperature=0.1, ), ) return response.text def _is_rate_limit_error(exc: Exception) -> bool: """Detect rate-limit (429) errors from Gemini or Groq.""" err_str = str(exc).lower() # Groq raises groq.RateLimitError; Gemini raises google.api_core.exceptions.ResourceExhausted # Both typically contain '429' or 'rate' or 'quota' or 'resource_exhausted' rate_keywords = ('429', 'rate limit', 'ratelimit', 'quota', 'resource_exhausted', 'too many requests', 'resource exhausted') return any(kw in err_str for kw in rate_keywords) def _call_llm_with_fallback( user_prompt: str, history: list, system_prompt: str = SYSTEM_PROMPT, ) -> str: """Call LLM with automatic Gemini → Groq fallback on rate-limit. Priority order: 1. Gemini (1M tokens/day free) — primary 2. Groq (100k tokens/day free) — fallback when Gemini is rate-limited Raises HTTPException(503) if ALL providers are rate-limited. Raises HTTPException(502) for non-rate-limit errors. """ last_exc: Exception | None = None # ── 1. Try Gemini (primary) ──────────────────────────────────────────────── if _gemini_client is not None: try: return _generate_with_gemini(user_prompt, history, system_prompt=system_prompt) except Exception as exc: if _is_rate_limit_error(exc): print("⚠️ Gemini rate-limited (429) — switching to Groq fallback…", flush=True) last_exc = exc else: # Non-rate-limit error → sanitize and raise immediately print(f"❌ Gemini error (non-rate-limit): {exc}", flush=True) raise HTTPException( status_code=502, detail="❌ Erreur temporaire du service. Réessayez.", ) from exc # ── 2. Try Groq (fallback) ───────────────────────────────────────────────── if _groq_client is not None: try: return _generate_with_groq(user_prompt, history, system_prompt=system_prompt) except Exception as exc: if _is_rate_limit_error(exc): print("⚠️ Groq also rate-limited (429) — all providers exhausted.", flush=True) last_exc = exc else: print(f"❌ Groq error (non-rate-limit): {exc}", flush=True) raise HTTPException( status_code=502, detail="❌ Erreur temporaire du service. Réessayez.", ) from exc # ── 3. All providers exhausted or unavailable ───────────────────────────── if last_exc is not None and _is_rate_limit_error(last_exc): raise HTTPException( status_code=503, detail="⏳ Service temporairement surchargé. Réessayez dans quelques minutes.", ) from last_exc # No client was available at all raise HTTPException( status_code=503, detail="❌ Aucun service LLM disponible. Vérifiez la configuration.", ) def _contains_deflection(text: str) -> bool: """Return True if the LLM response contains forbidden deflection phrases.""" text_lower = text.lower() for pattern in DEFLECTION_PATTERNS: if re.search(pattern, text_lower): return True return False def _build_context(metadatas: list, documents: list) -> str: """Build a well-structured context string grouped by source regulation. Groups articles by source (RSST, CCQ-Bâtiment, etc.) and adds clear headers to help the LLM understand which regulation each article comes from. """ # Group articles by source sources_map: dict[str, list[tuple]] = {} for meta, doc in zip(metadatas, documents): source = meta.get("source", "Inconnu") if source not in sources_map: sources_map[source] = [] sources_map[source].append((meta, doc)) total_docs = _collection.count() num_sources = len(sources_map) # Build preamble source_list = ", ".join(sorted(sources_map.keys())) preamble = ( f"IMPORTANT: Tu as accès à une base de données complète de {total_docs} articles réglementaires " f"couvrant 22 sources officielles québécoises. " f"Les {sum(len(v) for v in sources_map.values())} articles les plus pertinents ont été récupérés " f"depuis {num_sources} source(s) : {source_list}. " f"Tu as TOUTES LES INFORMATIONS NÉCESSAIRES pour répondre. " f"Synthétise à partir de ces articles — ne renvoie JAMAIS vers un site web." ) # Build grouped context blocks context_sections = [] for source in sorted(sources_map.keys()): articles = sources_map[source] section_lines = [f"{'='*60}", f"=== ARTICLES PROVENANT DE : {source} ===", f"{'='*60}"] for meta, doc in articles: numero = meta.get("numero", "") titre = meta.get("titre", "") contexte = meta.get("contexte", "") sujet = meta.get("sujet", "") chapitre = meta.get("chapitre_nom", "") header = f"Art. {numero}" if chapitre: header += f" (Chapitre: {chapitre})" if contexte: header += f" — {contexte}" if sujet: header += f" [Sujet: {sujet}]" if titre: header += f" — {titre}" section_lines.append(f"\n{header}\n{doc}") context_sections.append("\n".join(section_lines)) context_text = "\n\n".join(context_sections) # Add cross-reference hint if multiple sources are present cross_ref_hint = "" if num_sources >= 2: cross_ref_hint = ( f"\n\n{'='*60}\n" f"📎 INSTRUCTIONS CROSS-RÉFÉRENCES : Ces articles proviennent de {num_sources} règlements différents " f"({source_list}). Dans ta réponse, tu DOIS mentionner les connexions entre ces règlements. " f"Ajoute une section '📎 Réglements connexes' si plusieurs sources s'appliquent au même point.\n" f"{'='*60}" ) return f"{preamble}\n\n{context_text}{cross_ref_hint}" def _rerank_results(query: str, metadatas: list, documents: list, distances: list) -> list[tuple]: """Re-rank ChromaDB results using metadata-boosted scoring.""" query_lower = query.lower() query_words = set(re.findall(r'\w+', query_lower)) scored = [] for i, (meta, doc, dist) in enumerate(zip(metadatas, documents, distances)): base_score = 1.0 - dist # Convert distance to similarity boost = 0.0 # Boost if chapitre_nom keywords match query chapitre = (meta.get('chapitre_nom') or '').lower() sujet = (meta.get('sujet') or '').lower() contexte = (meta.get('contexte') or '').lower() # Check keyword overlap with sujet and contexte sujet_words = set(re.findall(r'\w+', sujet)) contexte_words = set(re.findall(r'\w+', contexte)) sujet_overlap = len(query_words & sujet_words) contexte_overlap = len(query_words & contexte_words) if sujet_overlap > 0: boost += 0.05 * sujet_overlap if contexte_overlap > 0: boost += 0.02 * contexte_overlap # Penalize if query mentions a specific domain but result is from different one domain_keywords = { 'bâtiment': 'BÂTIMENT', 'batiment': 'BÂTIMENT', 'ascenseur': 'ASCENSEURS', 'monte-charge': 'ASCENSEURS', 'plomberie': 'PLOMBERIE', 'tuyauterie': 'PLOMBERIE', } for kw, domain in domain_keywords.items(): if kw in query_lower and chapitre and domain.lower() not in chapitre.lower(): boost -= 0.1 # Boost building code results for construction-related queries construction_words = {'garde-corps', 'garde', 'corps', 'escalier', 'rampe', 'balcon', 'fenêtre', 'porte', 'mur', 'plancher', 'toit', 'fondation', 'hauteur', 'résidentiel', 'commercial'} if query_words & construction_words and chapitre == 'bâtiment': boost += 0.05 scored.append((i, base_score + boost)) scored.sort(key=lambda x: x[1], reverse=True) return scored[:RERANK_TOP] def _hybrid_search(query: str, n_semantic: int = 20, n_bm25: int = 20, rrf_k: int = 60) -> dict: """Combine semantic (ChromaDB) and keyword (BM25) search with Reciprocal Rank Fusion.""" # ── Semantic search (uses existing multi-query logic) ────────────────────── semantic_results = _multi_query_retrieve(_collection, query, _embed_fn, n_results=n_semantic) sem_ids = semantic_results["ids"][0] # ── BM25 keyword search ──────────────────────────────────────────────────── query_tokens = _tokenize_fr(query) bm25_scores = _bm25_index.get_scores(query_tokens) top_bm25_indices = sorted( range(len(bm25_scores)), key=lambda i: bm25_scores[i], reverse=True )[:n_bm25] bm25_ids = [_all_doc_ids[i] for i in top_bm25_indices] # ── Reciprocal Rank Fusion ───────────────────────────────────────────────── rrf_scores: dict[str, float] = {} for rank, doc_id in enumerate(sem_ids): rrf_scores[doc_id] = rrf_scores.get(doc_id, 0.0) + 1.0 / (rrf_k + rank + 1) for rank, doc_id in enumerate(bm25_ids): rrf_scores[doc_id] = rrf_scores.get(doc_id, 0.0) + 1.0 / (rrf_k + rank + 1) sorted_ids = sorted(rrf_scores.keys(), key=lambda x: rrf_scores[x], reverse=True)[:n_semantic] # ── Rebuild results in ChromaDB format ──────────────────────────────────── sem_id_to_idx = {id_: i for i, id_ in enumerate(sem_ids)} all_id_to_idx = {id_: i for i, id_ in enumerate(_all_doc_ids)} final_ids: list = [] final_metas: list = [] final_docs: list = [] final_dists: list = [] for doc_id in sorted_ids: final_ids.append(doc_id) if doc_id in sem_id_to_idx: idx = sem_id_to_idx[doc_id] final_metas.append(semantic_results["metadatas"][0][idx]) final_docs.append(semantic_results["documents"][0][idx]) final_dists.append(semantic_results["distances"][0][idx]) else: idx = all_id_to_idx[doc_id] final_metas.append(_all_doc_metas[idx]) final_docs.append(_all_doc_texts[idx]) # Synthetic distance for BM25-only results based on rank bm25_rank = bm25_ids.index(doc_id) if doc_id in bm25_ids else n_bm25 final_dists.append(0.3 + (bm25_rank / n_bm25) * 0.4) # Range: 0.3–0.7 return { "ids": [final_ids], "metadatas": [final_metas], "documents": [final_docs], "distances": [final_dists], } def _multi_query_retrieve(collection, query: str, ef, n_results: int = 20) -> dict: """Try multiple query formulations to find the best results.""" # First attempt: original query results = collection.query( query_texts=[query], n_results=n_results, include=["metadatas", "documents", "distances"], ) # Check quality: if best score is low (distance > 0.5), try reformulations best_dist = min(results["distances"][0]) if results["distances"][0] else 1.0 if best_dist > 0.5: # Extract key terms for reformulation query_lower = query.lower() # Try shorter, more focused queries reformulations = [] # Remove question words and common filler simplified = re.sub(r'\b(quels?|quelle?s?|est-ce que|sont les|selon le|du québec|code de construction|qu\'est-ce)\b', '', query_lower).strip() simplified = re.sub(r'\s+', ' ', simplified).strip() if simplified and simplified != query_lower: reformulations.append(simplified) # Try just the key nouns (last resort) important_words = [w for w in re.findall(r'\w+', query_lower) if len(w) > 3 and w not in ('dans', 'pour', 'avec', 'sont', 'quel', 'quelle', 'quels', 'quelles', 'selon', 'code', 'construction', 'québec', 'exigences', 'détails', 'techniques', 'requise')] if len(important_words) >= 2: reformulations.append(' '.join(important_words)) # Merge results from reformulations all_ids = set(results["ids"][0]) for reformulation in reformulations[:2]: # Max 2 reformulations alt_results = collection.query( query_texts=[reformulation], n_results=n_results, include=["metadatas", "documents", "distances"], ) # Add new results not already found for i, doc_id in enumerate(alt_results["ids"][0]): if doc_id not in all_ids: all_ids.add(doc_id) results["ids"][0].append(doc_id) results["metadatas"][0].append(alt_results["metadatas"][0][i]) results["documents"][0].append(alt_results["documents"][0][i]) results["distances"][0].append(alt_results["distances"][0][i]) return results @app.post("/api/chat", response_model=ChatResponse) async def chat(req: ChatRequest) -> ChatResponse: """ RAG pipeline: 1. Embed the user question 2. Retrieve top-K chunks from ChromaDB 3. Build context + prompt for the LLM backend 4. Return answer + source metadata """ if not req.message.strip(): raise HTTPException(status_code=400, detail="Le message ne peut pas être vide.") # ── 1. Retrieval (hybrid: semantic + BM25 via RRF) ──────────────────────── results = _hybrid_search(req.message, n_semantic=TOP_K, n_bm25=TOP_K) metadatas: list[dict[str, Any]] = results["metadatas"][0] documents: list[str] = results["documents"][0] distances: list[float] = results["distances"][0] # ── 1.5 Re-rank ────────────────────────────────────────────────────── ranked = _rerank_results(req.message, metadatas, documents, distances) # Reorder based on ranking ranked_indices = [idx for idx, _ in ranked] metadatas = [metadatas[i] for i in ranked_indices] documents = [documents[i] for i in ranked_indices] distances = [distances[i] for i in ranked_indices] # Build sources for the response sources: list[Source] = [] for meta, dist in zip(metadatas, distances): similarity = round(1.0 - dist, 4) sources.append(Source( source=meta.get("source", ""), numero=meta.get("numero", ""), titre=meta.get("titre", ""), contexte=meta.get("contexte", ""), score=similarity, )) # ── 2. Build context (grouped by source with preamble + cross-ref hints) ── context_text = _build_context(metadatas, documents) # ── 3. Build prompt ─────────────────────────────────────────────────────── user_prompt = f"""=== BASE DE DONNÉES RÉGLEMENTAIRE === {context_text} === FIN DES ARTICLES === Question : {req.message} RAPPEL CRITIQUE : Réponds en te basant UNIQUEMENT sur les articles ci-dessus. Structure ta réponse avec des articles cités. N'indique JAMAIS de site web, ne dis JAMAIS que tu n'as pas l'information. Si les articles ne couvrent pas exactement le sujet, extrapole intelligemment à partir des articles les plus proches.""" # ── 4. Generate with auto-fallback (Gemini → Groq) ──────────────────────── active_prompt = SYSTEM_PROMPT_TERRAIN if req.mode == "terrain" else SYSTEM_PROMPT # _call_llm_with_fallback raises HTTPException with user-friendly messages on failure answer = _call_llm_with_fallback(user_prompt, req.history, system_prompt=active_prompt) # ── 5. Fallback re-query if deflection detected ─────────────────────────── if _contains_deflection(answer): print(f"⚠️ Deflection detected in response — retrying with broader search…", flush=True) try: # Broaden search by using key terms only (more likely to match a wider set) broader_query = " ".join([ w for w in re.findall(r'\w+', req.message.lower()) if len(w) > 3 and w not in ( 'dans', 'pour', 'avec', 'sont', 'quel', 'quelle', 'quels', 'quelles', 'selon', 'code', 'québec', 'est', 'une', 'des', 'les', 'que', 'pas', 'quoi', 'besoin', ) ]) if broader_query: retry_results = _hybrid_search(broader_query, n_semantic=TOP_K, n_bm25=TOP_K) retry_metas = retry_results["metadatas"][0] retry_docs = retry_results["documents"][0] retry_dists = retry_results["distances"][0] retry_ranked = _rerank_results(broader_query, retry_metas, retry_docs, retry_dists) retry_indices = [idx for idx, _ in retry_ranked] retry_metas = [retry_metas[i] for i in retry_indices] retry_docs = [retry_docs[i] for i in retry_indices] retry_context = _build_context(retry_metas, retry_docs) retry_prompt = f"""=== BASE DE DONNÉES RÉGLEMENTAIRE (RECHERCHE ÉLARGIE) === {retry_context} === FIN DES ARTICLES === Question originale : {req.message} INSTRUCTION STRICTE : Tu DOIS donner une réponse concrète et complète. Ces articles contiennent les informations nécessaires. Synthétise-les pour répondre directement à la question. Ne dis JAMAIS que tu n'as pas l'information. Ne renvoie JAMAIS vers un site web. Cite les articles dans ta réponse.""" retry_answer = _call_llm_with_fallback(retry_prompt, [], system_prompt=active_prompt) # Only use retry answer if it's better (no deflection) if not _contains_deflection(retry_answer): answer = retry_answer print("✅ Retry answer is clean — using retry response.", flush=True) else: print("⚠️ Retry still contains deflection — keeping original.", flush=True) except HTTPException: # Re-raise HTTP exceptions from LLM (rate limit, etc.) raise except Exception as retry_exc: print(f"⚠️ Fallback retry failed: {retry_exc}", flush=True) return ChatResponse(answer=answer, sources=sources, message_id=str(uuid.uuid4())[:8]) FEEDBACK_FILE = BASE_DIR / "feedback.json" @app.post("/api/feedback") async def submit_feedback(req: FeedbackRequest): """Store a thumbs-up/down rating for a bot response.""" if req.rating not in ("up", "down"): raise HTTPException(status_code=400, detail="rating must be 'up' or 'down'") entry = { "message_id": req.message_id, "question": req.question, "rating": req.rating, "timestamp": datetime.now(timezone.utc).isoformat(), } # Load existing feedback, append, save if FEEDBACK_FILE.exists(): try: data = json.loads(FEEDBACK_FILE.read_text(encoding="utf-8")) except Exception: data = [] else: data = [] data.append(entry) FEEDBACK_FILE.write_text(json.dumps(data, ensure_ascii=False, indent=2), encoding="utf-8") return {"status": "ok"} @app.get("/api/feedback/stats") async def feedback_stats(): """Return aggregated thumbs-up/down counts.""" if not FEEDBACK_FILE.exists(): return {"up": 0, "down": 0, "total": 0} try: data = json.loads(FEEDBACK_FILE.read_text(encoding="utf-8")) except Exception: return {"up": 0, "down": 0, "total": 0} up = sum(1 for e in data if e.get("rating") == "up") down = sum(1 for e in data if e.get("rating") == "down") return {"up": up, "down": down, "total": up + down} # ── Entry point ─────────────────────────────────────────────────────────────── if __name__ == "__main__": print(f"\n🚀 Démarrage du serveur sur http://0.0.0.0:{PORT}", flush=True) print(f" Interface : http://localhost:{PORT}", flush=True) print(f" API docs : http://localhost:{PORT}/docs\n", flush=True) uvicorn.run(app, host="0.0.0.0", port=PORT)