cnesst-chatbot / app.py
CNESST Deploy
fix: Bypass exhausted Gemini API key from env var
c9b9092
Raw History Blame Contribute Delete
37.7 kB
#!/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)