Upload folder using huggingface_hub

app.py

@@ -1,304 +1,479 @@
 """
 MedGuard - Healthcare Multi-Agent Medication Safety System
-Hugging Face Space Entry Point
+Hugging Face Space with Real AI Agents (Lite Version)
 
 MCP 1st Birthday Hackathon Submission
 """
 import gradio as gr
 import os
-from typing import Dict, Any, List
+from typing import Dict, Any, List, Optional
 import json
+from datetime import datetime
+import asyncio
 
-# For HF Spaces, we'll use a simplified demo version
-# that showcases the agent architecture without requiring
-# full database connections
+# Set up basic config
+os.environ["PYTHONUNBUFFERED"] = "1"
 
-class MedGuardDemo:
-    """Demo version of MedGuard for Hugging Face Spaces."""
-    
-    def __init__(self):
+class MedGuardLive:
+    """Live version of MedGuard with real AI agents (database-lite)."""
+
+    def __init__(self, google_api_key: str = None, anthropic_api_key: str = None):
+        self.google_api_key = google_api_key
+        self.anthropic_api_key = anthropic_api_key
+        self.llm = None
+
+        # Initialize LLM if keys provided
+        if google_api_key:
+            try:
+                from langchain_google_genai import ChatGoogleGenerativeAI
+                self.llm = ChatGoogleGenerativeAI(
+                    model="gemini-1.5-flash",
+                    google_api_key=google_api_key,
+                    temperature=0.2
+                )
+            except Exception as e:
+                print(f"Error initializing Google Gemini: {e}")
+        elif anthropic_api_key:
+            try:
+                from langchain_anthropic import ChatAnthropic
+                self.llm = ChatAnthropic(
+                    model="claude-3-5-sonnet-20241022",
+                    api_key=anthropic_api_key,
+                    temperature=0.2
+                )
+            except Exception as e:
+                print(f"Error initializing Claude: {e}")
+
+        # Demo patients
         self.demo_patients = {
-            "P001": {
-                "name": "John Smith",
-                "age": 67,
-                "conditions": ["Hypertension", "Type 2 Diabetes", "Atrial Fibrillation"],
+            "jw1001": {
+                "name": "John Warfarin",
+                "age": 75,
+                "sex": "male",
+                "conditions": ["Atrial fibrillation", "Hypertension"],
                 "medications": [
-                    {"name": "Warfarin", "dose": "5mg", "frequency": "daily"},
-                    {"name": "Metformin", "dose": "1000mg", "frequency": "twice daily"},
-                    {"name": "Lisinopril", "dose": "20mg", "frequency": "daily"},
-                    {"name": "Aspirin", "dose": "81mg", "frequency": "daily"}
+                    {"name": "Warfarin", "dosage": "5mg", "frequency": "once daily", "indication": "Atrial fibrillation"},
+                    {"name": "Aspirin", "dosage": "81mg", "frequency": "once daily", "indication": "CVD prevention"},
+                    {"name": "Simvastatin", "dosage": "40mg", "frequency": "once daily", "indication": "Hyperlipidemia"}
                 ],
-                "allergies": ["Penicillin", "Sulfa drugs"]
+                "allergies": ["Penicillin"]
             },
-            "P002": {
-                "name": "Maria Garcia",
+            "sm2002": {
+                "name": "Sarah Martinez",
                 "age": 45,
-                "conditions": ["Depression", "Chronic Pain", "Insomnia"],
+                "sex": "female",
+                "conditions": ["Type 2 diabetes", "Hypertension", "Hyperlipidemia"],
+                "medications": [
+                    {"name": "Metformin", "dosage": "1000mg", "frequency": "twice daily", "indication": "Type 2 diabetes"},
+                    {"name": "Atorvastatin", "dosage": "20mg", "frequency": "once daily", "indication": "Hyperlipidemia"},
+                    {"name": "Lisinopril", "dosage": "20mg", "frequency": "once daily", "indication": "Hypertension"}
+                ],
+                "allergies": []
+            },
+            "md3003": {
+                "name": "Michael Davis",
+                "age": 28,
+                "sex": "male",
+                "conditions": ["Depression", "Anxiety"],
                 "medications": [
-                    {"name": "Sertraline", "dose": "100mg", "frequency": "daily"},
-                    {"name": "Tramadol", "dose": "50mg", "frequency": "as needed"},
-                    {"name": "Zolpidem", "dose": "10mg", "frequency": "at bedtime"}
+                    {"name": "Sertraline", "dosage": "100mg", "frequency": "once daily", "indication": "Depression"},
+                    {"name": "Ibuprofen", "dosage": "400mg", "frequency": "as needed", "indication": "Pain"}
                 ],
                 "allergies": []
             },
-            "P003": {
+            "rc7004": {
                 "name": "Robert Chen",
                 "age": 72,
+                "sex": "male",
                 "conditions": ["Heart Failure", "COPD", "Chronic Kidney Disease"],
                 "medications": [
-                    {"name": "Furosemide", "dose": "40mg", "frequency": "daily"},
-                    {"name": "Carvedilol", "dose": "25mg", "frequency": "twice daily"},
-                    {"name": "Potassium Chloride", "dose": "20mEq", "frequency": "daily"},
-                    {"name": "Albuterol", "dose": "2 puffs", "frequency": "as needed"}
+                    {"name": "Furosemide", "dosage": "40mg", "frequency": "daily", "indication": "Heart failure"},
+                    {"name": "Carvedilol", "dosage": "25mg", "frequency": "twice daily", "indication": "Heart failure"},
+                    {"name": "Potassium Chloride", "dosage": "20mEq", "frequency": "daily", "indication": "Supplement"},
+                    {"name": "Albuterol", "dosage": "2 puffs", "frequency": "as needed", "indication": "COPD"}
                 ],
                 "allergies": ["Iodine contrast"]
             }
         }
-        
-        # Known drug interactions for demo
-        self.interactions = {
-            ("Warfarin", "Aspirin"): {
-                "severity": "HIGH",
-                "type": "Pharmacodynamic",
-                "description": "Increased bleeding risk due to additive anticoagulant effects",
-                "recommendation": "Monitor INR closely, consider gastroprotection"
-            },
-            ("Sertraline", "Tramadol"): {
-                "severity": "HIGH", 
-                "type": "Serotonin Syndrome Risk",
-                "description": "Both drugs increase serotonin levels, risk of serotonin syndrome",
-                "recommendation": "Use with caution, monitor for symptoms of serotonin syndrome"
-            },
-            ("Sertraline", "Zolpidem"): {
-                "severity": "MODERATE",
-                "type": "CNS Depression",
-                "description": "Additive CNS depressant effects",
-                "recommendation": "Use lowest effective doses, monitor for excessive sedation"
-            },
-            ("Furosemide", "Carvedilol"): {
-                "severity": "LOW",
-                "type": "Hypotension Risk",
-                "description": "Potential for additive hypotensive effects",
-                "recommendation": "Monitor blood pressure, especially on initiation"
+
+    async def analyze_with_llm(self, patient_data: Dict[str, Any]) -> Dict[str, Any]:
+        """Analyze patient medications using LLM."""
+        if not self.llm:
+            return {
+                "error": "Please provide an API key to use AI-powered analysis",
+                "interactions": [],
+                "recommendations": []
             }
-        }
 
-    def get_patient_info(self, patient_id: str) -> Dict[str, Any]:
-        """Get patient information."""
-        return self.demo_patients.get(patient_id, None)
-    
-    def check_interactions(self, medications: List[str]) -> List[Dict[str, Any]]:
-        """Check for drug interactions."""
-        found_interactions = []
-        
-        for i, drug1 in enumerate(medications):
-            for drug2 in medications[i+1:]:
-                # Check both orderings
-                key1 = (drug1, drug2)
-                key2 = (drug2, drug1)
-                
-                if key1 in self.interactions:
-                    interaction = self.interactions[key1].copy()
-                    interaction["drugs"] = [drug1, drug2]
-                    found_interactions.append(interaction)
-                elif key2 in self.interactions:
-                    interaction = self.interactions[key2].copy()
-                    interaction["drugs"] = [drug1, drug2]
-                    found_interactions.append(interaction)
-        
-        return found_interactions
-    
-    def analyze_patient(self, patient_id: str) -> str:
-        """Run full analysis on a patient."""
-        patient = self.get_patient_info(patient_id)
-        
+        medications = patient_data["medications"]
+        med_list = [f"{m['name']} ({m['dosage']} {m['frequency']})" for m in medications]
+
+        system_prompt = """You are an expert clinical pharmacist AI specializing in drug interaction analysis.
+
+Your task is to analyze medication lists for:
+1. Drug-drug interactions (pharmacokinetic and pharmacodynamic)
+2. Severity level (contraindicated, major, moderate, minor)
+3. Clinical significance and mechanisms
+4. Evidence-based management recommendations
+
+Focus on clinically significant interactions. Be thorough but avoid over-flagging minor interactions."""
+
+        user_message = f"""Analyze this patient's medication regimen for drug interactions:
+
+**Patient Profile:**
+- Age: {patient_data['age']} years
+- Sex: {patient_data['sex']}
+- Conditions: {', '.join(patient_data['conditions'])}
+- Allergies: {', '.join(patient_data['allergies']) if patient_data['allergies'] else 'None'}
+
+**Current Medications:**
+{chr(10).join(f"- {med}" for med in med_list)}
+
+**Task:**
+1. Identify all clinically significant drug-drug interactions
+2. For each interaction, provide:
+   - Drugs involved
+   - Severity (contraindicated/major/moderate/minor)
+   - Mechanism of interaction
+   - Clinical effects
+   - Management recommendations
+   - Confidence level (0.0-1.0)
+
+3. Also consider:
+   - Age-related factors (geriatric if ≥65)
+   - Renal considerations if chronic kidney disease present
+   - Common clinical guidelines
+
+Return your analysis as JSON with this structure:
+{{
+  "interactions": [
+    {{
+      "drug1": "Drug A",
+      "drug2": "Drug B",
+      "severity": "major",
+      "mechanism": "...",
+      "clinical_effect": "...",
+      "management": "...",
+      "confidence": 0.9
+    }}
+  ],
+  "personalization": {{
+    "age_considerations": "...",
+    "renal_considerations": "...",
+    "other_factors": "..."
+  }},
+  "guideline_compliance": [
+    "Guideline check 1",
+    "Guideline check 2"
+  ],
+  "recommendations": [
+    {{
+      "priority": "high",
+      "action": "...",
+      "rationale": "..."
+    }}
+  ],
+  "overall_risk": "low|moderate|high",
+  "requires_review": true|false
+}}
+
+Be conservative - only flag interactions with clinical significance."""
+
+        try:
+            from langchain_core.messages import SystemMessage, HumanMessage
+
+            messages = [
+                SystemMessage(content=system_prompt),
+                HumanMessage(content=user_message)
+            ]
+
+            response = await self.llm.ainvoke(messages)
+            content = response.content
+
+            # Extract JSON from response
+            if "```json" in content:
+                content = content.split("```json")[1].split("```")[0].strip()
+            elif "```" in content:
+                content = content.split("```")[1].split("```")[0].strip()
+
+            result = json.loads(content)
+            return result
+
+        except Exception as e:
+            return {
+                "error": f"Analysis failed: {str(e)}",
+                "interactions": [],
+                "recommendations": []
+            }
+
+    async def analyze_patient(self, patient_id: str) -> str:
+        """Analyze patient medications."""
+        patient = self.demo_patients.get(patient_id)
+
         if not patient:
-            return "❌ Patient not found. Please select a valid patient ID."
-        
-        med_names = [m["name"] for m in patient["medications"]]
-        interactions = self.check_interactions(med_names)
-        
-        # Build analysis report
+            return "❌ Patient not found."
+
+        if not self.llm:
+            return "⚠️ **Please provide an API key (Google Gemini or Anthropic Claude) to enable AI analysis.**\n\nEnter your API key in the sidebar and try again."
+
+        # Run LLM analysis
+        analysis = await self.analyze_with_llm(patient)
+
+        if "error" in analysis:
+            return f"❌ **Analysis Error**\n\n{analysis['error']}"
+
+        # Format report
         report = []
-        report.append("# 🏥 MedGuard Analysis Report\n")
+        report.append("# 🏥 MedGuard AI Analysis Report\n")
         report.append(f"## Patient: {patient['name']} (ID: {patient_id})\n")
-        report.append(f"**Age:** {patient['age']} years\n")
+        report.append(f"**Age:** {patient['age']} years | **Sex:** {patient['sex']}\n")
         report.append(f"**Conditions:** {', '.join(patient['conditions'])}\n")
         report.append(f"**Allergies:** {', '.join(patient['allergies']) if patient['allergies'] else 'None reported'}\n")
-        
+
         report.append("\n## 💊 Current Medications\n")
         for med in patient["medications"]:
-            report.append(f"- **{med['name']}** {med['dose']} - {med['frequency']}\n")
-        
+            report.append(f"- **{med['name']}** {med['dosage']} - {med['frequency']} ({med['indication']})\n")
+
         report.append("\n---\n")
-        report.append("## 🤖 Multi-Agent Analysis\n")
-        
+        report.append("## 🤖 AI Multi-Agent Analysis\n")
+        report.append(f"*Powered by {self.llm.model_name if hasattr(self.llm, 'model_name') else 'AI'}*\n\n")
+
         # Drug Interaction Agent
-        report.append("\n### 🔬 Drug Interaction Agent\n")
+        report.append("### 🔬 Drug Interaction Agent\n")
+        interactions = analysis.get("interactions", [])
+
         if interactions:
-            high_risk = [i for i in interactions if i["severity"] == "HIGH"]
-            moderate_risk = [i for i in interactions if i["severity"] == "MODERATE"]
-            low_risk = [i for i in interactions if i["severity"] == "LOW"]
-            
+            high_risk = [i for i in interactions if i.get("severity") in ["major", "contraindicated"]]
+            moderate_risk = [i for i in interactions if i.get("severity") == "moderate"]
+            low_risk = [i for i in interactions if i.get("severity") in ["minor", "low"]]
+
             if high_risk:
                 report.append("\n#### ⚠️ HIGH SEVERITY INTERACTIONS\n")
-                for interaction in high_risk:
-                    report.append(f"**{interaction['drugs'][0]} ↔ {interaction['drugs'][1]}**\n")
-                    report.append(f"- Type: {interaction['type']}\n")
-                    report.append(f"- {interaction['description']}\n")
-                    report.append(f"- 💡 *{interaction['recommendation']}*\n\n")
-            
+                for inter in high_risk:
+                    report.append(f"**{inter['drug1']} ↔ {inter['drug2']}** (Confidence: {inter.get('confidence', 0.0):.0%})\n")
+                    report.append(f"- **Mechanism:** {inter.get('mechanism', 'Not specified')}\n")
+                    report.append(f"- **Clinical Effect:** {inter.get('clinical_effect', 'Not specified')}\n")
+                    report.append(f"- **Management:** {inter.get('management', 'Clinical judgment required')}\n\n")
+
             if moderate_risk:
                 report.append("\n#### ⚡ MODERATE SEVERITY INTERACTIONS\n")
-                for interaction in moderate_risk:
-                    report.append(f"**{interaction['drugs'][0]} ↔ {interaction['drugs'][1]}**\n")
-                    report.append(f"- Type: {interaction['type']}\n")
-                    report.append(f"- {interaction['description']}\n")
-                    report.append(f"- 💡 *{interaction['recommendation']}*\n\n")
-            
+                for inter in moderate_risk:
+                    report.append(f"**{inter['drug1']} ↔ {inter['drug2']}**\n")
+                    report.append(f"- {inter.get('clinical_effect', 'Monitor for interaction')}\n")
+                    report.append(f"- *{inter.get('management', 'Monitor closely')}*\n\n")
+
             if low_risk:
                 report.append("\n#### ℹ️ LOW SEVERITY INTERACTIONS\n")
-                for interaction in low_risk:
-                    report.append(f"**{interaction['drugs'][0]} ↔ {interaction['drugs'][1]}**\n")
-                    report.append(f"- {interaction['description']}\n\n")
+                for inter in low_risk:
+                    report.append(f"- {inter['drug1']} ↔ {inter['drug2']}: {inter.get('clinical_effect', 'Minor interaction')}\n")
         else:
             report.append("✅ No significant drug interactions detected.\n")
-        
+
         # Personalization Agent
-        report.append("\n### 👤 Personalization Agent\n")
-        if patient["age"] >= 65:
-            report.append("⚠️ **Geriatric Considerations:**\n")
-            report.append("- Patient is elderly (≥65 years) - consider renal function adjustments\n")
-            report.append("- Monitor for increased sensitivity to CNS-active medications\n")
-            report.append("- Fall risk assessment recommended\n")
-        
-        if "Chronic Kidney Disease" in patient["conditions"]:
-            report.append("\n⚠️ **Renal Considerations:**\n")
-            report.append("- Adjust renally-cleared medications based on eGFR\n")
-            report.append("- Avoid nephrotoxic combinations when possible\n")
-        
-        # Guideline Agent
-        report.append("\n### 📋 Guideline Compliance Agent\n")
-        report.append("Checking against clinical practice guidelines...\n")
-        
-        if "Atrial Fibrillation" in patient["conditions"] and any(m["name"] == "Warfarin" for m in patient["medications"]):
-            report.append("✅ Anticoagulation for AFib per AHA/ACC guidelines\n")
-        
-        if "Type 2 Diabetes" in patient["conditions"] and any(m["name"] == "Metformin" for m in patient["medications"]):
-            report.append("✅ Metformin as first-line therapy per ADA guidelines\n")
-        
-        if "Heart Failure" in patient["conditions"] and any(m["name"] == "Carvedilol" for m in patient["medications"]):
-            report.append("✅ Beta-blocker for HFrEF per ACC/AHA guidelines\n")
-        
-        # Cost Agent
-        report.append("\n### 💰 Cost Optimization Agent\n")
-        report.append("Analyzing cost-saving opportunities...\n")
-        report.append("- Consider generic alternatives where available\n")
-        report.append("- Check formulary status with patient's insurance\n")
-        
-        # Summary
+        personalization = analysis.get("personalization", {})
+        if personalization:
+            report.append("\n### 👤 Personalization Agent\n")
+            if personalization.get("age_considerations"):
+                report.append(f"**Age Considerations:** {personalization['age_considerations']}\n\n")
+            if personalization.get("renal_considerations"):
+                report.append(f"**Renal Considerations:** {personalization['renal_considerations']}\n\n")
+            if personalization.get("other_factors"):
+                report.append(f"**Other Factors:** {personalization['other_factors']}\n\n")
+
+        # Guideline Compliance
+        guidelines = analysis.get("guideline_compliance", [])
+        if guidelines:
+            report.append("\n### 📋 Guideline Compliance Agent\n")
+            for guideline in guidelines:
+                report.append(f"✅ {guideline}\n")
+
+        # Recommendations
+        recommendations = analysis.get("recommendations", [])
+        if recommendations:
+            report.append("\n### 💡 Recommendations\n")
+            for rec in recommendations:
+                priority_emoji = {"high": "🔴", "medium": "🟡", "low": "🟢"}.get(rec.get("priority", "low"), "ℹ️")
+                report.append(f"{priority_emoji} **{rec.get('action', 'N/A')}**\n")
+                report.append(f"   *Rationale:* {rec.get('rationale', 'N/A')}\n\n")
+
+        # Risk Summary
         report.append("\n---\n")
-        report.append("## 📊 Risk Summary\n")
-        
-        high_count = len([i for i in interactions if i["severity"] == "HIGH"])
-        if high_count > 0:
-            report.append(f"🔴 **{high_count} HIGH-RISK** interaction(s) requiring immediate attention\n")
-            report.append("\n**⚠️ REQUIRES HUMAN REVIEW**\n")
-        else:
-            report.append("🟢 No high-risk interactions detected\n")
-        
+        report.append("## 📊 Overall Assessment\n")
+        overall_risk = analysis.get("overall_risk", "low").upper()
+        risk_emoji = {"LOW": "🟢", "MODERATE": "🟡", "HIGH": "🔴"}.get(overall_risk, "⚪")
+
+        report.append(f"{risk_emoji} **Overall Risk Level:** {overall_risk}\n\n")
+
+        if analysis.get("requires_review", False):
+            report.append("⚠️ **REQUIRES CLINICAL REVIEW**\n")
+
         report.append("\n---\n")
-        report.append("*Generated by MedGuard Multi-Agent System*\n")
-        report.append("*MCP 1st Birthday Hackathon Submission*\n")
-        
+        report.append(f"*Analysis completed at {datetime.now().strftime('%Y-%m-%d %H:%M:%S')} UTC*\n")
+        report.append("*Generated by MedGuard Multi-Agent AI System*\n")
+
         return "".join(report)
 
 
-# Initialize demo
-demo_system = MedGuardDemo()
+# Global instance (will be recreated when API keys change)
+medguard = None
+
+def update_api_keys(google_key, anthropic_key):
+    """Update API keys and reinitialize system."""
+    global medguard
+
+    if not google_key and not anthropic_key:
+        return "⚠️ Please provide at least one API key (Google Gemini or Anthropic Claude)"
+
+    medguard = MedGuardLive(
+        google_api_key=google_key if google_key else None,
+        anthropic_api_key=anthropic_key if anthropic_key else None
+    )
+
+    if medguard.llm:
+        model_name = medguard.llm.model_name if hasattr(medguard.llm, 'model_name') else "AI model"
+        return f"✅ API keys configured successfully! Using **{model_name}**"
+    else:
+        return "❌ Failed to initialize AI model. Please check your API keys."
+
+def analyze_wrapper(patient_id, google_key, anthropic_key):
+    """Wrapper to handle async analysis."""
+    global medguard
+
+    # Initialize if needed
+    if medguard is None:
+        if not google_key and not anthropic_key:
+            return "⚠️ **Please provide an API key**\n\nEnter your Google Gemini or Anthropic Claude API key in the sidebar to enable AI analysis."
+        medguard = MedGuardLive(google_api_key=google_key, anthropic_api_key=anthropic_key)
+
+    # Run async analysis
+    loop = asyncio.new_event_loop()
+    asyncio.set_event_loop(loop)
+    result = loop.run_until_complete(medguard.analyze_patient(patient_id))
+    loop.close()
+
+    return result
+
 
 # Build Gradio Interface
-with gr.Blocks() as app:
-    
+with gr.Blocks(theme=gr.themes.Soft()) as app:
+
     gr.Markdown("""
-    # 🏥 MedGuard
-    ## AI-Powered Medication Safety Analysis
-    
-    **Multi-Agent System for Drug Interaction Detection & Clinical Decision Support**
-    
-    *MCP 1st Birthday Hackathon Submission*
-    
+    # 🏥 MedGuard AI
+    ## Real-Time Medication Safety Analysis with Multi-Agent AI
+
+    **Powered by LLM Agents | MCP 1st Birthday Hackathon**
+
     ---
     """)
-    
+
     with gr.Row():
         with gr.Column(scale=1):
+            gr.Markdown("### 🔑 API Configuration")
+            gr.Markdown("*Keys are session-only, not saved*")
+
+            google_key_input = gr.Textbox(
+                label="Google Gemini API Key (Recommended)",
+                placeholder="AIza...",
+                type="password"
+            )
+
+            anthropic_key_input = gr.Textbox(
+                label="Anthropic Claude API Key (Alternative)",
+                placeholder="sk-ant-...",
+                type="password"
+            )
+
+            config_status = gr.Markdown("⚪ Not configured")
+
+            configure_btn = gr.Button("🔄 Apply API Keys", variant="secondary")
+
+            gr.Markdown("---")
             gr.Markdown("### 👤 Select Patient")
-            
+
             patient_dropdown = gr.Dropdown(
                 choices=[
-                    ("P001 - John Smith (67y, Cardiac/Diabetes)", "P001"),
-                    ("P002 - Maria Garcia (45y, Psych/Pain)", "P002"),
-                    ("P003 - Robert Chen (72y, HF/COPD/CKD)", "P003")
+                    ("jw1001 - John (75y, Warfarin+Aspirin)", "jw1001"),
+                    ("sm2002 - Sarah (45y, Diabetes/HTN)", "sm2002"),
+                    ("md3003 - Michael (28y, Depression)", "md3003"),
+                    ("rc7004 - Robert (72y, HF/COPD/CKD)", "rc7004")
                 ],
-                label="Patient",
-                value="P001"
+                label="Patient ID",
+                value="jw1001"
             )
-            
-            analyze_btn = gr.Button("🔍 Analyze Medications", variant="primary", size="lg")
-            
+
+            analyze_btn = gr.Button("🔍 Analyze with AI", variant="primary", size="lg")
+
             gr.Markdown("""
-            ### 🤖 Agent Architecture
-            
-            This system uses **5 specialized AI agents**:
-            
-            1. **Drug Interaction Agent** - Detects harmful drug combinations
-            2. **Personalization Agent** - Adjusts for patient factors
-            3. **Guideline Agent** - Checks clinical compliance
-            4. **Cost Agent** - Finds cost-saving alternatives
-            5. **Explanation Agent** - Generates human-readable summaries
-            
-            Built with **MCP (Model Context Protocol)** for Claude Desktop integration.
+            ### 🤖 AI Agent System
+
+            **5 Specialized Agents:**
+            1. 🔬 **Drug Interaction** - Detects harmful combinations
+            2. 👤 **Personalization** - Patient-specific factors
+            3. 📋 **Guidelines** - Evidence-based compliance
+            4. 💰 **Cost** - Therapeutic alternatives
+            5. 💡 **Explanation** - Clinical summaries
+
+            **Powered by:** LangChain + Google Gemini / Claude
             """)
-            
+
         with gr.Column(scale=2):
             output = gr.Markdown(
-                value="Select a patient and click **Analyze** to begin.",
+                value="""### 👋 Welcome to MedGuard AI!
+
+**To get started:**
+1. Enter your **Google Gemini** or **Anthropic Claude** API key
+2. Click **Apply API Keys**
+3. Select a patient
+4. Click **Analyze with AI**
+
+**Get API Keys:**
+- [Google AI Studio](https://aistudio.google.com/app/apikey) (Free tier available)
+- [Anthropic Console](https://console.anthropic.com/) (Claude)
+
+*Your keys are used only for this session and are never stored.*""",
                 label="Analysis Results"
             )
-    
+
     gr.Markdown("""
     ---
-    
+
     ### 🛠️ Technology Stack
-    
+
     | Component | Technology |
     |-----------|------------|
-    | MCP Server | Python `mcp` SDK with stdio transport |
-    | Orchestration | LangGraph with conditional routing |
-    | LLM | Google Gemini 1.5 Flash |
-    | Vector Search | Qdrant + BioBERT embeddings |
-    | Graph DB | Neo4j for drug interaction network |
-    | Frontend | Gradio (this demo) |
-    
-    ### 📦 MCP Tools Available
-    
-    - `analyze_patient_medications` - Full safety analysis
-    - `check_drug_interactions` - Pairwise interaction check
-    - `get_patient_profile` - Patient demographics & meds
-    - `search_clinical_guidelines` - Evidence-based recommendations
-    - `get_drug_alternatives` - Therapeutic alternatives
-    - And 5 more...
-    
-    ---
-    
+    | AI Models | Google Gemini 1.5 Flash / Claude 3.5 Sonnet |
+    | Framework | LangChain for agent orchestration |
+    | MCP Integration | Full MCP server available (see GitHub) |
+    | Frontend | Gradio |
+
+    ### 📦 Full Production System
+
+    This is a **lite demo** version. The full system includes:
+    - PostgreSQL + Neo4j + Qdrant + Redis databases
+    - 10 MCP tools for Claude Desktop
+    - LangGraph conditional routing
+    - HIPAA-compliant audit logging
+    - Docker deployment
+
     **GitHub:** [SmartGridsML/mcp1stbirthday_hack](https://github.com/SmartGridsML/mcp1stbirthday_hack)
+
+    **Local Full System:**
+    ```bash
+    git clone https://github.com/SmartGridsML/mcp1stbirthday_hack
+    docker-compose up
+    ```
     """)
-    
+
     # Event handlers
+    configure_btn.click(
+        fn=update_api_keys,
+        inputs=[google_key_input, anthropic_key_input],
+        outputs=[config_status]
+    )
+
     analyze_btn.click(
-        fn=demo_system.analyze_patient,
-        inputs=[patient_dropdown],
+        fn=analyze_wrapper,
+        inputs=[patient_dropdown, google_key_input, anthropic_key_input],
         outputs=[output]
     )
 

requirements.txt

@@ -1 +1,5 @@
 gradio
+langchain
+langchain-google-genai
+langchain-anthropic
+langchain-core