医院急诊智能决策系统

flowchart TB
    subgraph UI["🖥️ Interface Utilisateur"]
        A[Dashboard Streamlit]
        B[Onglet Principal]
        C[Onglet Chatbot]
        D[Onglet Métriques]
    end

    subgraph Backend["⚙️ Backend Core"]
        E[EmergencyController]
        F[Patient/Staff/Transport Services]
        G[EmergencyState]
    end

    subgraph IA["🤖 Couche Intelligence Artificielle"]
        H[EmergencyAgent<br/>Mistral AI]
        I[RAG Engine<br/>FAISS + Embeddings]
        J[ChatbotEngine<br/>+ Intent Parser]
    end

    subgraph Security["🛡️ Sécurité"]
        K[Guardrails Multi-Couches<br/>Pattern + ML + Logic]
        L[InjectionDetector]
    end

    subgraph Monitoring["📊 Observabilité"]
        M[MetricsTracker<br/>EcoLogits]
        N[RequestMetrics]
    end

    UI --> Backend
    Backend --> IA
    IA --> Security
    IA --> Monitoring
    H --> I
    J --> I
    I --> K
    Backend --> G

# Workflow simplifié
1. Query utilisateur → Guardrails (sécurité)
2. Embedding de la query (MiniLM-L12)
3. Recherche FAISS (similarité cosinus)
4. Filtrage par seuil de confiance (> 0.7)
5. Récupération des règles applicables
6. Validation post-retrieval (guardrails)
7. Réponse enrichie (protocole + règles)

def cycle_orchestration(self) -> List[str]:
    """Cycle de décision autonome de l'agent."""
    # 1. Analyse de l'état via RAG
    situation = self._build_situation_prompt()
    rag_response = self.rag_engine.query(situation)
    
    # 2. Décision LLM enrichie
    decision = self._call_llm(situation, rag_response)
    
    # 3. Exécution via MCP tools
    actions = self._execute_actions(decision)
    
    return actions

Input Query
    ↓
[Couche 1] Pattern Detection (Regex)
    ↓ (si suspect)
[Couche 2] ML Classification (HGB)
    ↓ (si safe)
[Couche 3] RAG Retrieval
    ↓
[Couche 4] Logic Validation
    ↓
Output (safe/blocked)

# Exemples
- Injection classique: "ignore previous instructions"
- Jailbreak: "DAN mode", "Developer override"
- Template injection: {{...}}, {%...%}
- Command injection: ;ls, $(command), `backticks`
- SQL injection: DROP TABLE, DELETE FROM

1. TF-IDF Vectorization (5000 features, n-grams 1-3)
2. Histogram Gradient Boosting (max_depth=10, learning_rate=0.1)
3. Seuil de décision : 0.5 (ajustable)

graph LR
    A[User Input] --> B[Guardrails]
    B --> C[Intent Parser]
    C --> D{Intent Type}
    D -->|ADD_PATIENT| E[Action Executor]
    D -->|ASK_PROTOCOL| F[RAG Engine]
    D -->|GET_STATUS| G[State Query]
    E --> H[Controller]
    F --> I[Response Builder]
    G --> I
    H --> I
    I --> J[Formatted Response]

# Ajout de patients
"ajoute Jean Dupont gravité rouge"
"ajoute 5 patients jaunes avec fièvre"
"ajoute Martin rouge pour douleur thoracique"

# Transports
"transporte P001 en consultation"
"déplace patient P002 vers Unité A"

# Questions protocoles
"quel protocole pour douleur thoracique ?"
"que faire pour un AVC suspect ?"

# État système
"quel est l'état du système ?"
"liste les patients en attente"

class ActionExecutor:
    def execute(self, action_plan) -> List[Dict]:
        for action in action_plan.actions:
            tool_name = action["tool"]
            params = action["params"]
            result = self._execute_single(tool_name, params)
        return results

@dataclass
class ChatbotResponse:
    message: str
    guardrail_status: str  # "allowed" | "blocked"
    rag_context: Optional[Dict]
    actions_executed: Optional[List]
    latency_ms: float
    intent_type: str

# Calcul automatique par EcoLogits
response = litellm.completion(model="mistral/mistral-small-latest", ...)

# Extraction
energy_kwh = response.impacts.energy.value.min
co2_kg = response.impacts.gwp.value.min  # Mix électrique FR (55g CO2/kWh)

cost = (input_tokens / 1_000_000) * input_price + \
       (output_tokens / 1_000_000) * output_price

"Ajoute 3 patients rouges avec détresse respiratoire"
"Quel est le protocole pour douleur thoracique ?"
"Transporte le patient P001 en consultation"
"Quel est l'état du système ?"
"Explique ta dernière décision"

# 1. Cloner le repository
git clone https://github.com/votre-username/emergency-manager.git
cd emergency-manager

# 2. Créer l'environnement virtuel
python -m venv .venv
source .venv/bin/activate  # Linux/Mac
# .venv\Scripts\activate   # Windows

# 3. Installer les dépendances
pip install -r requirements.txt

# 4. Configurer les variables d'environnement
cp .env.example .env
# Éditer .env et ajouter votre MISTRAL_API_KEY

# API Keys
MISTRAL_API_KEY=your_mistral_api_key_here

# Modèles (optionnel, valeurs par défaut)
LLM_MODEL=mistral-small-latest
EMBEDDING_MODEL=paraphrase-multilingual-MiniLM-L12-v2

# Monitoring (optionnel)
ENABLE_ECOLOGITS=true

# Construire l'index vectoriel FAISS à partir des protocoles
python rag/LLM/build_index.py

# Télécharger les datasets et entraîner le modèle
python rag/LLM/train_guardrails.py

# Lancer le dashboard Streamlit
streamlit run emergency_dashboard_premium.py

# Lancer les tests de vérification
python test_integration.py

emergency-manager/
│
├── 📄 README.md                              # Ce fichier
├── 📄 requirements.txt                       # Dépendances Python
├── 📄 .env.example                           # Template configuration
├── 📄 .gitignore                             # Fichiers à ignorer
│
├── 📄 emergency_dashboard_premium.py         # 🎯 POINT D'ENTRÉE - Dashboard Streamlit
├── 📄 premium_styles.py                      # Styles CSS du dashboard
├── 📄 dashboard_components.py                # Composants UI réutilisables
├── 📄 chatbot_component.py                   # Composant chatbot
├── 📄 test_integration.py                    # Tests d'intégration
│
├── 📂 rag/                                   # RAG Engine
│   ├── engine.py                            # HospitalRAGEngine (moteur principal)
│   ├── models.py                            # Modèles Pydantic (RAGResponse, Protocol, Rule)
│   ├── guardrails.py                        # Guardrails multi-couches
│   └── LLM/
│       ├── build_index.py                   # Construction index FAISS
│       ├── train_guardrails.py              # Entraînement guardrail ML
│       └── compare_models.py                # Benchmark modèles ML
│
├── 📂 mcp/                                   # Model Context Protocol
│   ├── state.py                             # Modèles d'état (EmergencyState, Patient, Staff)
│   ├── agent.py                             # EmergencyAgent autonome
│   ├── controllers/
│   │   └── emergency_controller.py          # Contrôleur principal
│   └── services/
│       ├── patient_service.py               # Service gestion patients
│       ├── staff_service.py                 # Service gestion personnel
│       └── transport_service.py             # Service gestion transports
│
├── 📂 chatbot/                               # Chatbot médical
│   ├── chatbot_engine.py                    # ChatbotEngine (orchestrateur)
│   ├── intent_parser.py                     # Parsing intentions NLP
│   ├── action_executor.py                   # Exécution actions MCP
│   └── response_builder.py                  # Construction réponses
│
├── 📂 monitoring/                            # Monitoring GreenOps/FinOps
│   ├── monitoring.py                        # MetricsTracker
│   └── rag_augmented.py                     # Wrapper LiteLLM + EcoLogits
│
├── 📂 data_regle/                            # Base de connaissances
│   ├── protocoles.json                      # ~100 protocoles médicaux
│   ├── regles.json                          # ~50 règles hospitalières
│   ├── protocoles.index                     # Index FAISS standard
│   └── protocoles_fast.index                # Index FAISS optimisé (simulation)
│
├── 📂 storage/                               # Stockage persistant
│   ├── guardrail.pkl                        # Modèle guardrail ML entraîné
│   └── logs/                                # Logs système (si activés)
│
└── 📂 docs/                                  # Documentation
    ├── img/                                 # Logo et captures
    └── notice_guardrail.md                  # Notice technique guardrails

Emergency_Manager - Système agentique IA pour les urgences hospitalières
Groupe 3, Master 2 SISE, Université Lyon 2, 2024-2025