Upload 25 files

Dockerfile

@@ -0,0 +1,39 @@
+FROM python:3.10-slim
+
+# Optimizations for RunPod / Production
+# 1. Prevent Python from buffering stdout/stderr (ensures logs show up immediately in RunPod console)
+ENV PYTHONUNBUFFERED=1
+# 2. Prevent Python from writing .pyc files
+ENV PYTHONDONTWRITEBYTECODE=1
+
+WORKDIR /app
+
+# Install system dependencies
+# 'build-essential' is often needed for compiling python packages
+# 'curl' is added for the Healthcheck
+RUN apt-get update && apt-get install -y \
+    build-essential \
+    curl \
+    && rm -rf /var/lib/apt/lists/*
+
+# Copy requirements first to leverage Docker cache
+COPY requirements.txt .
+
+# Install Python dependencies
+RUN pip install --no-cache-dir --upgrade pip && \
+    pip install --no-cache-dir -r requirements.txt
+
+# Copy the rest of the application
+COPY . .
+
+# Expose the API port
+EXPOSE 8000
+
+# Healthcheck (Optional but recommended for RunPod reliability)
+# It pings the root endpoint to ensure the server is responsive
+HEALTHCHECK --interval=30s --timeout=30s --start-period=5s --retries=3 \
+    CMD curl -f http://0.0.0.0:8000/ || exit 1
+
+# Launch the FastAPI server
+# 0.0.0.0 is critical for container networking
+CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "8000"]

README.md

@@ -1,12 +1,8 @@
 ---
-title: Smartiag
-emoji: 👁
-colorFrom: indigo
-colorTo: red
-sdk: gradio
-sdk_version: 6.2.0
-app_file: app.py
-pinned: false
+title: SmartDiag Backend
+emoji: ⚕️
+colorFrom: blue
+colorTo: indigo
+sdk: docker
+app_port: 8000
 ---
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

agents/anamnesis.py

@@ -0,0 +1,79 @@
+from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder
+from llm_factory import get_llm
+from langchain_core.messages import HumanMessage, AIMessage
+from models import AgentState
+from typing import List
+
+llm = get_llm(model_type="text", temperature=0.7)
+
+system_prompt = """You are a highly advanced Clinical Copilot (AI Doctor Assistant).
+Your role is to assist the physician by analyzing patient data, suggesting diagnoses, and recommending exams.
+
+### 1. MODE: INTAKE ANALYSIS (Critical)
+IF the user provides a summary of patient data (Name, Age, Symptoms, Vitals), you MUST output a structured clinical assessment in FRENCH:
+
+**🚨 ANALYSE CLINIQUE IMMÉDIATE**
+*   **Synthèse**: 1 sentence summary of the patient's state (Stable/Unstable).
+*   **Red Flags**: List any abnormal vitals or worrying symptoms (e.g., "Hypertension Sévère", "SpO2 Basse").
+
+**🧐 HYPOTHÈSES DIAGNOSTIQUES (Probabilités)**
+1.  **[Most Likely]**: Explanation.
+2.  **[Plausible]**: Explanation.
+3.  **[To rule out]**: Explanation (Red Flag).
+
+**✅ CONDUITE À TENIR IMMÉDIATE**
+*   List 3-4 specific exams to order NOW (e.g., ECG, Troponine, Radio Thorax).
+*   Immediate treatments if urgent (e.g., Oxygen, Aspirin).
+
+**❓ QUESTIONS D'INVESTIGATION**
+*   Ask 3 precises questions to the doctor/patient to narrow down the diagnosis (e.g., "La douleur irradie-t-elle dans le bras gauche?", "Avez-vous des antécédents de phlébite?").
+
+---
+
+### 2. MODE: ONGOING CONSULTATION
+For subsequent messages:
+- Acknowledge the new information.
+- Update your hypothesis.
+- Suggest next steps.
+- Be concise.
+
+### TONE & STYLE
+- Professional, efficient, "Doctor-to-Doctor" tone.
+- USE FRENCH LANGUAGE unless told otherwise.
+- USE MARKDOWN for bolding and lists.
+"""
+
+prompt = ChatPromptTemplate.from_messages([
+    ("system", system_prompt),
+    MessagesPlaceholder(variable_name="history"),
+    ("user", "{input}")
+])
+
+chain = prompt | llm
+
+from services.rag_service import rag_service
+
+async def run_anamnesis_agent(history: List[dict], user_input: str) -> str:
+    # Fetch RAG Context - DISABLE GLOBAL CONTEXT TO PREVENT LEAKAGE BETWEEN PATIENTS IN POC
+    # rag_context = rag_service.get_context("default")
+    rag_context = "" 
+    
+    # Prepend Context info if found
+    messages = []
+    if rag_context:
+        messages.append(HumanMessage(content=f"[SYSTEM: Patient Context Loaded from RAG]\n{rag_context}\n\n[End of Context]"))
+    
+    for msg in history:
+        if msg['role'] == 'user':
+            messages.append(HumanMessage(content=msg['content']))
+        elif msg['role'] == 'assistant':
+            messages.append(AIMessage(content=msg['content']))
+    
+    # Check if this is an "Intake Analysis" request (detected by keyword in system prompt from frontend)
+    if "intake data" in user_input.lower() or "patient:" in user_input.lower():
+        # Temporarily boost temperature for creative medical reasoning
+        # (Not possible to change runtime param easily without refactor, but prompt engineering helps)
+        pass
+
+    response = await chain.ainvoke({"history": messages, "input": user_input})
+    return response.content

agents/bio_analysis.py

@@ -0,0 +1,112 @@
+import json
+from langchain_core.messages import HumanMessage
+from llm_factory import get_llm
+import base64
+
+# Initialize both models
+text_llm = get_llm(model_type="text", temperature=0.1)
+vision_llm = get_llm(model_type="vision", temperature=0.1)
+
+import io
+from pypdf import PdfReader
+from services.rag_service import rag_service
+
+async def run_bio_analysis_agent(file_data: bytes, mime_type: str) -> dict:
+    try:
+        print(f"Processing file with mime_type: {mime_type}")
+        
+        prompt_text = """
+        Tu es un Expert Biologiste et Pharmacien.
+        
+        TA MISSION :
+        Analyser ce rapport de laboratoire et extraire les données structurées.
+        
+        FORMAT DE SORTIE ATTENDU (JSON uniquement) :
+        {
+          "patient_name": "Nom du patient ou 'Inconnu'",
+          "date": "Date du rapport ou 'Inconnue'",
+          "critical_alerts": ["Liste des valeurs critiques nécessitant une attention immédiate"],
+          "results": [
+            {
+              "test_name": "Nom de l'analyse (ex: Hémoglobine)",
+              "value": "Valeur numérique (ex: 10.5)",
+              "unit": "Unité (ex: g/dL)",
+              "ref_range": "Plage de référence (ex: 12-16)",
+              "status": "LOW" | "HIGH" | "NORMAL",
+              "interpretation": "Brève interprétation clinique"
+            }
+          ],
+          "global_interpretation": "Synthèse globale de l'état du patient basés sur les résultats.",
+          "recommendations": ["Actions recommandées"]
+        }
+        
+        RÉPOND UNIQUEMENT AVEC LE JSON. PAS DE MARKDOWN.
+        """
+
+        message_content = []
+        selected_llm = text_llm # Default to text
+
+        if mime_type == "application/pdf":
+            # Extract text from PDF
+            try:
+                pdf_file = io.BytesIO(file_data)
+                reader = PdfReader(pdf_file)
+                extracted_text = ""
+                for page in reader.pages:
+                    extracted_text += page.extract_text() + "\n"
+                
+                print(f"Extracted {len(extracted_text)} chars from PDF")
+                message_content.append({"type": "text", "text": prompt_text + "\n\nVOICI LE CONTENU DU RAPPORT :\n" + extracted_text})
+                selected_llm = text_llm # Use DeepSeek for text
+            except Exception as pdf_err:
+                print(f"PDF Extraction failed: {pdf_err}")
+                return {"error": "PDF parsing failed", "details": str(pdf_err)}
+
+        elif mime_type.startswith("image/"):
+            # Use Vision for images
+            b64_data = base64.b64encode(file_data).decode("utf-8")
+            message_content.append({"type": "text", "text": prompt_text})
+            message_content.append({
+                "type": "image_url",
+                "image_url": {"url": f"data:{mime_type};base64,{b64_data}"}
+            })
+            selected_llm = vision_llm # Use Gemini for Vision
+        else:
+            return {"error": "Unsupported file type", "details": mime_type}
+        
+        message = HumanMessage(content=message_content)
+        
+        response = await selected_llm.ainvoke([message])
+        
+        # Clean up response to ensure valid JSON
+        content = response.content.strip()
+        if content.startswith("```json"):
+            content = content[7:-3]
+        elif content.startswith("```"):
+            content = content[3:-3]
+            
+        try:
+            # SAVE TO RAG (Mocking 'default' patient ID for this POC)
+            rag_service.add_document("default", f"Résultat Analyse Labo:\n{content}", "lab_result")
+            
+            return json.loads(content)
+        except json.JSONDecodeError as e:
+            print(f"JSON Parse Error: {e}")
+            print(f"Raw Content: {content}")
+            
+            # Even on JSON error, save raw text so context is kept
+            rag_service.add_document("default", f"Tentative Analyse Labo (Brut):\n{content}", "lab_result_raw")
+            
+            return {
+                "error": "Failed to parse JSON",
+                "raw_content": content
+            }
+            
+    except Exception as e:
+        print(f"CRITICAL ERROR in run_bio_analysis_agent: {str(e)}")
+        import traceback
+        traceback.print_exc()
+        return {
+            "error": "Analysis failed",
+            "details": str(e)
+        }

agents/diagnosis.py

@@ -0,0 +1,40 @@
+from langchain_core.prompts import ChatPromptTemplate
+from llm_factory import get_llm
+
+llm = get_llm(model_type="text", temperature=0.2)
+
+system_prompt = """You are an expert medical Diagnostician.
+Your goal is to analyze patient symptoms, history, and biological lab results (if available) to provide a differential diagnosis.
+
+Rules:
+1. **LANGUAGE: FRENCH ONLY.** The entire output must be in French.
+2. **INTEGRATION:** If biological results are provided, use them to CONFIRM or RULE OUT hypotheses. Cite specific values (e.g., "L'anémie est confirmée par l'hémoglobine à 9g/dL").
+3. Format your response clearly:
+   - **Diagnostic Principal**: The most likely cause.
+   - **Justification**: Combine clinical signs + biological proofs.
+   - **Diagnostics Différentiels**: Other possibilities.
+   - **Signes de Gravité (Red Flags)**: Any urgent warnings.
+4. Be concise and professional.
+"""
+
+prompt = ChatPromptTemplate.from_messages([
+    ("system", system_prompt),
+    ("user", """Patient Info: {patient_info}
+
+Symptom Summary (Chat): {symptom_summary}
+
+Biological Analysis (Labs): {bio_data}
+""")
+])
+
+chain = prompt | llm
+
+async def run_diagnosis_agent(patient_info: dict, symptom_summary: str, bio_data: dict = None) -> str:
+    bio_text = str(bio_data) if bio_data else "Aucune donnée biologique fournie."
+    
+    response = await chain.ainvoke({
+        "patient_info": str(patient_info),
+        "symptom_summary": symptom_summary,
+        "bio_data": bio_text
+    })
+    return response.content

agents/followup.py

@@ -0,0 +1,45 @@
+from llm_factory import get_llm
+from langchain_core.prompts import PromptTemplate
+import os
+from dotenv import load_dotenv
+
+load_dotenv()
+
+def get_followup_agent():
+    llm = get_llm(model_type="text", temperature=0.2)
+    
+    template = """
+    Tu es un Agent de Suivi Médical (Care Manager).
+    
+    TA MISSION :
+    Créer un plan de surveillance à domicile clair et rassurant pour le patient, basé sur son diagnostic et son traitement.
+    
+    DIAGNOSTIC : {diagnosis}
+    TRAITEMENT : {treatment}
+    
+    GÉNÈRE UN PLAN DE SUIVI (En Français, ton empathique et clair) :
+    
+    📅 QUAND CONSULTER À NOUVEAU ?
+    - [Délai ou condition précise]
+    
+    🚨 SIGNES D'ALERTE (Red Flags) - "Revenez aux urgences si..." :
+    - [Liste des symptômes graves à surveiller]
+    
+    🏠 CONSEILS DE SURVEILLANCE :
+    - [Ex: Prise de température, hydratation, repos...]
+    """
+    
+    prompt = PromptTemplate(
+        input_variables=["diagnosis", "treatment"],
+        template=template,
+    )
+    
+    return prompt | llm
+
+async def run_followup_agent(diagnosis: str, treatment: str) -> str:
+    agent = get_followup_agent()
+    response = await agent.ainvoke({
+        "diagnosis": diagnosis,
+        "treatment": treatment
+    })
+    return response.content

agents/imaging.py

@@ -0,0 +1,42 @@
+from llm_factory import get_llm
+from langchain_core.prompts import PromptTemplate
+import os
+from dotenv import load_dotenv
+
+load_dotenv()
+
+def get_imaging_agent():
+    llm = get_llm(model_type="text", temperature=0.1)
+    
+    template = """
+    Tu es un Radiologue Expert (IA).
+    
+    TA MISSION :
+    Analyser la description d'une imagerie médicale (Radio, Scanner, IRM, Échographie) pour en extraire les anomalies significatives et suggérer une conclusion clinique.
+    
+    DESCRIPTION DE L'IMAGERIE / COMPTE-RENDU :
+    {imaging_desc}
+    
+    CONTEXTE CLINIQUE :
+    {clinical_context}
+    
+    RÉPONSE ATTENDUE (En Français) :
+    1. 🔍 ANOMALIES DÉTECTÉES : [Liste à puces]
+    2. 🩺 INTERPRÉTATION CLINIQUE : [Ce que cela signifie pour le patient]
+    3. ⚠️ RECOMMANDATION : [Ex: Avis spécialisé, examen complémentaire, urgence]
+    """
+    
+    prompt = PromptTemplate(
+        input_variables=["imaging_desc", "clinical_context"],
+        template=template,
+    )
+    
+    return prompt | llm
+
+async def run_imaging_agent(imaging_desc: str, clinical_context: str) -> str:
+    agent = get_imaging_agent()
+    response = await agent.ainvoke({
+        "imaging_desc": imaging_desc,
+        "clinical_context": clinical_context
+    })
+    return response.content

agents/intake.py

@@ -0,0 +1,34 @@
+from langchain_core.prompts import ChatPromptTemplate
+from llm_factory import get_llm
+from langchain_core.output_parsers import JsonOutputParser
+from models import Patient
+import os
+
+# Initialize LLM
+llm = get_llm(model_type="text", temperature=0.1)
+
+# Parser
+parser = JsonOutputParser(pydantic_object=Patient)
+
+# Prompt
+system_prompt = """You are a medical receptionist agent. Your goal is to extract patient information from a natural language introduction.
+Extract the following fields: name, age, gender, and any mentioned medical history.
+If a field is missing, leave it as null or infer it if obvious.
+Return the result as a JSON object matching the Patient schema.
+"""
+
+prompt = ChatPromptTemplate.from_messages([
+    ("system", system_prompt),
+    ("user", "{input}")
+])
+
+chain = prompt | llm | parser
+
+async def run_intake_agent(user_input: str) -> Patient:
+    try:
+        result = await chain.ainvoke({"input": user_input})
+        return Patient(**result)
+    except Exception as e:
+        # Fallback or error handling
+        print(f"Error in intake agent: {e}")
+        return Patient(name="Unknown", age=0, gender="Unknown")

agents/pharmacist.py

@@ -0,0 +1,48 @@
+from llm_factory import get_llm
+from langchain_core.prompts import PromptTemplate
+import os
+from dotenv import load_dotenv
+
+load_dotenv()
+
+def get_pharmacist_agent():
+    llm = get_llm(model_type="text", temperature=0.1)
+    
+    template = """
+    Tu es un Pharmacien Clinicien Expert. Ta mission est de sécuriser la prescription.
+    
+    PATIENT :
+    - Nom : {patient_name}
+    - Âge : {patient_age}
+    - Antécédents : {history}
+    
+    ORDONNANCE PROPOSÉE :
+    {prescription}
+    
+    ANALYSE REQUISE :
+    1. Vérifier les contre-indications absolues avec les antécédents.
+    2. Vérifier les interactions médicamenteuses majeures.
+    3. Vérifier les dosages (si fournis) par rapport à l'âge.
+    
+    RÉPONSE (En Français) :
+    - STATUT : [VALIDÉ ✅ / ATTENTION ⚠️ / DANGER ⛔]
+    - ANALYSE : [Commentaire bref]
+    - RECOMMANDATION : [Si nécessaire, correction suggérée]
+    """
+    
+    prompt = PromptTemplate(
+        input_variables=["patient_name", "patient_age", "history", "prescription"],
+        template=template,
+    )
+    
+    return prompt | llm
+
+async def run_pharmacist_agent(patient_name: str, patient_age: int, history: str, prescription: str) -> str:
+    agent = get_pharmacist_agent()
+    response = await agent.ainvoke({
+        "patient_name": patient_name,
+        "patient_age": patient_age,
+        "history": history,
+        "prescription": prescription
+    })
+    return response.content

agents/planner.py

@@ -0,0 +1,31 @@
+from langchain_core.prompts import ChatPromptTemplate
+from llm_factory import get_llm
+
+llm = get_llm(model_type="text", temperature=0.2)
+
+system_prompt = """You are a Medical Action Planner.
+Based on the provided diagnosis, recommend the next steps.
+
+Rules:
+1. **LANGUAGE: FRENCH ONLY.**
+2. Structure the plan as follows:
+   - **Examens Complémentaires**: Labs, Imaging (X-Ray, MRI, etc.). Mark URGENT if needed.
+   - **Traitement**: Medications (Generic names), dosage instructions.
+   - **Orientation**: Specialist referrals (Cardiologist, Pneumologist, etc.).
+   - **Conseils**: Lifestyle or monitoring advice.
+3. If the diagnosis suggests an emergency, emphasize immediate hospital admission or urgent specialist consultation.
+Be specific about which agent (e.g., "Bio Analysis Agent") would handle which part if applicable, but primarily output the medical actions.
+"""
+
+prompt = ChatPromptTemplate.from_messages([
+    ("system", system_prompt),
+    ("user", "Diagnosis Report: {diagnosis_report}")
+])
+
+chain = prompt | llm
+
+async def run_planner_agent(diagnosis_report: str) -> str:
+    response = await chain.ainvoke({
+        "diagnosis_report": diagnosis_report
+    })
+    return response.content

agents/radiology.py

@@ -0,0 +1,178 @@
+import os
+import io
+import pydicom
+import numpy as np
+from PIL import Image
+import base64
+import httpx
+import asyncio
+from dotenv import load_dotenv
+
+load_dotenv()
+
+HF_TOKEN = os.getenv("HUGGINGFACE_TOKEN")
+Z_AI_API_KEY = os.getenv("Z_AI_API_KEY")
+ROBOFLOW_API_KEY = os.getenv("ROBOFLOW_API_KEY")
+HEADERS_HF = {"Authorization": f"Bearer {HF_TOKEN}"}
+HEADERS_Z_AI = {"Authorization": f"Bearer {Z_AI_API_KEY}", "Content-Type": "application/json"}
+
+# List of models updated for 2026 SOTA
+MODELS = {
+    "fracture": "bone-fracture-vqdiz/1",             # Roboflow Object Detection (Local Docker)
+    "fracture_vlm": "AIRI-Institute/chexfract-maira2",      # Medical VLM for Fracture Reports
+    "mammo": "ianpan/mammoscreen",
+    "breast_tissue": "nateraw/breast-cancer-classification",
+    "glm": "glm-4.6v"
+}
+
+async def call_hf_api(model_id, payload):
+    # Use standard Inference API endpoint for 2026 models
+    api_url = f"https://api-inference.huggingface.co/models/{model_id}"
+    
+    async with httpx.AsyncClient(timeout=60.0) as client:
+        # Some models expect raw bytes, others expect json with 'inputs'
+        # For our 2026 ViT models, passing bytes directly often works better for image-classification
+        if "inputs" in payload and isinstance(payload["inputs"], str):
+            # If it's base64, we decode it back to bytes for the inference API raw call
+            try:
+                img_data = base64.b64decode(payload["inputs"])
+                response = await client.post(api_url, headers=HEADERS_HF, content=img_data)
+            except:
+                response = await client.post(api_url, headers=HEADERS_HF, json=payload)
+        else:
+            response = await client.post(api_url, headers=HEADERS_HF, json=payload)
+        
+        if response.status_code == 503:
+            return {"error": "Model is loading", "details": response.json()}
+        
+        return response.json()
+
+async def call_roboflow_api(model_id, image_bytes):
+    """
+    Appelle le serveur d'inférence Roboflow LOCAL (Docker).
+    Configuration basée sur la version RAG finale.
+    """
+    # On utilise exactement les IDs de ton projet fonctionnel
+    API_KEY = os.getenv("ROBOFLOW_API_KEY", "Ac4Ngxa813phZbyPDo64")
+    PROJECT_ID = "bone-fracture-vqdiz"
+    MODEL_VERSION = "1"
+    
+    # URL de ton Docker local
+    api_url = f"http://localhost:9001/{PROJECT_ID}/{MODEL_VERSION}?api_key={API_KEY}"
+    
+    async with httpx.AsyncClient(timeout=30.0) as client:
+        # Envoi en multipart/form-data comme dans ton code med-ai-final
+        files = {'file': ("image.jpg", image_bytes, "image/jpeg")}
+        try:
+            response = await client.post(api_url, files=files)
+            
+            print(f"DEBUG Roboflow Local: URL={api_url} Status={response.status_code}")
+            
+            if response.status_code != 200:
+                print(f"DEBUG Roboflow Error Detail: {response.text}")
+                return {"error": response.text, "status": response.status_code}
+            
+            return response.json()
+        except Exception as e:
+            print(f"DEBUG Roboflow Local Exception: {str(e)}")
+            return {
+                "error": "Serveur d'inférence local introuvable.", 
+                "message": "Assurez-vous que le conteneur Docker tourne (inference server start).",
+                "details": str(e)
+            }
+
+async def call_z_ai_api(payload):
+    api_url = "https://api.z.ai/api/paas/v4/chat/completions"
+    
+    async with httpx.AsyncClient(timeout=90.0) as client:
+        response = await client.post(api_url, headers=HEADERS_Z_AI, json=payload)
+        return response.json()
+
+def convert_dicom_to_jpg(dicom_bytes: bytes) -> bytes:
+    """Convertit un fichier DICOM en image JPEG exploitable par l'IA."""
+    try:
+        ds = pydicom.dcmread(io.BytesIO(dicom_bytes))
+        pixel_array = ds.pixel_array
+        
+        if hasattr(ds, 'RescaleIntercept') and hasattr(ds, 'RescaleSlope'):
+            pixel_array = pixel_array.astype(np.float32) * ds.RescaleSlope + ds.RescaleIntercept
+            
+        p_min, p_max = np.min(pixel_array), np.max(pixel_array)
+        if p_max > p_min:
+            pixel_array = ((pixel_array - p_min) / (p_max - p_min) * 255).astype(np.uint8)
+        else:
+            pixel_array = pixel_array.astype(np.uint8)
+            
+        img = Image.fromarray(pixel_array)
+        if img.mode != 'RGB':
+            img = img.convert('RGB')
+            
+        buf = io.BytesIO()
+        img.save(buf, format="JPEG", quality=95)
+        return buf.getvalue()
+    except Exception as e:
+        print(f"Erreur conversion DICOM: {e}")
+        return None
+
+async def run_radiology_agent(image_bytes: bytes, model_type: str, question: str = None) -> dict:
+    # Détection DICOM
+    is_dicom = False
+    if len(image_bytes) > 132 and image_bytes[128:132] == b"DICM":
+        is_dicom = True
+    
+    if is_dicom:
+        converted = convert_dicom_to_jpg(image_bytes)
+        if converted:
+            image_bytes = converted
+            print("Image DICOM convertie avec succès.")
+
+    img_str = base64.b64encode(image_bytes).decode("utf-8")
+
+    if model_type == "glm":
+        payload = {
+            "model": "glm-4.6v",
+            "messages": [
+                {
+                    "role": "user",
+                    "content": [
+                        {
+                            "type": "text",
+                            "text": f"En tant qu'expert radiologue : {question if question else 'Décrivez cette imagerie et les anomalies potentielles.'}"
+                        },
+                        {
+                            "type": "image_url",
+                            "image_url": { "url": f"data:image/jpeg;base64,{img_str}" }
+                        }
+                    ]
+                }
+            ]
+        }
+        result = await call_z_ai_api(payload)
+        if "choices" in result:
+            return result["choices"][0]["message"]["content"]
+        return result
+        
+    elif model_type == "fracture_vlm":
+        # Specific handling for 2026 ChexFract specialized VLM
+        model_id = MODELS.get("fracture_vlm")
+        # For VLMs on HF, they often expect a specific format or we use the chat template via inference
+        payload = {
+            "inputs": {
+                "image": img_str,
+                "text": question if question else "Describe any fractures in this X-ray and propose a BIRADS/Classification."
+            }
+        }
+        return await call_hf_api(model_id, payload)
+        
+    else:
+        # Standard classification or specialized detection
+        model_id = MODELS.get(model_type)
+        
+        if model_type == "fracture":
+            # Roboflow expects binary or base64 but our helper uses binary
+            return await call_roboflow_api(model_id, image_bytes)
+            
+        payload = {
+            "inputs": img_str
+        }
+        return await call_hf_api(model_id, payload)

agents/report.py

@@ -0,0 +1,84 @@
+from langchain_core.prompts import ChatPromptTemplate
+from llm_factory import get_llm
+from fpdf import FPDF
+import qrcode
+import os
+
+llm = get_llm(model_type="text", temperature=0.1)
+
+system_prompt = """You are a Medical Report Generator.
+Based on the diagnosis and action plan, write a formal medical report.
+Include:
+1. Patient Summary.
+2. Clinical Findings.
+3. Diagnosis.
+4. Recommendations & Prescription.
+5. A polite closing.
+
+Format it as a clean text that can be put into a PDF.
+"""
+
+prompt = ChatPromptTemplate.from_messages([
+    ("system", system_prompt),
+    ("user", "Patient: {patient_info}\nDiagnosis: {diagnosis}\nPlan: {plan}")
+])
+
+chain = prompt | llm
+
+async def generate_report_content(patient_info: dict, diagnosis: str, plan: str) -> str:
+    response = await chain.ainvoke({
+        "patient_info": str(patient_info),
+        "diagnosis": diagnosis,
+        "plan": plan
+    })
+    return response.content
+
+def create_pdf_report(content: str, patient_name: str, filename: str = "report.pdf"):
+    pdf = FPDF()
+    pdf.add_page()
+    pdf.set_font("Arial", size=12)
+    
+    # Header
+    pdf.set_font("Arial", 'B', 16)
+    pdf.cell(200, 10, txt="Medical Report", ln=1, align='C')
+    pdf.set_font("Arial", size=12)
+    pdf.cell(200, 10, txt="Dr. Amine Tounsi", ln=1, align='C')
+    pdf.ln(10)
+    
+    # Content
+    # Sanitize content for FPDF (latin-1)
+    replacements = {
+        "\u2019": "'",  # Smart quote
+        "\u2018": "'",
+        "\u201c": '"',  # Smart double quotes
+        "\u201d": '"',
+        "\u2013": "-",  # En dash
+        "\u2014": "-",  # Em dash
+        "\u2264": "<=", # Less than or equal
+        "\u2265": ">=", # Greater than or equal
+        "…": "...",
+        "–": "-"
+    }
+    for char, replacement in replacements.items():
+        content = content.replace(char, replacement)
+    
+    # Final fallback: encode to latin-1, replace errors with '?', then decode
+    content = content.encode('latin-1', 'replace').decode('latin-1')
+
+    pdf.multi_cell(0, 10, txt=content)
+    
+    # QR Code
+    qr = qrcode.QRCode(version=1, box_size=10, border=5)
+    qr.add_data(f"Patient: {patient_name} - Verified by Dr. Tounsi")
+    qr.make(fit=True)
+    img = qr.make_image(fill_color="black", back_color="white")
+    img.save("temp_qr.png")
+    
+    pdf.ln(10)
+    pdf.image("temp_qr.png", w=30)
+    os.remove("temp_qr.png")
+    
+    # Ensure directory exists
+    os.makedirs("reports", exist_ok=True)
+    pdf.output(f"reports/{filename}")
+    return f"reports/{filename}"

agents/triage.py

@@ -0,0 +1,42 @@
+from llm_factory import get_llm
+from langchain_core.prompts import PromptTemplate
+import os
+from dotenv import load_dotenv
+
+load_dotenv()
+
+def get_triage_agent():
+    llm = get_llm(model_type="text", temperature=0.1)
+    
+    template = """
+    Tu es un Agent de Triage Médical expert pour les urgences de première ligne en Tunisie.
+    
+    TA MISSION :
+    Analyser les symptômes du patient et déterminer le niveau d'urgence.
+    
+    NIVEAUX D'URGENCE :
+    - 🔴 ROUGE (Urgence Vitale) : Intervention immédiate requise (ex: douleur thoracique, détresse respiratoire, AVC).
+    - 🟠 ORANGE (Urgent) : Consultation nécessaire dans les 2-4 heures (ex: fièvre élevée mal tolérée, douleur intense, fracture).
+    - 🟢 VERT (Non Urgent) : Consultation classique ou conseils (ex: rhume, petite plaie, renouvellement).
+    
+    SYMPTÔMES DU PATIENT :
+    {symptoms}
+    
+    FORMAT DE RÉPONSE ATTENDU (Strictement en Français) :
+    
+    NIVEAU : [ROUGE/ORANGE/VERT]
+    JUSTIFICATION : [Explication courte et précise en 1 phrase]
+    ACTION RECOMMANDÉE : [Ex: "Appeler le 190", "Consultation immédiate", "Prendre RDV demain"]
+    """
+    
+    prompt = PromptTemplate(
+        input_variables=["symptoms"],
+        template=template,
+    )
+    
+    return prompt | llm
+
+async def run_triage_agent(symptoms: str) -> str:
+    agent = get_triage_agent()
+    response = await agent.ainvoke({"symptoms": symptoms})
+    return response.content

check_mammo_api.py

@@ -0,0 +1,13 @@
+from gradio_client import Client
+import json
+
+def check_api():
+    try:
+        client = Client("ianpan/screening-mammography")
+        print("API Information:")
+        print(client.view_api(return_format="json"))
+    except Exception as e:
+        print(f"Error: {e}")
+
+if __name__ == "__main__":
+    check_api()

list_models.py

@@ -0,0 +1,49 @@
+import os
+from dotenv import load_dotenv
+load_dotenv()
+
+# Ensure the key is available for the client if it expects GEMINI_API_KEY
+if "GOOGLE_API_KEY" in os.environ:
+    os.environ["GEMINI_API_KEY"] = os.environ["GOOGLE_API_KEY"]
+
+try:
+    from google import genai
+    from google.genai.errors import APIError
+except ImportError:
+    # Fallback to google.generativeai if google.genai is not found (older SDK)
+    import google.generativeai as genai
+    print("Using google.generativeai SDK fallback...")
+    
+    try:
+        genai.configure(api_key=os.environ["GOOGLE_API_KEY"])
+        print("✨ Modèles d'IA disponibles (via google-generativeai) :")
+        print("-------------------------------")
+        for model in genai.list_models():
+            if 'generateContent' in model.supported_generation_methods:
+                print(f"- **{model.name}**")
+        exit(0)
+    except Exception as e:
+        print(f"Fallback failed: {e}")
+        exit(1)
+
+def lister_modeles_disponibles():
+    """Liste tous les modèles disponibles via l'API Google GenAI."""
+    try:
+        # Initialisation du client (il lira la clé API automatiquement)
+        client = genai.Client(api_key=os.environ.get("GOOGLE_API_KEY"))
+        
+        print("✨ Modèles d'IA disponibles :")
+        print("-------------------------------")
+        
+        # Récupération de la liste des modèles
+        for model in client.models.list():
+            # Afficher le nom du modèle et sa description (facultatif)
+            print(f"- **{model.name}**")
+            # print(f"  Description: {model.description}")
+            
+    except Exception as e:
+        print(f"Erreur lors de la connexion à l'API : {e}")
+        print("Vérifiez que votre clé API est valide et correctement configurée.")
+
+# Exécution de la fonction
+lister_modeles_disponibles()

llm_factory.py

@@ -0,0 +1,49 @@
+import os
+from langchain_openai import ChatOpenAI
+from langchain_google_genai import ChatGoogleGenerativeAI
+from dotenv import load_dotenv
+
+load_dotenv()
+
+def get_llm(model_type="text", temperature=0.1):
+    """
+    Factory to get the appropriate LLM based on task type.
+    
+    Args:
+        model_type: "text" (DeepSeek) or "vision" (Gemini)
+        temperature: Creativity level
+    """
+    
+    # Prioritize Gemini as requested for the demo
+    google_key = os.getenv("GOOGLE_API_KEY")
+    if google_key:
+        return ChatGoogleGenerativeAI(
+            model="gemini-2.5-flash", 
+            temperature=temperature,
+            google_api_key=google_key
+        )
+    
+    if model_type == "text":
+        api_key = os.getenv("DEEPSEEK_API_KEY")
+        if not api_key:
+            raise ValueError("No API keys found (DeepSeek or Google)")
+            
+        return ChatOpenAI(
+            model="deepseek-chat",
+            api_key=api_key,
+            base_url="https://api.deepseek.com",
+            temperature=temperature
+        )
+        
+    elif model_type == "vision":
+        # Vision specific logic if needed, but Gemini handles both
+        if google_key:
+            return ChatGoogleGenerativeAI(
+                model="gemini-2.5-flash", 
+                temperature=temperature,
+                google_api_key=google_key
+            )
+        raise ValueError("Google API Key required for vision")
+        
+    else:
+        raise ValueError(f"Unknown model_type: {model_type}")

main.py

@@ -0,0 +1,265 @@
+from dotenv import load_dotenv
+import os
+import httpx
+import base64
+load_dotenv()
+
+from fastapi import FastAPI, HTTPException, Form
+from fastapi.middleware.cors import CORSMiddleware
+from pydantic import BaseModel
+from typing import List, Dict, Any, Optional
+from models import Patient, AgentState
+from agents.intake import run_intake_agent
+from agents.anamnesis import run_anamnesis_agent
+from agents.diagnosis import run_diagnosis_agent
+from agents.planner import run_planner_agent
+
+
+app = FastAPI(title="Medical Multi-Agent POC")
+
+# CORS configuration
+origins = ["*"]
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=origins,
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+class IntakeRequest(BaseModel):
+    input: str
+
+class AnamnesisRequest(BaseModel):
+    history: List[Dict[str, str]]
+    input: str
+
+class DiagnosisRequest(BaseModel):
+    patient_info: Dict[str, Any]
+    symptom_summary: str
+    bio_data: Optional[Dict[str, Any]] = None
+
+class PlannerRequest(BaseModel):
+    diagnosis_report: str
+
+@app.get("/")
+async def root():
+    return {"message": "Medical Multi-Agent POC Backend is running"}
+
+@app.post("/api/intake", response_model=Patient)
+async def intake_endpoint(request: IntakeRequest):
+    return await run_intake_agent(request.input)
+
+@app.post("/api/anamnesis")
+async def anamnesis_endpoint(request: AnamnesisRequest):
+    response = await run_anamnesis_agent(request.history, request.input)
+    return {"response": response}
+
+@app.post("/api/diagnosis")
+async def diagnosis_endpoint(request: DiagnosisRequest):
+    report = await run_diagnosis_agent(request.patient_info, request.symptom_summary, request.bio_data)
+    return {"report": report}
+
+@app.post("/api/planner")
+async def planner_endpoint(request: PlannerRequest):
+    plan = await run_planner_agent(request.diagnosis_report)
+    return {"plan": plan}
+
+# --- New Agents Endpoints ---
+
+from agents.triage import run_triage_agent
+from agents.pharmacist import run_pharmacist_agent
+from agents.imaging import run_imaging_agent
+from agents.followup import run_followup_agent
+
+class TriageRequest(BaseModel):
+    symptoms: str
+
+class PharmacistRequest(BaseModel):
+    patient_name: str
+    patient_age: int
+    history: str
+    prescription: str
+
+class ImagingRequest(BaseModel):
+    imaging_desc: str
+    clinical_context: str
+
+class FollowupRequest(BaseModel):
+    diagnosis: str
+    treatment: str
+
+@app.post("/api/triage")
+async def triage_endpoint(request: TriageRequest):
+    result = await run_triage_agent(request.symptoms)
+    return {"result": result}
+
+@app.post("/api/pharmacist")
+async def pharmacist_endpoint(request: PharmacistRequest):
+    result = await run_pharmacist_agent(request.patient_name, request.patient_age, request.history, request.prescription)
+    return {"result": result}
+
+@app.post("/api/imaging")
+async def imaging_endpoint(request: ImagingRequest):
+    result = await run_imaging_agent(request.imaging_desc, request.clinical_context)
+    return {"result": result}
+
+@app.post("/api/followup")
+async def followup_endpoint(request: FollowupRequest):
+    result = await run_followup_agent(request.diagnosis, request.treatment)
+    return {"result": result}
+
+from agents.bio_analysis import run_bio_analysis_agent
+from agents.radiology import run_radiology_agent
+from agents.report import generate_report_content, create_pdf_report
+from fastapi.responses import FileResponse
+
+from fastapi import UploadFile, File
+
+class ReportRequest(BaseModel):
+    patient_info: Dict[str, Any]
+    diagnosis: str
+    plan: str
+
+@app.post("/api/bio-analysis")
+async def bio_analysis_endpoint(file: UploadFile = File(...)):
+    content = await file.read()
+    analysis = await run_bio_analysis_agent(content, file.content_type)
+    return {"analysis": analysis}
+
+@app.post("/api/radiology-analysis")
+async def radiology_analysis_endpoint(
+    file: UploadFile = File(...), 
+    model_type: str = Form(...), 
+    question: Optional[str] = Form(None)
+):
+    content = await file.read()
+    result = await run_radiology_agent(content, model_type, question)
+    return {"result": result}
+
+@app.post("/api/generate-report")
+async def report_endpoint(request: ReportRequest):
+    content = await generate_report_content(request.patient_info, request.diagnosis, request.plan)
+    patient_name = request.patient_info.get("name", "patient").replace(" ", "_").lower()
+    filename = f"{patient_name}_report.pdf"
+    file_path = create_pdf_report(content, request.patient_info.get("name", "Unknown"), filename)
+    return {"content": content, "pdf_url": f"/reports/{filename}"}
+
+@app.get("/reports/{filename}")
+async def get_report(filename: str):
+    return FileResponse(f"reports/{filename}")
+
+import google.generativeai as genai
+import json
+
+@app.post("/api/collab-chat")
+async def collab_chat_endpoint(
+    text: str = Form(...),
+    history: str = Form(...),
+    file: Optional[UploadFile] = File(None)
+):
+    try:
+        # Load chat history
+        chat_history = json.loads(history)
+        
+        # Priority: GLM (VLM) for multimodal medical analysis
+        z_api_key = os.getenv("Z_AI_API_KEY")
+        
+        if not z_api_key:
+            return {"response": "Erreur: Clé API IA Vision (VLM) non configurée dans le fichier .env."}
+            
+        api_url = "https://api.z.ai/api/paas/v4/chat/completions"
+        headers = {
+            "Authorization": f"Bearer {z_api_key}",
+            "Content-Type": "application/json"
+        }
+        
+        # Convert history (Gemini format) to GLM format
+        messages = []
+        # Add system prompt for medical expertise
+        messages.append({
+            "role": "system", 
+            "content": "Tu es un expert médical SmartDiag. Analyse les documents et réponds aux médecins avec précision clinique."
+        })
+        
+        for h in chat_history:
+            role = "user" if h["role"] == "user" else "assistant"
+            # Extract text from parts
+            msg_text = ""
+            if isinstance(h["parts"], list) and len(h["parts"]) > 0:
+                msg_text = h["parts"][0].get("text", "")
+            elif isinstance(h["parts"], str):
+                msg_text = h["parts"]
+            
+            if msg_text:
+                messages.append({"role": role, "content": msg_text})
+        
+        # Prepare current content based on media type
+        if file:
+            current_content = []
+            extracted_text = ""
+            file_bytes = await file.read()
+            
+            if file.content_type.startswith("image/"):
+                img_b64 = base64.b64encode(file_bytes).decode("utf-8")
+                current_content.append({
+                    "type": "image_url",
+                    "image_url": {"url": f"data:{file.content_type};base64,{img_b64}"}
+                })
+            elif file.content_type == "application/pdf":
+                try:
+                    import io
+                    from pypdf import PdfReader
+                    pdf_file = io.BytesIO(file_bytes)
+                    reader = PdfReader(pdf_file)
+                    for page in reader.pages:
+                        extracted_text += page.extract_text() + "\n"
+                    
+                    if extracted_text:
+                        text = f"{text}\n\n[Contenu du PDF joint ({file.filename})]:\n{extracted_text}"
+                    else:
+                        return {"response": "Impossible d'extraire le texte de ce PDF (scan/image). Merci d'envoyer une capture d'écran."}
+                except Exception as pdf_err:
+                    print(f"PDF Error: {pdf_err}")
+                    return {"response": "Erreur lecture PDF."}
+            
+            # For VLM, content is a list
+            current_content.append({"type": "text", "text": text})
+            messages.append({"role": "user", "content": current_content})
+            model_name = "glm-4.6v"
+        else:
+            # Text only: Use GLM-4.6v as well for consistency, but with text-only payload
+            if not text.strip():
+                 return {"response": "Veuillez saisir un message."}
+            
+            # GLM-4V expects list content for consistency if we use that model
+            messages.append({
+                "role": "user", 
+                "content": [{"type": "text", "text": text}]
+            })
+            model_name = "glm-4.6v"
+        
+        payload = {
+            "model": model_name,
+            "messages": messages,
+            "temperature": 0.7,
+            "top_p": 0.9,
+            "stream": False
+        }
+        
+        async with httpx.AsyncClient(timeout=120.0) as client:
+            response = await client.post(api_url, headers=headers, json=payload)
+            if response.status_code == 200:
+                result = response.json()
+                return {"response": result["choices"][0]["message"]["content"]}
+            else:
+                error_msg = response.text
+                print(f"GLM API Error: {error_msg}")
+                return {"response": f"Erreur VLM : Impossible d'analyser le document ({response.status_code})."}
+        
+    except Exception as e:
+        print(f"Critical error in collab-chat: {str(e)}")
+        import traceback
+        traceback.print_exc()
+        return {"response": f"Désolé, une erreur technique est survenue : {str(e)}"}

models.py

@@ -0,0 +1,25 @@
+from pydantic import BaseModel
+from typing import List, Optional, Dict, Any
+
+class Patient(BaseModel):
+    id: Optional[str] = None
+    name: str
+    age: int
+    gender: str
+    medical_history: Optional[str] = None
+
+class AgentMessage(BaseModel):
+    role: str  # "user", "assistant", "system"
+    content: str
+
+class AgentState(BaseModel):
+    patient: Optional[Patient] = None
+    messages: List[AgentMessage] = []
+    context: Dict[str, Any] = {}
+    next_step: Optional[str] = None
+
+class AgentConfig(BaseModel):
+    name: str
+    type: str  # "intake", "anamnesis", "diagnosis", "planner"
+    model: str = "gpt-4o"
+    system_prompt: str

requirements.txt

@@ -0,0 +1,15 @@
+fastapi
+uvicorn
+pydantic
+langchain
+langchain-google-genai
+python-dotenv
+fpdf
+qrcode
+python-multipart
+pypdf
+langchain-openai
+pillow
+httpx
+requests
+google-generativeai

services/__init__.py

@@ -0,0 +1 @@
+# Init

services/rag_service.py

@@ -0,0 +1,26 @@
+from typing import List, Dict, Optional
+
+class RAGService:
+    def __init__(self):
+        # In-memory storage for POC: { patient_id: [context_strings] }
+        self.context_store: Dict[str, List[str]] = {}
+
+    def add_document(self, patient_id: str, content: str, doc_type: str = "general"):
+        """Adds a piece of information to the patient's context."""
+        if patient_id not in self.context_store:
+            self.context_store[patient_id] = []
+        
+        entry = f"--- DOCUMENT ({doc_type}) ---\n{content}\n"
+        self.context_store[patient_id].append(entry)
+        print(f"RAG: Added {doc_type} for patient {patient_id}")
+
+    def get_context(self, patient_id: str) -> str:
+        """Retrieves all context for a patient as a formatted string."""
+        docs = self.context_store.get(patient_id, [])
+        if not docs:
+            return ""
+        
+        return "\n".join(docs)
+
+# Singleton instance
+rag_service = RAGService()

test.txt

@@ -0,0 +1 @@
+test content