909e051cc9
- Multi-modèles : 4 rôles LLM (coding=gemma3:27b-cloud, cpam=gemma3:27b-cloud, validation=deepseek-v3.2:cloud, qc=gemma3:12b) avec get_model(role) - Prompts externalisés : 7 templates dans src/prompts/templates.py - Cache Ollama : modèle stocké par entrée (migration auto ancien format) - call_ollama() : paramètre role= (priorité: model > role > global) - Quality engine : veto_engine + decision_engine + rules_router (YAML) - Benchmark qualité : scripts/benchmark_quality.py (A/B, métriques CIM-10) - Fix biologie : valeurs qualitatives (troponine négative) non filtrées - Fix CPAM : gemma3:27b-cloud au lieu de deepseek (JSON tronqué par thinking) - CPAM max_tokens 4000→6000, viewer admin multi-modèles - Benchmark 10 dossiers : 100% DAS valides, 10/10 CPAM, 243s/dossier Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
948 lines
36 KiB
Python
948 lines
36 KiB
Python
"""Génération de contre-argumentation pour les contrôles CPAM via RAG + Ollama."""
|
|
|
|
from __future__ import annotations
|
|
|
|
import logging
|
|
import re
|
|
|
|
from ..config import ControleCPAM, DossierMedical, RAGSource
|
|
from ..medical.cim10_dict import normalize_code, validate_code
|
|
from ..medical.cim10_extractor import BIO_NORMALS
|
|
from ..medical.ollama_client import call_anthropic, call_ollama
|
|
from ..prompts import CPAM_EXTRACTION, CPAM_ARGUMENTATION, CPAM_ADVERSARIAL
|
|
|
|
logger = logging.getLogger(__name__)
|
|
|
|
|
|
def _search_rag_for_control(controle: ControleCPAM, dossier: DossierMedical) -> list[dict]:
|
|
"""Recherche RAG ciblée pour le sujet du désaccord.
|
|
|
|
Effectue 2-5 recherches ciblées au lieu d'une requête fourre-tout :
|
|
1. Codes contestés → règles de codage spécifiques
|
|
2. Argument CPAM → passages Guide Méthodo contradictoires
|
|
3. Contexte clinique (optionnel) → définitions CIM-10 des codes en jeu
|
|
4. Définitions CIM-10 des codes contestés
|
|
5. Règles explicitement citées dans l'argument CPAM
|
|
|
|
Retourne [] si le RAG est indisponible (index absent, modèle embedding
|
|
inaccessible, etc.) — la contre-argumentation sera générée sans sources.
|
|
"""
|
|
try:
|
|
from ..medical.rag_search import search_similar_cpam
|
|
except Exception:
|
|
logger.warning("Index RAG non disponible pour la contre-argumentation")
|
|
return []
|
|
|
|
try:
|
|
return _search_rag_queries(controle, dossier, search_similar_cpam)
|
|
except Exception:
|
|
logger.warning("Erreur RAG pour la contre-argumentation — génération sans sources",
|
|
exc_info=True)
|
|
return []
|
|
|
|
|
|
def _search_rag_queries(
|
|
controle: ControleCPAM,
|
|
dossier: DossierMedical,
|
|
search_similar_cpam,
|
|
) -> list[dict]:
|
|
"""Exécute les requêtes RAG (séparé pour permettre un try/except global)."""
|
|
all_results: list[dict] = []
|
|
|
|
# Requête 1 — Codes contestés (règles de codage)
|
|
if controle.dp_ucr or controle.da_ucr:
|
|
query_parts = []
|
|
if controle.dp_ucr:
|
|
query_parts.append(f"règles codage {controle.dp_ucr} diagnostic principal")
|
|
if controle.da_ucr:
|
|
query_parts.append(f"diagnostic associé significatif {controle.da_ucr} CMA")
|
|
query_codes = " ".join(query_parts)
|
|
results_codes = search_similar_cpam(query_codes, top_k=6)
|
|
logger.debug(" RAG requête codes : %d résultats", len(results_codes))
|
|
all_results.extend(results_codes)
|
|
|
|
# Requête 2 — Argument CPAM (recherche dans le Guide Méthodo)
|
|
query_parts_arg = []
|
|
if controle.titre:
|
|
query_parts_arg.append(controle.titre)
|
|
arg_short = controle.arg_ucr[:500] if controle.arg_ucr else ""
|
|
if arg_short:
|
|
query_parts_arg.append(arg_short)
|
|
query_arg = " ".join(query_parts_arg)
|
|
if query_arg.strip():
|
|
results_arg = search_similar_cpam(query_arg, top_k=6)
|
|
logger.debug(" RAG requête argument : %d résultats", len(results_arg))
|
|
all_results.extend(results_arg)
|
|
|
|
# Requête 3 — Contexte clinique (définitions CIM-10 des codes en jeu)
|
|
if controle.da_ucr and dossier.diagnostic_principal:
|
|
dp_text = dossier.diagnostic_principal.texte
|
|
das_texts = [
|
|
d.texte for d in dossier.diagnostics_associes
|
|
if d.cim10_suggestion and controle.da_ucr
|
|
and d.cim10_suggestion in controle.da_ucr
|
|
]
|
|
if das_texts:
|
|
query_clinique = f"{dp_text} {' '.join(das_texts)}"
|
|
results_clinique = search_similar_cpam(query_clinique, top_k=4)
|
|
logger.debug(" RAG requête clinique : %d résultats", len(results_clinique))
|
|
all_results.extend(results_clinique)
|
|
|
|
# Requête 4 — Définitions CIM-10 des codes contestés
|
|
contested_codes = []
|
|
for field in (controle.dp_ucr, controle.da_ucr, controle.dr_ucr):
|
|
if field:
|
|
contested_codes.extend(re.split(r"[,;\s]+", field.strip()))
|
|
for raw_code in contested_codes:
|
|
raw_code = raw_code.strip()
|
|
if not raw_code:
|
|
continue
|
|
norm = normalize_code(raw_code)
|
|
is_valid, label = validate_code(norm)
|
|
if is_valid and label:
|
|
query_def = f"CIM-10 {norm} {label} définition inclusion exclusion"
|
|
else:
|
|
query_def = f"CIM-10 {norm} définition codage"
|
|
results_def = search_similar_cpam(query_def, top_k=3)
|
|
logger.debug(" RAG requête CIM-10 %s : %d résultats", norm, len(results_def))
|
|
all_results.extend(results_def)
|
|
|
|
# Requête 5 — Règles explicitement citées dans l'argument CPAM
|
|
if controle.arg_ucr:
|
|
rule_patterns = [
|
|
r'(?:R[eè]gle\s*T?\s*\d+)',
|
|
r'(?:Annexe[\s-]*\d+[A-Za-z]*)',
|
|
r'(?:Situation de soins?\s+[^.]{5,40})',
|
|
]
|
|
rules_found = []
|
|
for pattern in rule_patterns:
|
|
rules_found.extend(re.findall(pattern, controle.arg_ucr, re.IGNORECASE))
|
|
if rules_found:
|
|
rules_unique = list(dict.fromkeys(rules_found))
|
|
query_rules = " ".join(rules_unique) + " guide méthodologique codage PMSI"
|
|
results_rules = search_similar_cpam(query_rules, top_k=4)
|
|
logger.debug(" RAG requête règles (%s) : %d résultats",
|
|
", ".join(rules_unique), len(results_rules))
|
|
all_results.extend(results_rules)
|
|
|
|
if not all_results:
|
|
return []
|
|
|
|
# Fusion : dédupliquer par (document, code, page), garder le meilleur score
|
|
seen: dict[tuple, dict] = {}
|
|
for r in all_results:
|
|
key = (r.get("document"), r.get("code"), r.get("page"))
|
|
if key in seen:
|
|
if r["score"] > seen[key]["score"]:
|
|
seen[key] = r
|
|
else:
|
|
seen[key] = r
|
|
|
|
merged = sorted(seen.values(), key=lambda r: r["score"], reverse=True)
|
|
return merged[:12]
|
|
|
|
|
|
def _get_code_label(code_str: str) -> str:
|
|
"""Résout le libellé CIM-10 pour un ou plusieurs codes."""
|
|
codes = re.split(r"[,;\s]+", code_str.strip())
|
|
labels = []
|
|
for raw in codes:
|
|
raw = raw.strip()
|
|
if not raw:
|
|
continue
|
|
norm = normalize_code(raw)
|
|
is_valid, label = validate_code(norm)
|
|
if is_valid and label:
|
|
labels.append(f"{norm} — {label}")
|
|
else:
|
|
labels.append(norm)
|
|
if not labels:
|
|
return ""
|
|
if len(labels) == 1:
|
|
parts = labels[0].split(" — ", 1)
|
|
return f" — {parts[1]}" if len(parts) > 1 else ""
|
|
return "\n " + "\n ".join(labels)
|
|
|
|
|
|
def _get_cim10_definitions(
|
|
dossier: DossierMedical,
|
|
controle: ControleCPAM,
|
|
) -> str:
|
|
"""Construit une section de définitions CIM-10 déterministes pour tous les codes en jeu.
|
|
|
|
Collecte les codes depuis :
|
|
- Le dossier : DP (cim10_suggestion) + DAS (cim10_suggestion)
|
|
- L'UCR : dp_ucr, da_ucr, dr_ucr
|
|
|
|
Returns:
|
|
Texte formaté pour injection dans le prompt, ou "" si aucun code résolu.
|
|
"""
|
|
codes_seen: dict[str, str] = {} # code normalisé → rôle (pour affichage)
|
|
|
|
# Codes du dossier (établissement)
|
|
if dossier.diagnostic_principal and dossier.diagnostic_principal.cim10_suggestion:
|
|
code = dossier.diagnostic_principal.cim10_suggestion
|
|
codes_seen[normalize_code(code)] = "DP établissement"
|
|
for das in dossier.diagnostics_associes:
|
|
if das.cim10_suggestion:
|
|
norm = normalize_code(das.cim10_suggestion)
|
|
if norm not in codes_seen:
|
|
codes_seen[norm] = "DAS établissement"
|
|
|
|
# Codes de l'UCR (CPAM)
|
|
for field, role in [
|
|
(controle.dp_ucr, "DP proposé UCR"),
|
|
(controle.da_ucr, "DA proposé UCR"),
|
|
(controle.dr_ucr, "DR proposé UCR"),
|
|
]:
|
|
if not field:
|
|
continue
|
|
for raw in re.split(r"[,;\s]+", field.strip()):
|
|
raw = raw.strip()
|
|
if not raw:
|
|
continue
|
|
norm = normalize_code(raw)
|
|
if norm not in codes_seen:
|
|
codes_seen[norm] = role
|
|
|
|
if not codes_seen:
|
|
return ""
|
|
|
|
# Résoudre les libellés
|
|
lines = []
|
|
for norm_code, role in codes_seen.items():
|
|
is_valid, label = validate_code(norm_code)
|
|
if is_valid and label:
|
|
lines.append(f" {norm_code} — {label} [{role}]")
|
|
else:
|
|
lines.append(f" {norm_code} — (code non trouvé dans le dictionnaire) [{role}]")
|
|
|
|
if not lines:
|
|
return ""
|
|
|
|
return (
|
|
"\nDÉFINITIONS CIM-10 — RÉFÉRENCE (source : dictionnaire officiel) :\n"
|
|
+ "\n".join(lines)
|
|
)
|
|
|
|
|
|
def _build_tagged_context(dossier: DossierMedical) -> tuple[str, dict[str, str]]:
|
|
"""Construit un contexte clinique avec des tags de référence pour le grounding.
|
|
|
|
Chaque élément clinique reçoit un tag unique ([BIO-1], [IMG-1], [TRT-1], [ACTE-1])
|
|
que le LLM doit citer dans ses preuves pour garantir la traçabilité.
|
|
|
|
Returns:
|
|
(texte tagué pour injection dans le prompt, dict tag → contenu original)
|
|
"""
|
|
tag_map: dict[str, str] = {}
|
|
lines: list[str] = []
|
|
|
|
# Biologie (avec normes de référence pour éviter les hallucinations)
|
|
for i, b in enumerate(dossier.biologie_cle, 1):
|
|
if not b.valeur:
|
|
continue
|
|
tag = f"BIO-{i}"
|
|
# Interpréter la valeur par rapport aux normes connues
|
|
norm_info = ""
|
|
if b.test in BIO_NORMALS:
|
|
lo, hi = BIO_NORMALS[b.test]
|
|
try:
|
|
val = float(b.valeur.replace(",", ".").split()[0])
|
|
if val > hi:
|
|
norm_info = f" — ÉLEVÉ (norme {lo}-{hi})"
|
|
elif val < lo:
|
|
norm_info = f" — BAS (norme {lo}-{hi})"
|
|
else:
|
|
norm_info = f" — NORMAL (norme {lo}-{hi})"
|
|
except (ValueError, AttributeError):
|
|
pass
|
|
content = f"{b.test}: {b.valeur}{norm_info}"
|
|
tag_map[tag] = content
|
|
lines.append(f" [{tag}] {content}")
|
|
|
|
# Imagerie
|
|
for i, im in enumerate(dossier.imagerie, 1):
|
|
tag = f"IMG-{i}"
|
|
conclusion = f" — {im.conclusion}" if im.conclusion else ""
|
|
content = f"{im.type}{conclusion}"
|
|
tag_map[tag] = content
|
|
lines.append(f" [{tag}] {content}")
|
|
|
|
# Traitements
|
|
for i, t in enumerate(dossier.traitements_sortie[:10], 1):
|
|
tag = f"TRT-{i}"
|
|
posologie = f" {t.posologie}" if t.posologie else ""
|
|
content = f"{t.medicament}{posologie}"
|
|
tag_map[tag] = content
|
|
lines.append(f" [{tag}] {content}")
|
|
|
|
# Actes CCAM
|
|
for i, a in enumerate(dossier.actes_ccam, 1):
|
|
tag = f"ACTE-{i}"
|
|
code = f" ({a.code_ccam_suggestion})" if a.code_ccam_suggestion else ""
|
|
content = f"{a.texte}{code}"
|
|
tag_map[tag] = content
|
|
lines.append(f" [{tag}] {content}")
|
|
|
|
if not lines:
|
|
return "", tag_map
|
|
|
|
text = "ÉLÉMENTS CLINIQUES RÉFÉRENCÉS (cite le tag [XX-N] dans tes preuves) :\n" + "\n".join(lines)
|
|
return text, tag_map
|
|
|
|
|
|
def _validate_grounding(response_data: dict, tag_map: dict[str, str]) -> list[str]:
|
|
"""Vérifie que les références dans preuves_dossier correspondent à des tags existants.
|
|
|
|
Returns:
|
|
Liste de warnings pour les références inventées.
|
|
"""
|
|
if not tag_map:
|
|
return []
|
|
|
|
warnings: list[str] = []
|
|
preuves = response_data.get("preuves_dossier")
|
|
if not preuves or not isinstance(preuves, list):
|
|
return warnings
|
|
|
|
for p in preuves:
|
|
if not isinstance(p, dict):
|
|
continue
|
|
ref = p.get("ref", "")
|
|
if not ref:
|
|
continue
|
|
if ref not in tag_map:
|
|
valeur = p.get("valeur", "?")
|
|
warnings.append(f"Preuve [{ref}] non traçable (« {valeur} »)")
|
|
logger.warning("Grounding : preuve [%s] introuvable dans les tags du dossier", ref)
|
|
|
|
return warnings
|
|
|
|
|
|
def _check_das_bio_coherence(dossier: DossierMedical) -> list[str]:
|
|
"""Vérifie la cohérence entre les textes DAS et les valeurs biologiques.
|
|
|
|
Détecte les contradictions comme "leucocytose" dans un DAS alors que
|
|
les leucocytes sont bas, ou "anémie" alors que l'hémoglobine est normale.
|
|
|
|
Returns:
|
|
Liste de warnings pour les incohérences détectées.
|
|
"""
|
|
if not dossier.diagnostics_associes or not dossier.biologie_cle:
|
|
return []
|
|
|
|
# Patterns DAS → (test bio attendu, direction attendue)
|
|
_DAS_BIO_CHECKS: dict[str, tuple[str, str]] = {
|
|
"leucocytose": ("Leucocytes", "high"),
|
|
"leucopénie": ("Leucocytes", "low"),
|
|
"leucopenie": ("Leucocytes", "low"),
|
|
"thrombocytose": ("Plaquettes", "high"),
|
|
"thrombocytopénie": ("Plaquettes", "low"),
|
|
"thrombocytopenie": ("Plaquettes", "low"),
|
|
"thrombopénie": ("Plaquettes", "low"),
|
|
"thrombopenie": ("Plaquettes", "low"),
|
|
"anémie": ("Hémoglobine", "low"),
|
|
"anemie": ("Hémoglobine", "low"),
|
|
"polyglobulie": ("Hémoglobine", "high"),
|
|
"hyperkaliémie": ("Potassium", "high"),
|
|
"hypokaliémie": ("Potassium", "low"),
|
|
}
|
|
|
|
# Indexer les valeurs bio disponibles
|
|
bio_values: dict[str, float] = {}
|
|
for b in dossier.biologie_cle:
|
|
if b.test and b.valeur:
|
|
try:
|
|
bio_values[b.test] = float(b.valeur.replace(",", ".").split()[0])
|
|
except (ValueError, AttributeError):
|
|
pass
|
|
|
|
warnings: list[str] = []
|
|
for das in dossier.diagnostics_associes:
|
|
texte_lower = (das.texte or "").lower()
|
|
for pattern, (bio_test, direction) in _DAS_BIO_CHECKS.items():
|
|
if pattern not in texte_lower:
|
|
continue
|
|
if bio_test not in bio_values or bio_test not in BIO_NORMALS:
|
|
continue
|
|
val = bio_values[bio_test]
|
|
lo, hi = BIO_NORMALS[bio_test]
|
|
if direction == "high" and val <= hi:
|
|
warnings.append(
|
|
f"INCOHÉRENCE : DAS « {das.texte} » ({das.cim10_suggestion or '?'}) "
|
|
f"mais {bio_test} = {val} est NORMAL (norme {lo}-{hi})"
|
|
)
|
|
elif direction == "low" and val >= lo:
|
|
warnings.append(
|
|
f"INCOHÉRENCE : DAS « {das.texte} » ({das.cim10_suggestion or '?'}) "
|
|
f"mais {bio_test} = {val} est NORMAL (norme {lo}-{hi})"
|
|
)
|
|
|
|
if warnings:
|
|
for w in warnings:
|
|
logger.warning(" DAS/bio : %s", w)
|
|
|
|
return warnings
|
|
|
|
|
|
def _build_cpam_prompt(
|
|
dossier: DossierMedical,
|
|
controle: ControleCPAM,
|
|
sources: list[dict],
|
|
extraction: dict | None = None,
|
|
) -> tuple[str, dict[str, str]]:
|
|
"""Construit le prompt pour la contre-argumentation CPAM.
|
|
|
|
Args:
|
|
extraction: Résultat optionnel de la passe 1 (extraction structurée).
|
|
|
|
Returns:
|
|
(prompt texte, tag_map pour validation grounding)
|
|
"""
|
|
# Résumé du dossier médical
|
|
dossier_lines = []
|
|
|
|
if dossier.diagnostic_principal:
|
|
dp = dossier.diagnostic_principal
|
|
dp_code = f" ({dp.cim10_suggestion})" if dp.cim10_suggestion else ""
|
|
dossier_lines.append(f"- DP : {dp.texte}{dp_code}")
|
|
elif controle.dp_ucr:
|
|
dp_label = _get_code_label(controle.dp_ucr)
|
|
dossier_lines.append(
|
|
f"- DP : code {controle.dp_ucr}{dp_label} "
|
|
f"(codé par l'établissement, contesté par la CPAM)"
|
|
)
|
|
|
|
if dossier.diagnostics_associes:
|
|
das_parts = []
|
|
for das in dossier.diagnostics_associes:
|
|
code = f" ({das.cim10_suggestion})" if das.cim10_suggestion else ""
|
|
das_parts.append(f"{das.texte}{code}")
|
|
dossier_lines.append(f"- DAS : {', '.join(das_parts)}")
|
|
|
|
if dossier.actes_ccam:
|
|
actes = [f"{a.texte} ({a.code_ccam_suggestion})" if a.code_ccam_suggestion else a.texte
|
|
for a in dossier.actes_ccam]
|
|
dossier_lines.append(f"- Actes CCAM : {', '.join(actes)}")
|
|
|
|
sejour = dossier.sejour
|
|
if sejour.duree_sejour is not None:
|
|
dossier_lines.append(f"- Durée séjour : {sejour.duree_sejour} jours")
|
|
if sejour.sexe or sejour.age is not None:
|
|
patient_info = []
|
|
if sejour.sexe:
|
|
patient_info.append(sejour.sexe)
|
|
if sejour.age is not None:
|
|
patient_info.append(f"{sejour.age} ans")
|
|
if sejour.age < 18:
|
|
patient_info.append("(PÉDIATRIE — codage pédiatrique applicable)")
|
|
elif sejour.age >= 80:
|
|
patient_info.append("(patient âgé — comorbidités fréquentes)")
|
|
dossier_lines.append(f"- Patient : {', '.join(patient_info)}")
|
|
if sejour.mode_entree:
|
|
mode_label = sejour.mode_entree
|
|
if "urgence" in mode_label.lower() or "urgent" in mode_label.lower():
|
|
dossier_lines.append(f"- Mode d'entrée : {mode_label} (ADMISSION EN URGENCE)")
|
|
else:
|
|
dossier_lines.append(f"- Mode d'entrée : {mode_label}")
|
|
if sejour.mode_sortie:
|
|
dossier_lines.append(f"- Mode de sortie : {sejour.mode_sortie}")
|
|
if sejour.imc is not None:
|
|
dossier_lines.append(f"- IMC : {sejour.imc}")
|
|
|
|
if dossier.biologie_cle:
|
|
bio = [f"{b.test}: {b.valeur}" for b in dossier.biologie_cle[:5] if b.valeur]
|
|
if bio:
|
|
dossier_lines.append(f"- Biologie clé : {', '.join(bio)}")
|
|
|
|
if dossier.imagerie:
|
|
img_parts = []
|
|
for im in dossier.imagerie:
|
|
conclusion = f" — {im.conclusion}" if im.conclusion else ""
|
|
img_parts.append(f"{im.type}{conclusion}")
|
|
dossier_lines.append(f"- Imagerie : {', '.join(img_parts)}")
|
|
|
|
if dossier.traitements_sortie:
|
|
trt_parts = []
|
|
for t in dossier.traitements_sortie[:10]:
|
|
posologie = f" {t.posologie}" if t.posologie else ""
|
|
trt_parts.append(f"{t.medicament}{posologie}")
|
|
dossier_lines.append(f"- Traitements de sortie : {', '.join(trt_parts)}")
|
|
|
|
if dossier.antecedents:
|
|
dossier_lines.append(f"- Antécédents : {', '.join(a.texte for a in dossier.antecedents[:10])}")
|
|
|
|
if dossier.complications:
|
|
dossier_lines.append(f"- Complications : {', '.join(c.texte for c in dossier.complications)}")
|
|
|
|
dossier_str = "\n".join(dossier_lines) if dossier_lines else "Non disponible"
|
|
|
|
# Section asymétrie : éléments que la CPAM n'avait pas
|
|
asymetrie_lines = []
|
|
|
|
if dossier.biologie_cle:
|
|
bio_details = []
|
|
for b in dossier.biologie_cle if len(dossier.biologie_cle) <= 10 else dossier.biologie_cle[:10]:
|
|
anomalie = " (anormale)" if b.anomalie else ""
|
|
if b.valeur:
|
|
bio_details.append(f"{b.test}: {b.valeur}{anomalie}")
|
|
if bio_details:
|
|
asymetrie_lines.append(f"- Biologie : {', '.join(bio_details)}")
|
|
|
|
if dossier.imagerie:
|
|
img_details = []
|
|
for im in dossier.imagerie:
|
|
conclusion = f" — {im.conclusion}" if im.conclusion else ""
|
|
img_details.append(f"{im.type}{conclusion}")
|
|
if img_details:
|
|
asymetrie_lines.append(f"- Imagerie : {', '.join(img_details)}")
|
|
|
|
if dossier.traitements_sortie:
|
|
trt_details = []
|
|
for t in dossier.traitements_sortie[:10]:
|
|
posologie = f" {t.posologie}" if t.posologie else ""
|
|
trt_details.append(f"{t.medicament}{posologie}")
|
|
if trt_details:
|
|
asymetrie_lines.append(f"- Traitements : {', '.join(trt_details)}")
|
|
|
|
if dossier.actes_ccam:
|
|
actes_details = [
|
|
f"{a.texte} ({a.code_ccam_suggestion})" if a.code_ccam_suggestion else a.texte
|
|
for a in dossier.actes_ccam
|
|
]
|
|
if actes_details:
|
|
asymetrie_lines.append(f"- Actes CCAM : {', '.join(actes_details)}")
|
|
|
|
asymetrie_str = ""
|
|
if asymetrie_lines:
|
|
asymetrie_str = (
|
|
"\n\nÉLÉMENTS DU DOSSIER NON TRANSMIS À LA CPAM "
|
|
"(l'UCR n'a eu que le CRH et les codes) :\n"
|
|
+ "\n".join(asymetrie_lines)
|
|
)
|
|
|
|
# Codes contestés par la CPAM (avec libellés CIM-10 résolus)
|
|
codes_contestes = []
|
|
if controle.dp_ucr:
|
|
codes_contestes.append(f"DP proposé par UCR : {controle.dp_ucr}{_get_code_label(controle.dp_ucr)}")
|
|
if controle.da_ucr:
|
|
codes_contestes.append(f"DA proposés par UCR : {controle.da_ucr}{_get_code_label(controle.da_ucr)}")
|
|
if controle.dr_ucr:
|
|
codes_contestes.append(f"DR proposé par UCR : {controle.dr_ucr}{_get_code_label(controle.dr_ucr)}")
|
|
if controle.actes_ucr:
|
|
codes_contestes.append(f"Actes proposés par UCR : {controle.actes_ucr}")
|
|
codes_str = "\n".join(codes_contestes) if codes_contestes else "Aucun code spécifique proposé"
|
|
|
|
# Définitions CIM-10 déterministes (tous les codes en jeu)
|
|
definitions_str = _get_cim10_definitions(dossier, controle)
|
|
|
|
# Contexte clinique tagué pour le grounding
|
|
tagged_context, tag_map = _build_tagged_context(dossier)
|
|
if tagged_context:
|
|
tagged_str = f"\n\n{tagged_context}"
|
|
else:
|
|
tagged_str = (
|
|
"\n\nATTENTION — DOSSIER PAUVRE EN ÉLÉMENTS CLINIQUES :\n"
|
|
"Aucune biologie, imagerie, traitement ou acte CCAM disponible.\n"
|
|
"Ne spécule PAS sur des éléments absents. Signale explicitement "
|
|
"le manque de données au lieu d'inventer des preuves."
|
|
)
|
|
|
|
# Vérification cohérence DAS / biologie
|
|
das_bio_warnings = _check_das_bio_coherence(dossier)
|
|
if das_bio_warnings:
|
|
tagged_str += (
|
|
"\n\nALERTES COHÉRENCE DAS / BIOLOGIE (incohérences détectées dans le dossier) :\n"
|
|
+ "\n".join(f" - {w}" for w in das_bio_warnings)
|
|
+ "\n Prends en compte ces incohérences dans ton analyse."
|
|
)
|
|
|
|
# Sources RAG
|
|
sources_text = ""
|
|
for i, src in enumerate(sources, 1):
|
|
doc_name = {
|
|
"cim10": "CIM-10 FR 2026",
|
|
"cim10_alpha": "CIM-10 Index Alphabétique 2026",
|
|
"guide_methodo": "Guide Méthodologique MCO 2026",
|
|
"ccam": "CCAM PMSI V4 2025",
|
|
}.get(src.get("document", ""), src.get("document", ""))
|
|
|
|
code_info = f" (code: {src['code']})" if src.get("code") else ""
|
|
page_info = f" [page {src['page']}]" if src.get("page") else ""
|
|
|
|
sources_text += f"--- Source {i}: {doc_name}{code_info}{page_info} ---\n"
|
|
sources_text += (src.get("extrait", "")[:800]) + "\n\n"
|
|
|
|
# Section pré-analyse (résultat passe 1, si disponible)
|
|
extraction_str = ""
|
|
if extraction:
|
|
ext_lines = []
|
|
comp = extraction.get("comprehension_contestation")
|
|
if comp:
|
|
ext_lines.append(f"Compréhension : {comp}")
|
|
elems = extraction.get("elements_cliniques_pertinents", [])
|
|
if elems and isinstance(elems, list):
|
|
elem_strs = []
|
|
for e in elems:
|
|
if isinstance(e, dict):
|
|
elem_strs.append(f" - [{e.get('tag', '?')}] {e.get('pertinence', '')}")
|
|
if elem_strs:
|
|
ext_lines.append("Éléments pertinents :\n" + "\n".join(elem_strs))
|
|
accords = extraction.get("points_accord_potentiels", [])
|
|
if accords and isinstance(accords, list):
|
|
ext_lines.append("Points d'accord potentiels : " + " ; ".join(str(a) for a in accords))
|
|
codes = extraction.get("codes_en_jeu", {})
|
|
if codes and isinstance(codes, dict):
|
|
diff = codes.get("difference_cle", "")
|
|
if diff:
|
|
ext_lines.append(f"Différence clé entre les codages : {diff}")
|
|
if ext_lines:
|
|
extraction_str = (
|
|
"\nPRÉ-ANALYSE (extraction automatique — à utiliser comme base) :\n"
|
|
+ "\n".join(ext_lines)
|
|
)
|
|
|
|
prompt = CPAM_ARGUMENTATION.format(
|
|
dossier_str=dossier_str,
|
|
asymetrie_str=asymetrie_str,
|
|
tagged_str=tagged_str,
|
|
titre=controle.titre,
|
|
arg_ucr=controle.arg_ucr,
|
|
decision_ucr=controle.decision_ucr,
|
|
codes_str=codes_str,
|
|
definitions_str=definitions_str,
|
|
sources_text=sources_text,
|
|
extraction_str=extraction_str,
|
|
)
|
|
return prompt, tag_map
|
|
|
|
|
|
def _validate_references(parsed: dict, sources: list[dict]) -> list[str]:
|
|
"""Vérifie que les références citées correspondent aux sources RAG fournies.
|
|
|
|
Returns:
|
|
Liste d'avertissements pour les références non vérifiables.
|
|
"""
|
|
warnings = []
|
|
refs = parsed.get("references")
|
|
if not refs or not isinstance(refs, list):
|
|
return warnings
|
|
|
|
# Construire un set des documents sources disponibles
|
|
source_docs = set()
|
|
for src in sources:
|
|
doc_name = src.get("document", "")
|
|
source_docs.add(doc_name)
|
|
# Ajouter les noms lisibles aussi
|
|
readable = {
|
|
"cim10": "CIM-10 FR 2026",
|
|
"cim10_alpha": "CIM-10 Index Alphabétique 2026",
|
|
"guide_methodo": "Guide Méthodologique MCO 2026",
|
|
"ccam": "CCAM PMSI V4 2025",
|
|
}.get(doc_name, "")
|
|
if readable:
|
|
source_docs.add(readable)
|
|
source_docs.add(readable.lower())
|
|
|
|
if not source_docs:
|
|
return warnings
|
|
|
|
for ref in refs:
|
|
if not isinstance(ref, dict):
|
|
continue
|
|
doc = ref.get("document", "")
|
|
if doc and not any(sd in doc.lower() or doc.lower() in sd.lower() for sd in source_docs if sd):
|
|
warnings.append(f"Référence non vérifiable : {doc}")
|
|
logger.warning("CPAM : référence non vérifiable « %s »", doc)
|
|
|
|
return warnings
|
|
|
|
|
|
def _format_response(parsed: dict, ref_warnings: list[str] | None = None) -> str:
|
|
"""Formate la réponse LLM en texte lisible."""
|
|
sections = []
|
|
|
|
analyse = parsed.get("analyse_contestation")
|
|
if analyse:
|
|
sections.append(f"ANALYSE DE LA CONTESTATION\n{analyse}")
|
|
|
|
accord = parsed.get("points_accord")
|
|
if accord and accord.lower() not in ("aucun", "non applicable", "n/a", ""):
|
|
sections.append(f"POINTS D'ACCORD\n{accord}")
|
|
|
|
# Nouveaux champs structurés par axe
|
|
contre_med = parsed.get("contre_arguments_medicaux")
|
|
if contre_med:
|
|
sections.append(f"CONTRE-ARGUMENTS MÉDICAUX\n{contre_med}")
|
|
|
|
# Preuves du dossier (nouveau champ structuré)
|
|
preuves = parsed.get("preuves_dossier")
|
|
if preuves and isinstance(preuves, list):
|
|
preuves_lines = []
|
|
for p in preuves:
|
|
if isinstance(p, dict):
|
|
ref = p.get("ref", "")
|
|
elem = p.get("element", "")
|
|
valeur = p.get("valeur", "")
|
|
signif = p.get("signification", "")
|
|
ref_prefix = f"[{ref}] " if ref else ""
|
|
preuves_lines.append(f"- {ref_prefix}[{elem}] {valeur} → {signif}")
|
|
if preuves_lines:
|
|
sections.append(f"PREUVES DU DOSSIER\n" + "\n".join(preuves_lines))
|
|
|
|
contre_asym = parsed.get("contre_arguments_asymetrie")
|
|
if contre_asym:
|
|
sections.append(f"ASYMÉTRIE D'INFORMATION\n{contre_asym}")
|
|
|
|
contre_regl = parsed.get("contre_arguments_reglementaires")
|
|
if contre_regl:
|
|
sections.append(f"CONTRE-ARGUMENTS RÉGLEMENTAIRES\n{contre_regl}")
|
|
|
|
# Fallback : ancien champ unique (réponses en cache existantes)
|
|
if not contre_med and not contre_asym and not contre_regl:
|
|
contre = parsed.get("contre_arguments")
|
|
if contre:
|
|
sections.append(f"CONTRE-ARGUMENTS\n{contre}")
|
|
|
|
# Références structurées (nouveau format liste) ou ancien format string
|
|
refs = parsed.get("references")
|
|
if refs:
|
|
if isinstance(refs, list):
|
|
ref_lines = []
|
|
for r in refs:
|
|
if isinstance(r, dict):
|
|
doc = r.get("document", "")
|
|
page = r.get("page", "")
|
|
citation = r.get("citation", "")
|
|
ref_lines.append(f"- [{doc}, p.{page}] {citation}")
|
|
else:
|
|
ref_lines.append(f"- {r}")
|
|
if ref_lines:
|
|
sections.append(f"REFERENCES\n" + "\n".join(ref_lines))
|
|
else:
|
|
sections.append(f"REFERENCES\n{refs}")
|
|
|
|
conclusion = parsed.get("conclusion")
|
|
if conclusion:
|
|
sections.append(f"CONCLUSION\n{conclusion}")
|
|
|
|
# Avertissements sur les références non vérifiables
|
|
if ref_warnings:
|
|
warning_text = "\n".join(f"- {w}" for w in ref_warnings)
|
|
sections.append(f"AVERTISSEMENT — REFERENCES NON VÉRIFIÉES\n{warning_text}")
|
|
|
|
return "\n\n".join(sections)
|
|
|
|
|
|
def _validate_adversarial(
|
|
response_data: dict,
|
|
tag_map: dict[str, str],
|
|
controle: ControleCPAM,
|
|
) -> dict | None:
|
|
"""Validation adversariale — vérifie la cohérence de la contre-argumentation.
|
|
|
|
Un appel LLM de relecture critique vérifie :
|
|
1. Les valeurs cliniques citées correspondent aux éléments tagués du dossier
|
|
2. La conclusion est cohérente avec l'argumentation
|
|
3. Les points d'accord ne contredisent pas la contre-argumentation
|
|
4. Les codes CIM-10 cités sont cohérents
|
|
|
|
Returns:
|
|
dict {"coherent": bool, "erreurs": list[str], "score_confiance": int} ou None si échec.
|
|
"""
|
|
import json as _json
|
|
|
|
# Construire le résumé des éléments factuels disponibles
|
|
if tag_map:
|
|
factual_lines = "\n".join(f" [{tag}] {content}" for tag, content in tag_map.items())
|
|
factual_section = f"ÉLÉMENTS FACTUELS DU DOSSIER :\n{factual_lines}"
|
|
else:
|
|
factual_section = "ÉLÉMENTS FACTUELS DU DOSSIER : aucun élément tagué disponible"
|
|
|
|
# Sérialiser la réponse LLM de façon compacte
|
|
try:
|
|
response_json = _json.dumps(response_data, ensure_ascii=False, indent=None)
|
|
# Tronquer si trop long pour le prompt de validation
|
|
if len(response_json) > 3000:
|
|
response_json = response_json[:3000] + "..."
|
|
except (TypeError, ValueError):
|
|
logger.warning("Validation adversariale : impossible de sérialiser la réponse")
|
|
return None
|
|
|
|
# Normes biologiques pour vérifier les interprétations
|
|
normes_lines = []
|
|
for test, (lo, hi) in BIO_NORMALS.items():
|
|
normes_lines.append(f" {test}: {lo}-{hi}")
|
|
normes_section = "NORMES BIOLOGIQUES DE RÉFÉRENCE :\n" + "\n".join(normes_lines)
|
|
|
|
dp_ucr_line = f"DP UCR : {controle.dp_ucr}" if controle.dp_ucr else ""
|
|
da_ucr_line = f"DA UCR : {controle.da_ucr}" if controle.da_ucr else ""
|
|
|
|
prompt = CPAM_ADVERSARIAL.format(
|
|
response_json=response_json,
|
|
factual_section=factual_section,
|
|
normes_section=normes_section,
|
|
dp_ucr_line=dp_ucr_line,
|
|
da_ucr_line=da_ucr_line,
|
|
)
|
|
|
|
logger.debug(" Validation adversariale")
|
|
result = call_ollama(prompt, temperature=0.0, max_tokens=800, role="validation")
|
|
if result is None:
|
|
result = call_anthropic(prompt, temperature=0.0, max_tokens=800)
|
|
if result is None:
|
|
logger.warning(" Validation adversariale échouée — LLM indisponible")
|
|
return None
|
|
|
|
coherent = result.get("coherent", True)
|
|
erreurs = result.get("erreurs", [])
|
|
score = result.get("score_confiance", -1)
|
|
|
|
if not coherent and erreurs:
|
|
logger.warning(" Validation adversariale : %d incohérence(s) détectée(s) (score %s/10)",
|
|
len(erreurs), score)
|
|
for e in erreurs:
|
|
logger.warning(" - %s", e)
|
|
else:
|
|
logger.info(" Validation adversariale OK (score %s/10)", score)
|
|
|
|
return result
|
|
|
|
|
|
def _extraction_pass(
|
|
dossier: DossierMedical,
|
|
controle: ControleCPAM,
|
|
) -> dict | None:
|
|
"""Passe 1 — Extraction structurée du contexte avant argumentation.
|
|
|
|
Prompt court centré sur la compréhension de la contestation et l'extraction
|
|
des éléments cliniques pertinents. Pas de rédaction argumentative.
|
|
|
|
Returns:
|
|
dict structuré ou None si le LLM échoue.
|
|
"""
|
|
# Résumé dossier compact
|
|
dp_str = ""
|
|
if dossier.diagnostic_principal:
|
|
dp = dossier.diagnostic_principal
|
|
code = f" ({dp.cim10_suggestion})" if dp.cim10_suggestion else ""
|
|
dp_str = f"{dp.texte}{code}"
|
|
elif controle.dp_ucr:
|
|
dp_str = f"code {controle.dp_ucr} (codé par l'établissement)"
|
|
|
|
das_str = ", ".join(
|
|
f"{d.texte} ({d.cim10_suggestion})" if d.cim10_suggestion else d.texte
|
|
for d in dossier.diagnostics_associes
|
|
)
|
|
|
|
# Contexte tagué (réutilise la même fonction)
|
|
tagged_text, _ = _build_tagged_context(dossier)
|
|
|
|
dp_ucr_line = f"DP proposé UCR : {controle.dp_ucr}" if controle.dp_ucr else ""
|
|
da_ucr_line = f"DA proposés UCR : {controle.da_ucr}" if controle.da_ucr else ""
|
|
|
|
prompt = CPAM_EXTRACTION.format(
|
|
dp_str=dp_str or "Non extrait",
|
|
das_str=das_str or "Aucun",
|
|
tagged_text=tagged_text,
|
|
titre=controle.titre,
|
|
arg_ucr=controle.arg_ucr,
|
|
decision_ucr=controle.decision_ucr,
|
|
dp_ucr_line=dp_ucr_line,
|
|
da_ucr_line=da_ucr_line,
|
|
)
|
|
|
|
logger.debug(" Passe 1 — extraction structurée")
|
|
result = call_ollama(prompt, temperature=0.0, max_tokens=1500, role="cpam")
|
|
if result is None:
|
|
result = call_anthropic(prompt, temperature=0.0, max_tokens=1500)
|
|
if result is not None:
|
|
logger.info(" Passe 1 OK : %d éléments cliniques extraits",
|
|
len(result.get("elements_cliniques_pertinents", [])))
|
|
else:
|
|
logger.warning(" Passe 1 échouée — fallback single-pass")
|
|
return result
|
|
|
|
|
|
def generate_cpam_response(
|
|
dossier: DossierMedical,
|
|
controle: ControleCPAM,
|
|
) -> tuple[str, dict | None, list[RAGSource]]:
|
|
"""Génère une contre-argumentation pour un contrôle CPAM.
|
|
|
|
Args:
|
|
dossier: Le dossier médical analysé.
|
|
controle: Le contrôle CPAM à contester.
|
|
|
|
Returns:
|
|
Tuple (texte de contre-argumentation, dict LLM structuré ou None, sources RAG utilisées).
|
|
"""
|
|
logger.info("CPAM : génération contre-argumentation pour OGC %d — %s",
|
|
controle.numero_ogc, controle.titre)
|
|
|
|
# 1. Passe 1 — Extraction structurée (compréhension avant argumentation)
|
|
extraction = _extraction_pass(dossier, controle)
|
|
|
|
# 2. Recherche RAG ciblée
|
|
sources = _search_rag_for_control(controle, dossier)
|
|
logger.info(" RAG : %d sources trouvées", len(sources))
|
|
|
|
# 3. Construction du prompt (passe 2 — argumentation)
|
|
prompt, tag_map = _build_cpam_prompt(dossier, controle, sources, extraction)
|
|
|
|
# 4. Appel LLM — Ollama (rôle cpam) > Haiku fallback
|
|
result = call_ollama(prompt, temperature=0.1, max_tokens=6000, role="cpam")
|
|
if result is not None:
|
|
logger.info(" Contre-argumentation via Ollama")
|
|
else:
|
|
logger.info(" Ollama indisponible → fallback Anthropic Haiku")
|
|
result = call_anthropic(prompt, temperature=0.1, max_tokens=6000)
|
|
if result is not None:
|
|
logger.info(" Contre-argumentation via Anthropic Haiku")
|
|
|
|
# 5. Conversion des sources RAG
|
|
rag_sources = [
|
|
RAGSource(
|
|
document=s.get("document", ""),
|
|
page=s.get("page"),
|
|
code=s.get("code"),
|
|
extrait=s.get("extrait", "")[:200],
|
|
)
|
|
for s in sources
|
|
]
|
|
|
|
if result is None:
|
|
logger.warning(" LLM non disponible — contre-argumentation non générée")
|
|
return "", None, rag_sources
|
|
|
|
# 6. Validation des références RAG
|
|
ref_warnings = _validate_references(result, sources)
|
|
if ref_warnings:
|
|
logger.warning(" CPAM : %d référence(s) non vérifiable(s)", len(ref_warnings))
|
|
|
|
# 7. Validation grounding (preuves traçables vers le dossier)
|
|
grounding_warnings = _validate_grounding(result, tag_map)
|
|
if grounding_warnings:
|
|
logger.warning(" CPAM : %d preuve(s) non traçable(s)", len(grounding_warnings))
|
|
|
|
# 8. Validation adversariale (cohérence factuelle)
|
|
adversarial_warnings: list[str] = []
|
|
validation = _validate_adversarial(result, tag_map, controle)
|
|
if validation and not validation.get("coherent", True):
|
|
erreurs = validation.get("erreurs", [])
|
|
score = validation.get("score_confiance", "?")
|
|
for e in erreurs:
|
|
if isinstance(e, str) and e.strip():
|
|
adversarial_warnings.append(f"Incohérence détectée : {e}")
|
|
if adversarial_warnings:
|
|
adversarial_warnings.append(f"Score de confiance : {score}/10")
|
|
|
|
all_warnings = ref_warnings + grounding_warnings + adversarial_warnings
|
|
|
|
# 9. Formater la réponse
|
|
text = _format_response(result, all_warnings)
|
|
logger.info(" Contre-argumentation générée (%d caractères)", len(text))
|
|
|
|
return text, result, rag_sources
|