# Corrections Interface Web et Sauvegarde Base de Données

## Date: 2026-02-12

## Problèmes Corrigés

### 1. ❌ Erreur de sauvegarde en base de données (NOT NULL constraint)

**Symptôme**: Les codes n'étaient pas sauvegardés en base car les champs `model_name`, `model_digest`, et `prompt_version` étaient NULL.

**Cause**: La méthode `_save_code()` ne recevait pas les informations de version du modèle.

**Solution**: 
- Modifié `_save_codes_to_database()` pour extraire les informations de version depuis `coding_proposal.model_version`
- Ajouté les paramètres `model_name`, `model_digest`, `prompt_version` à la méthode `_save_code()`
- Passé ces valeurs lors de la création de l'objet `CodeDB`

**Fichier**: `src/pipeline_mco_pmsi/pipeline.py`

```python
# Avant
def _save_code(self, stay_db_id: int, code, code_type: str) -> None:
    code_db = CodeDB(
        stay_id=stay_db_id,
        code=code.code,
        label=code.label,
        type=code_type,
        confidence=code.confidence,
        reasoning=code.reasoning,
        referentiel_version=code.referentiel_version,
        status="proposed"
    )

# Après
def _save_code(self, stay_db_id: int, code, code_type: str, 
               model_name: str, model_digest: str, prompt_version: str) -> None:
    code_db = CodeDB(
        stay_id=stay_db_id,
        code=code.code,
        label=code.label,
        type=code_type,
        confidence=code.confidence,
        reasoning=code.reasoning,
        referentiel_version=code.referentiel_version,
        status="proposed",
        model_name=model_name,
        model_digest=model_digest,
        prompt_version=prompt_version
    )
```

### 2. ❌ Extraction CCAM retournait "UNKNOWN"

**Symptôme**: Les codes CCAM n'étaient pas correctement extraits des chunks, retournant "UNKNOWN" au lieu du code réel.

**Cause**: Le regex ne gérait pas le format markdown utilisé dans les chunks CCAM (`### YYYY001` suivi de `**Description**: ...`).

**Solution**: 
- Amélioré la méthode `_extract_code_and_label()` dans `rag_engine.py`
- Ajouté plusieurs patterns de détection:
  - Titres markdown (`### YYYY001`)
  - Format classique (`YYYY001 Libellé`)
  - Extensions ATIH (`YYYY001+ABC`)
  - Recherche flexible dans tout le texte

**Fichier**: `src/pipeline_mco_pmsi/rag/rag_engine.py`

```python
# Nouveau pattern pour titres markdown
pattern_title = re.compile(r"^###\s+([A-Z]{4}[0-9]{3}(?:\+[A-Z0-9]{3})?)(?:\s|$)")

# Pattern flexible pour recherche dans tout le texte
pattern_anywhere = re.compile(r"([A-Z]{4}[0-9]{3}(?:\+[A-Z0-9]{3})?)")
```

## Résultats

### ✅ Codes sauvegardés en base

```bash
✅ Codes sauvegardés: 56
  - dp: F05.0 - Délirium non surajouté à une démence, ainsi décrit
  - dr: K80 - Cholélithiase
  - das: S00 - Lésion traumatique superficielle de la tête
  - das: K73.8 - Autres hépatites chroniques, non classées ailleurs
  - ccam: HMCC003 - Cholécystogastrostomie ou cholécystoduodénostomie, par cœlioscopie
```

### ✅ Interface web fonctionnelle

L'endpoint API `/stays/15_23096332/coding-proposal` retourne maintenant correctement:
- Le DP avec preuves et justification
- Le DR avec preuves et justification
- Les DAS (25 codes)
- Les CCAM (29 actes)
- Les scores de confiance
- Les raisonnements du codeur

**URL**: http://localhost:8001/stays/15_23096332/coding-proposal

## Problèmes Restants

### ⚠️ Qualité du codage

Le codage proposé n'est pas optimal:
- **DP proposé**: F05.0 (Délirium) au lieu de K80/K81 (Cholécystite)
- **DAS absurdes**: S00 (Lésion tête), K73.8 (Hépatite), codes non pertinents
- **Cause probable**: 
  - Extraction de faits cliniques incorrecte
  - Recherche RAG retournant des codes non pertinents
  - Logique de sélection du DP à améliorer

### ⚠️ Mémoire GPU saturée

Le cross-encoder pour le reranking échoue avec "CUDA out of memory":
- GPU saturé par d'autres processus (6.72 GiB utilisés par process 3600706)
- Le fallback CPU fonctionne mais est plus lent
- **Solution temporaire**: Le code gère l'erreur et continue sans reranking
- **Solution permanente**: Libérer la mémoire GPU ou forcer l'utilisation du CPU

## Prochaines Étapes

1. **Améliorer la qualité du codage**:
   - Revoir l'extraction des faits cliniques
   - Améliorer la recherche RAG (meilleurs prompts, meilleurs embeddings)
   - Affiner la logique de sélection du DP

2. **Optimiser l'utilisation GPU**:
   - Identifier et arrêter les processus GPU inutiles
   - Forcer le cross-encoder sur CPU de manière plus robuste
   - Considérer un modèle cross-encoder plus léger

3. **Tester l'interface web complète**:
   - Vérifier l'affichage dans le navigateur
   - Tester les fonctionnalités de correction
   - Tester la validation des dossiers

## Commandes de Test

```bash
# Traiter le séjour complet
python process_sejour_15_complet.py

# Vérifier les codes en base
python -c "
from pipeline_mco_pmsi.database.base import get_engine, get_session
from pipeline_mco_pmsi.database.models import StayDB, CodeDB

engine = get_engine('sqlite:///pipeline_mco_pmsi.db')
with get_session(engine) as session:
    stay = session.query(StayDB).filter(StayDB.stay_id == '15_23096332').first()
    codes = session.query(CodeDB).filter(CodeDB.stay_id == stay.id, CodeDB.status == 'proposed').all()
    print(f'Codes: {len(codes)}')
"

# Tester l'API
curl http://localhost:8001/stays/15_23096332/coding-proposal | python -m json.tool

# Démarrer l'interface web
python -m uvicorn pipeline_mco_pmsi.api.tim_api:app --host 0.0.0.0 --port 8001
```