Upload 12 files

src/__init__.py

@@ -0,0 +1,12 @@
+"""
+Drug Interaction Analysis System
+A comprehensive system for analyzing drug interactions using biomedical language models and network analysis.
+"""
+
+from .models.biomedical_llm import BiomedicalLLM
+from .models.drug_interaction_db import DrugInteractionDatabase
+from .models.ddi_processor import DDIProcessor
+from .models.chatbot import DrugInteractionChatbot
+
+__version__ = "1.0.0"
+__all__ = ['BiomedicalLLM', 'DrugInteractionDatabase', 'DDIProcessor', 'DrugInteractionChatbot'] 

src/models/biomedical_llm.py

@@ -0,0 +1,425 @@
+"""Biomedical Language Model for drug interaction analysis."""
+
+import torch
+from transformers import AutoTokenizer, AutoModelForCausalLM
+import json
+import re
+
+class BiomedicalLLM:
+    """Class to handle biomedical language model inference"""
+    
+    def __init__(self, model_name="stanford-crfm/BioMedLM"):
+        """
+        Initialize the Biomedical Language Model
+        
+        Args:
+            model_name: The name of the model to use (default: BioMedLM)
+                Options include:
+                - "stanford-crfm/BioMedLM"
+                - "microsoft/biogpt"
+        """
+        self.model_name = model_name
+        try:
+            print(f"Loading {model_name}...")
+            self.tokenizer = AutoTokenizer.from_pretrained(model_name)
+            # Set pad token if it doesn't exist
+            if self.tokenizer.pad_token is None:
+                self.tokenizer.pad_token = self.tokenizer.eos_token
+                
+            self.model = AutoModelForCausalLM.from_pretrained(
+                model_name, 
+                torch_dtype=torch.float16 if torch.cuda.is_available() else torch.float32,
+                device_map="auto" if torch.cuda.is_available() else None,
+                pad_token_id=self.tokenizer.pad_token_id
+            )
+            self.device = "cuda" if torch.cuda.is_available() else "cpu"
+            print(f"Model loaded successfully on {self.device}")
+        except Exception as e:
+            print(f"Error loading model: {e}")
+            print("Falling back to API-based approach or stub implementation")
+            self.tokenizer = None
+            self.model = None
+    
+    def extract_ddi_from_literature(self, drug1, drug2):
+        """
+        Extract drug-drug interaction information from biomedical literature
+        
+        Args:
+            drug1: Name of the first drug
+            drug2: Name of the second drug
+            
+        Returns:
+            A list of extracted interactions with evidence
+        """
+        if self.model is None or self.tokenizer is None:
+            # Fallback behavior if model failed to load
+            return self._fallback_extract_ddi(drug1, drug2)
+        
+        try:
+            # Construct a prompt for the model
+            prompt = f"""
+            Analyze the scientific literature for interactions between {drug1} and {drug2}.
+            Include the following information:
+            1. Description of the interaction mechanism
+            2. Severity (Mild, Moderate, Severe)
+            3. Clinical significance
+            4. Management recommendations
+            
+            Format the response as JSON with the following structure:
+            {{
+                "interactions": [
+                    {{
+                        "description": "Description of mechanism",
+                        "severity": "Severity level",
+                        "evidence": "Evidence from literature",
+                        "management": "Management recommendation"
+                    }}
+                ]
+            }}
+            """
+            
+            # Generate completion with proper attention mask
+            inputs = self.tokenizer(prompt, return_tensors="pt").to(self.device)
+            
+            # Ensure attention mask is set properly
+            if 'attention_mask' not in inputs:
+                inputs['attention_mask'] = torch.ones_like(inputs['input_ids'])
+            
+            # Generate with appropriate parameters
+            with torch.no_grad():
+                outputs = self.model.generate(
+                    inputs.input_ids,
+                    attention_mask=inputs.attention_mask,
+                    max_new_tokens=512,
+                    temperature=0.7,
+                    top_p=0.9,
+                    do_sample=True
+                )
+            
+            # Decode the response
+            response = self.tokenizer.decode(outputs[0], skip_special_tokens=True)
+            
+            # Extract the JSON part of the response
+            json_match = re.search(r'({[\s\S]*})', response)
+            if json_match:
+                json_str = json_match.group(1)
+                try:
+                    return json.loads(json_str)
+                except:
+                    # If JSON parsing fails, return a structured response anyway
+                    return self._extract_structured_info(response, drug1, drug2)
+            else:
+                # If no JSON found, extract structured information
+                return self._extract_structured_info(response, drug1, drug2)
+                
+        except Exception as e:
+            print(f"Error in LLM inference: {e}")
+            return self._fallback_extract_ddi(drug1, drug2)
+    
+    def _extract_structured_info(self, text, drug1, drug2):
+        """Extract structured information from text if JSON parsing fails"""
+        # Try to identify descriptions, severity, etc.
+        severity_match = re.search(r'(mild|moderate|severe)', text.lower())
+        severity = severity_match.group(1).capitalize() if severity_match else "Unknown"
+        
+        # Default structured response
+        return {
+            "interactions": [
+                {
+                    "description": f"Potential interaction between {drug1} and {drug2} identified in literature",
+                    "severity": severity,
+                    "evidence": "Based on biomedical literature analysis",
+                    "management": "Consult healthcare provider for specific guidance"
+                }
+            ]
+        }
+    
+    def _fallback_extract_ddi(self, drug1, drug2):
+        """Fallback method when model is not available"""
+        # Return a structured response with disclaimer
+        return {
+            "interactions": [
+                {
+                    "description": f"Potential interaction between {drug1} and {drug2}",
+                    "severity": "Unknown",
+                    "evidence": "Please consult literature for evidence",
+                    "management": "Consult healthcare provider for guidance"
+                }
+            ],
+            "note": "Biomedical model not available - using fallback information"
+        }
+    
+    def analyze_clinical_notes(self, clinical_text):
+        """
+        Extract drug mentions and potential interactions from clinical notes
+        
+        Args:
+            clinical_text: The clinical notes text to analyze
+            
+        Returns:
+            A dictionary with extracted drugs and potential interactions
+        """
+        if self.model is None or self.tokenizer is None:
+            # Fallback behavior if model failed to load
+            return self._fallback_analyze_clinical_notes(clinical_text)
+        
+        try:
+            # Construct a prompt for the model
+            prompt = f"""
+            Extract all medication mentions and potential drug interactions from the following clinical note:
+            
+            {clinical_text}
+            
+            Format the response as JSON with the following structure:
+            {{
+                "medications": [
+                    {{
+                        "name": "Drug name",
+                        "dosage": "Dosage if mentioned",
+                        "frequency": "Frequency if mentioned"
+                    }}
+                ],
+                "potential_interactions": [
+                    {{
+                        "drug1": "First drug name",
+                        "drug2": "Second drug name",
+                        "concern": "Description of potential interaction"
+                    }}
+                ]
+            }}
+            """
+            
+            # Generate completion with proper attention mask
+            inputs = self.tokenizer(prompt, return_tensors="pt").to(self.device)
+            
+            # Ensure attention mask is set properly
+            if 'attention_mask' not in inputs:
+                inputs['attention_mask'] = torch.ones_like(inputs['input_ids'])
+            
+            # Generate with appropriate parameters
+            with torch.no_grad():
+                outputs = self.model.generate(
+                    inputs.input_ids,
+                    attention_mask=inputs.attention_mask,
+                    max_new_tokens=512,
+                    temperature=0.7,
+                    top_p=0.9,
+                    do_sample=True
+                )
+            
+            # Decode the response
+            response = self.tokenizer.decode(outputs[0], skip_special_tokens=True)
+            
+            # Extract the JSON part of the response
+            json_match = re.search(r'({[\s\S]*})', response)
+            if json_match:
+                json_str = json_match.group(1)
+                try:
+                    return json.loads(json_str)
+                except:
+                    # If JSON parsing fails, return a structured response anyway
+                    return self._extract_medications_from_text(response)
+            else:
+                # If no JSON found, extract structured information
+                return self._extract_medications_from_text(response)
+                
+        except Exception as e:
+            print(f"Error in LLM inference: {e}")
+            return self._fallback_analyze_clinical_notes(clinical_text)
+    
+    def _extract_medications_from_text(self, text):
+        """Extract medication mentions from text if JSON parsing fails"""
+        # Simple regex-based extraction
+        drug_patterns = [
+            r'([A-Za-z]+)\s+(\d+\s*mg)',
+            r'([A-Za-z]+)\s+(\d+\s*mcg)',
+            r'([A-Za-z]+)\s+(\d+\s*ml)',
+            r'([A-Za-z]+)\s+(\d+\s*tablet)',
+            r'prescribe[d]?\s+([A-Za-z]+)',
+            r'taking\s+([A-Za-z]+)',
+            r'administer[ed]?\s+([A-Za-z]+)'
+        ]
+        
+        medications = []
+        for pattern in drug_patterns:
+            matches = re.finditer(pattern, text, re.IGNORECASE)
+            for match in matches:
+                if len(match.groups()) > 1:
+                    drug_name = match.group(1)
+                    dosage = match.group(2)
+                    medications.append({"name": drug_name, "dosage": dosage, "frequency": "Not specified"})
+                else:
+                    drug_name = match.group(1)
+                    medications.append({"name": drug_name, "dosage": "Not specified", "frequency": "Not specified"})
+        
+        # Return structured data
+        return {
+            "medications": medications,
+            "potential_interactions": []
+        }
+    
+    def _fallback_analyze_clinical_notes(self, clinical_text):
+        """Fallback method for clinical note analysis when model is not available"""
+        # Return a structured response with disclaimer
+        return {
+            "medications": [],
+            "potential_interactions": [],
+            "note": "Biomedical model not available - please review clinical notes manually"
+        }
+    
+    def get_drug_information(self, drug_name):
+        """
+        Get detailed information about a specific drug
+        
+        Args:
+            drug_name: Name of the drug
+            
+        Returns:
+            A dictionary with drug information
+        """
+        if self.model is None or self.tokenizer is None:
+            # Fallback behavior if model failed to load
+            return self._fallback_drug_information(drug_name)
+        
+        try:
+            # Construct a prompt for the model
+            prompt = f"""
+            Provide comprehensive information about the medication {drug_name}, including:
+            1. Drug class
+            2. Mechanism of action
+            3. Common indications
+            4. Common side effects
+            5. Common drug interactions
+            6. Contraindications
+            
+            Format the response as JSON with the following structure:
+            {{
+                "drug_name": "{drug_name}",
+                "drug_class": "Drug class",
+                "mechanism": "Mechanism of action",
+                "indications": ["Indication 1", "Indication 2"],
+                "side_effects": ["Side effect 1", "Side effect 2"],
+                "common_interactions": ["Drug 1", "Drug 2"],
+                "contraindications": ["Contraindication 1", "Contraindication 2"]
+            }}
+            """
+            
+            # Generate completion with proper attention mask
+            inputs = self.tokenizer(prompt, return_tensors="pt").to(self.device)
+            
+            # Ensure attention mask is set properly
+            if 'attention_mask' not in inputs:
+                inputs['attention_mask'] = torch.ones_like(inputs['input_ids'])
+            
+            # Generate with appropriate parameters
+            with torch.no_grad():
+                outputs = self.model.generate(
+                    inputs.input_ids,
+                    attention_mask=inputs.attention_mask,
+                    max_new_tokens=512,
+                    temperature=0.7,
+                    top_p=0.9,
+                    do_sample=True
+                )
+            
+            # Decode the response
+            response = self.tokenizer.decode(outputs[0], skip_special_tokens=True)
+            
+            # Extract the JSON part of the response
+            json_match = re.search(r'({[\s\S]*})', response)
+            if json_match:
+                json_str = json_match.group(1)
+                try:
+                    return json.loads(json_str)
+                except:
+                    # If JSON parsing fails, return a structured response anyway
+                    return self._extract_drug_info_from_text(response, drug_name)
+            else:
+                # If no JSON found, extract structured information
+                return self._extract_drug_info_from_text(response, drug_name)
+                
+        except Exception as e:
+            print(f"Error in LLM inference: {e}")
+            return self._fallback_drug_information(drug_name)
+    
+    def _extract_drug_info_from_text(self, text, drug_name):
+        """Extract drug information from text if JSON parsing fails"""
+        # Create default structure
+        drug_info = {
+            "drug_name": drug_name,
+            "drug_class": "Not specified",
+            "mechanism": "Not specified",
+            "indications": [],
+            "side_effects": [],
+            "common_interactions": [],
+            "contraindications": []
+        }
+        
+        # Try to extract each section
+        class_match = re.search(r'[Cc]lass:?\s+([^\n\.]+)', text)
+        if class_match:
+            drug_info["drug_class"] = class_match.group(1).strip()
+        
+        mechanism_match = re.search(r'[Mm]echanism:?\s+([^\n\.]+)', text)
+        if mechanism_match:
+            drug_info["mechanism"] = mechanism_match.group(1).strip()
+        
+        # Extract lists with regex
+        indication_match = re.search(r'[Ii]ndications?:?\s+((?:[^\n]+\n?)+)', text)
+        if indication_match:
+            indications_text = indication_match.group(1)
+            # Split by common list markers
+            indications = re.findall(r'(?:^|\n)\s*(?:\d+\.|\*|-|•)\s*([^\n]+)', indications_text)
+            if indications:
+                drug_info["indications"] = [ind.strip() for ind in indications]
+            elif indications_text:
+                # If no list markers, just split by commas or newlines
+                items = re.split(r',|\n', indications_text)
+                drug_info["indications"] = [item.strip() for item in items if item.strip()]
+        
+        # Similarly for other list-based fields
+        side_effects_match = re.search(r'[Ss]ide [Ee]ffects:?\s+((?:[^\n]+\n?)+)', text)
+        if side_effects_match:
+            side_effects_text = side_effects_match.group(1)
+            side_effects = re.findall(r'(?:^|\n)\s*(?:\d+\.|\*|-|•)\s*([^\n]+)', side_effects_text)
+            if side_effects:
+                drug_info["side_effects"] = [se.strip() for se in side_effects]
+            elif side_effects_text:
+                items = re.split(r',|\n', side_effects_text)
+                drug_info["side_effects"] = [item.strip() for item in items if item.strip()]
+        
+        interactions_match = re.search(r'[Ii]nteractions:?\s+((?:[^\n]+\n?)+)', text)
+        if interactions_match:
+            interactions_text = interactions_match.group(1)
+            interactions = re.findall(r'(?:^|\n)\s*(?:\d+\.|\*|-|•)\s*([^\n]+)', interactions_text)
+            if interactions:
+                drug_info["common_interactions"] = [inter.strip() for inter in interactions]
+            elif interactions_text:
+                items = re.split(r',|\n', interactions_text)
+                drug_info["common_interactions"] = [item.strip() for item in items if item.strip()]
+        
+        contraindications_match = re.search(r'[Cc]ontraindications:?\s+((?:[^\n]+\n?)+)', text)
+        if contraindications_match:
+            contraindications_text = contraindications_match.group(1)
+            contraindications = re.findall(r'(?:^|\n)\s*(?:\d+\.|\*|-|•)\s*([^\n]+)', contraindications_text)
+            if contraindications:
+                drug_info["contraindications"] = [contra.strip() for contra in contraindications]
+            elif contraindications_text:
+                items = re.split(r',|\n', contraindications_text)
+                drug_info["contraindications"] = [item.strip() for item in items if item.strip()]
+        
+        return drug_info
+    
+    def _fallback_drug_information(self, drug_name):
+        """Fallback method for drug information when model is not available"""
+        # Return a structured response with disclaimer
+        return {
+            "drug_name": drug_name,
+            "drug_class": "Information not available",
+            "mechanism": "Information not available",
+            "indications": ["Information not available"],
+            "side_effects": ["Information not available"],
+            "common_interactions": ["Information not available"],
+            "contraindications": ["Information not available"],
+            "note": "Biomedical model not available - using fallback information"
+        } 

src/models/chatbot.py

@@ -0,0 +1,376 @@
+"""Drug Interaction Chatbot for natural language interaction with the drug interaction system."""
+
+import re
+import uuid
+import io
+import matplotlib.pyplot as plt
+import networkx as nx
+from typing import Dict, List, Tuple, Optional, Any
+
+from .biomedical_llm import BiomedicalLLM
+from .drug_interaction_db import DrugInteractionDatabase
+from .ddi_processor import DDIProcessor
+
+class DrugInteractionChatbot:
+    """Chatbot interface for drug interaction analysis system."""
+    
+    def __init__(self, model_name="stanford-crfm/BioMedLM"):
+        """Initialize the Drug Interaction Chatbot with Biomedical LLM"""
+        self.db = DrugInteractionDatabase()
+        self.bio_llm = BiomedicalLLM(model_name)
+        self.processor = DDIProcessor(self.db, self.bio_llm)
+        
+    def process_message(self, message):
+        """Process a user message and provide an appropriate response"""
+        # Check if this is a clinical notes analysis request
+        if any(term in message.lower() for term in ["clinical note", "patient note", "extract from", "analyze note", "medical record"]):
+            # Extract the clinical note part
+            note_pattern = r"(?:clinical note|patient note|medical record)[s]?:?\s*([\s\S]+)$"
+            note_match = re.search(note_pattern, message, re.IGNORECASE)
+            
+            if note_match:
+                clinical_text = note_match.group(1).strip()
+                extracted_info = self.processor.extract_drugs_from_clinical_notes(clinical_text)
+                
+                # Format the response
+                response = "📋 **Analysis of Clinical Notes**\n\n"
+                
+                # Add medications
+                if extracted_info["medications"]:
+                    response += "**Medications Identified:**\n"
+                    for med in extracted_info["medications"]:
+                        name = med.get("name", "Unknown")
+                        dosage = med.get("dosage", "Not specified")
+                        frequency = med.get("frequency", "Not specified")
+                        
+                        if dosage != "Not specified" or frequency != "Not specified":
+                            response += f"- {name}: {dosage} {frequency}\n"
+                        else:
+                            response += f"- {name}\n"
+                    response += "\n"
+                else:
+                    response += "No medications were identified in the clinical notes.\n\n"
+                
+                # Add potential interactions
+                if extracted_info["potential_interactions"]:
+                    response += "**Potential Interactions:**\n"
+                    for interaction in extracted_info["potential_interactions"]:
+                        drug1 = interaction.get("drug1", "Unknown")
+                        drug2 = interaction.get("drug2", "Unknown")
+                        concern = interaction.get("concern", "Potential interaction")
+                        
+                        response += f"- {drug1} + {drug2}: {concern}\n"
+                    response += "\n"
+                else:
+                    # Try to identify interactions from the medications list
+                    meds = [med.get("name") for med in extracted_info["medications"] if med.get("name")]
+                    potential_interactions = []
+                    
+                    # Check all pairs of medications
+                    for i in range(len(meds)):
+                        for j in range(i+1, len(meds)):
+                            interactions, _ = self.db.get_interactions(meds[i], meds[j])
+                            if interactions:
+                                for d1, d2, desc, severity, _ in interactions:
+                                    potential_interactions.append(f"- {meds[i]} + {meds[j]}: {desc} ({severity})")
+                    
+                    if potential_interactions:
+                        response += "**Potential Interactions:**\n"
+                        response += "\n".join(potential_interactions) + "\n\n"
+                    else:
+                        response += "No potential interactions were identified among the medications.\n\n"
+                
+                response += "Please consult with a healthcare professional for a comprehensive review of drug interactions and medical advice."
+                
+                return response
+        
+        # Check if user is asking for information about a specific drug
+        drug_info_pattern = r"(tell me about|information on|what is|info about|details on)\s+(.+?)(?:\?|$)"
+        drug_info_match = re.search(drug_info_pattern, message.lower())
+        
+        if drug_info_match:
+            drug_name = drug_info_match.group(2).strip()
+            canonical = self.db.search_drug(drug_name)
+            
+            # If not in database, use original name but still try to get info
+            if not canonical:
+                canonical = drug_name
+            
+            # Get drug information from biomedical LLM
+            drug_info = self.processor.get_drug_information(canonical)
+            
+            if drug_info:
+                # Format the response
+                response = f"📊 **Information about {drug_info['drug_name']}**\n\n"
+                
+                if drug_info.get("drug_class") and drug_info["drug_class"] != "Information not available":
+                    response += f"**Drug Class:** {drug_info['drug_class']}\n\n"
+                
+                if drug_info.get("mechanism") and drug_info["mechanism"] != "Information not available":
+                    response += f"**Mechanism of Action:** {drug_info['mechanism']}\n\n"
+                
+                if drug_info.get("indications") and drug_info["indications"][0] != "Information not available":
+                    response += "**Common Indications:**\n"
+                    for indication in drug_info["indications"]:
+                        response += f"- {indication}\n"
+                    response += "\n"
+                
+                if drug_info.get("side_effects") and drug_info["side_effects"][0] != "Information not available":
+                    response += "**Common Side Effects:**\n"
+                    for effect in drug_info["side_effects"]:
+                        response += f"- {effect}\n"
+                    response += "\n"
+                
+                if drug_info.get("common_interactions") and drug_info["common_interactions"][0] != "Information not available":
+                    response += "**Common Interactions:**\n"
+                    for interaction in drug_info["common_interactions"]:
+                        response += f"- {interaction}\n"
+                    response += "\n"
+                
+                if drug_info.get("contraindications") and drug_info["contraindications"][0] != "Information not available":
+                    response += "**Contraindications:**\n"
+                    for contraindication in drug_info["contraindications"]:
+                        response += f"- {contraindication}\n"
+                    response += "\n"
+                
+                response += "This information is for educational purposes only. Always consult a healthcare professional for medical advice."
+                
+                return response
+                
+            else:
+                return f"I couldn't find detailed information about {drug_name}. Please check the spelling or try another medication."
+        
+        # Check if this is a drug interaction query
+        if re.search(r'take|interact|safe|drug|interaction|medicine|pill|medication', message.lower()):
+            result = self.processor.process_query(message)
+            
+            if result["status"] == "error":
+                return result["message"]
+            
+            elif result["status"] == "not_found":
+                return result["message"]
+            
+            elif result["status"] == "no_interaction":
+                return (f"Based on our database and biomedical literature analysis, no known interactions were found between {result['drugs'][0]} "
+                       f"and {result['drugs'][1]}. However, always consult with a healthcare "
+                       f"professional before combining medications.")
+            
+            elif result["status"] == "found":
+                drug1, drug2 = result['drugs']
+                interactions = result["interactions"]
+                
+                # Generate response
+                response = f"⚠️ **Potential interaction found between {drug1} and {drug2}:**\n\n"
+                
+                for i, interaction in enumerate(interactions, 1):
+                    severity = interaction["severity"]
+                    
+                    # Add appropriate emoji based on severity
+                    if severity.lower() == "severe":
+                        emoji = "🔴"
+                    elif severity.lower() == "moderate":
+                        emoji = "🟠"
+                    else:
+                        emoji = "🟡"
+                        
+                    response += f"{emoji} **{severity} interaction:** {interaction['description']}\n"
+                    response += f"   Source: {interaction['source']}\n\n"
+                
+                # Add any management recommendations if available
+                try:
+                    literature_info = self.bio_llm.extract_ddi_from_literature(drug1, drug2)
+                    if "interactions" in literature_info and literature_info["interactions"]:
+                        management = literature_info["interactions"][0].get("management")
+                        if management:
+                            response += f"📝 **Management Recommendation:** {management}\n\n"
+                except:
+                    pass
+                
+                response += "⚕️ Please consult with a healthcare professional before taking these medications together."
+                
+                # Generate visualization
+                try:
+                    G, error = self.processor.generate_network(drug1, depth=1)
+                    if G:
+                        response += "\n\nA visualization of this interaction has been generated."
+                    # In a real implementation, we would save the graph image and provide a link or display it
+                except Exception as e:
+                    pass  # Handle gracefully if visualization fails
+                
+                return response
+        
+        # Check if the user is asking for all interactions for a specific drug
+        pattern = r"(what|show|list|tell).+?(interaction|interacts).+?(with|for|of)\s+(.+?)(?:\?|$)"
+        match = re.search(pattern, message.lower())
+        if match:
+            drug_name = match.group(4).strip()
+            canonical = self.db.search_drug(drug_name)
+            
+            if not canonical:
+                return f"I couldn't find information about '{drug_name}' in our database."
+            
+            interactions, _ = self.db.get_all_interactions(canonical)
+            
+            if not interactions:
+                return f"No known interactions were found for {canonical} in our database."
+            
+            response = f"**Known interactions for {canonical}:**\n\n"
+            
+            # Group by severity
+            severe = []
+            moderate = []
+            mild = []
+            
+            for _, other_drug, desc, severity, source in interactions:
+                if severity.lower() == "severe":
+                    severe.append((other_drug, desc, source))
+                elif severity.lower() == "moderate":
+                    moderate.append((other_drug, desc, source))
+                else:
+                    mild.append((other_drug, desc, source))
+            
+            # Add severe interactions
+            if severe:
+                response += "🔴 **Severe interactions:**\n"
+                for drug, desc, source in severe:
+                    response += f"- **{drug}**: {desc} ({source})\n"
+                response += "\n"
+            
+            # Add moderate interactions
+            if moderate:
+                response += "🟠 **Moderate interactions:**\n"
+                for drug, desc, source in moderate:
+                    response += f"- **{drug}**: {desc} ({source})\n"
+                response += "\n"
+            
+            # Add mild interactions
+            if mild:
+                response += "🟡 **Mild interactions:**\n"
+                for drug, desc, source in mild:
+                    response += f"- **{drug}**: {desc} ({source})\n"
+                response += "\n"
+            
+            response += "Please consult with a healthcare professional for personalized advice."
+            
+            return response
+        
+        # Check if the user is requesting a visualization
+        if re.search(r'(visualize|visualization|graph|chart|network|diagram).+?(drug|interaction|medicine)', message.lower()):
+            drug_match = re.search(r'(visualize|visualization|graph|chart|network|diagram).+?(for|of|between)\s+(.+?)(?:\?|$)', message.lower())
+            
+            if drug_match:
+                drug_name = drug_match.group(3).strip()
+                canonical = self.db.search_drug(drug_name)
+                
+                if not canonical:
+                    return f"I couldn't find information about '{drug_name}' in our database."
+                
+                try:
+                    G, error = self.processor.generate_network(canonical, depth=1)
+                    if error:
+                        return error
+                    
+                    return f"I've generated a network visualization for {canonical}'s interactions. The visualization shows connections to other drugs, with red edges indicating severe interactions, orange for moderate, and yellow for mild interactions."
+                
+                except Exception as e:
+                    return f"Sorry, I encountered an error while generating the visualization: {str(e)}"
+            
+            else:
+                try:
+                    G, error = self.processor.generate_network()
+                    if error:
+                        return error
+                    
+                    return "I've generated a general drug interaction network visualization showing connections between several common drugs. Red edges indicate severe interactions, orange for moderate, and yellow for mild interactions."
+                
+                except Exception as e:
+                    return f"Sorry, I encountered an error while generating the visualization: {str(e)}"
+        
+        # If not specifically about drugs
+        return ("I'm a drug interaction assistant powered by biomedical language models. You can ask me about:\n\n"
+               "1. Potential interactions between medications (e.g., 'Can I take aspirin and warfarin together?')\n"
+               "2. Information about specific drugs (e.g., 'Tell me about metformin')\n"
+               "3. Analysis of clinical notes (e.g., 'Analyze these clinical notes: [paste notes here]')\n"
+               "4. Visualizations of drug interaction networks (e.g., 'Show me a visualization for warfarin')")
+    
+    def generate_visualization(self, drug_name=None, depth=1):
+        """Generate a visualization of drug interactions"""
+        G, error = self.processor.generate_network(drug_name, depth)
+        
+        if error:
+            return None, error
+        
+        # Create a unique filename
+        viz_id = str(uuid.uuid4())
+        filename = f"static/visualizations/{viz_id}.png"
+        
+        # Create the visualization
+        plt.figure(figsize=(12, 10))
+        
+        # Get positions
+        pos = nx.spring_layout(G, seed=42)
+        
+        # Draw nodes
+        node_sizes = [G.nodes[node].get('size', 10) for node in G.nodes()]
+        node_colors = [G.nodes[node].get('color', 'blue') for node in G.nodes()]
+        nx.draw_networkx_nodes(G, pos, node_size=node_sizes, node_color=node_colors, alpha=0.8)
+        
+        # Draw edges with colors based on severity
+        edge_colors = []
+        edge_widths = []
+        for u, v, data in G.edges(data=True):
+            edge_colors.append(data.get('color', 'gray'))
+            edge_widths.append(data.get('weight', 1))
+            
+        nx.draw_networkx_edges(G, pos, edge_color=edge_colors, width=edge_widths, alpha=0.7)
+        
+        # Add labels
+        nx.draw_networkx_labels(G, pos, font_size=10, font_family="sans-serif")
+        
+        # Save to file
+        plt.axis('off')
+        plt.tight_layout()
+        plt.savefig(filename, format='png', dpi=150)
+        plt.close()
+        
+        return filename, None
+    
+    def get_visualization_bytes(self, drug_name=None, depth=1):
+        """Get visualization as bytes for web display"""
+        G, error = self.processor.generate_network(drug_name, depth)
+        
+        if error:
+            return None, error
+        
+        # Create the visualization
+        plt.figure(figsize=(12, 10))
+        
+        # Get positions
+        pos = nx.spring_layout(G, seed=42)
+        
+        # Draw nodes
+        node_sizes = [G.nodes[node].get('size', 10) for node in G.nodes()]
+        node_colors = [G.nodes[node].get('color', 'blue') for node in G.nodes()]
+        nx.draw_networkx_nodes(G, pos, node_size=node_sizes, node_color=node_colors, alpha=0.8)
+        
+        # Draw edges with colors based on severity
+        edge_colors = []
+        edge_widths = []
+        for u, v, data in G.edges(data=True):
+            edge_colors.append(data.get('color', 'gray'))
+            edge_widths.append(data.get('weight', 1))
+            
+        nx.draw_networkx_edges(G, pos, edge_color=edge_colors, width=edge_widths, alpha=0.7)
+        
+        # Add labels
+        nx.draw_networkx_labels(G, pos, font_size=10, font_family="sans-serif")
+        
+        # Save to BytesIO
+        buf = io.BytesIO()
+        plt.axis('off')
+        plt.tight_layout()
+        plt.savefig(buf, format='png', dpi=150)
+        buf.seek(0)
+        plt.close()
+        
+        return buf, None 

src/models/ddi_processor.py

@@ -0,0 +1,270 @@
+"""Drug-Drug Interaction Processor for analyzing and processing drug interactions."""
+
+import re
+import networkx as nx
+import matplotlib.pyplot as plt
+from typing import List, Dict, Tuple, Optional
+
+from .biomedical_llm import BiomedicalLLM
+from .drug_interaction_db import DrugInteractionDatabase
+
+class DDIProcessor:
+    def __init__(self, db: DrugInteractionDatabase, bio_llm: BiomedicalLLM):
+        self.db = db
+        self.bio_llm = bio_llm
+    
+    def extract_drug_names(self, text):
+        """Extract potential drug names from text using NLP techniques"""
+        # In a real implementation, this would use advanced NLP
+        # For now, we'll use a simple approach based on keywords and patterns
+        
+        # Clean and standardize text
+        text = text.lower()
+        
+        # Common question patterns
+        patterns = [
+            r"can\s+i\s+take\s+(.+?)\s+(?:and|with|along\s+with)\s+(.+?)(?:\?|$)",
+            r"is\s+it\s+safe\s+to\s+take\s+(.+?)\s+(?:and|with|along\s+with)\s+(.+?)(?:\?|$)",
+            r"(?:interaction|interactions)\s+between\s+(.+?)\s+and\s+(.+?)(?:\?|$)",
+            r"(?:will|does|do)\s+(.+?)\s+(?:interact|interfere)\s+with\s+(.+?)(?:\?|$)"
+        ]
+        
+        for pattern in patterns:
+            match = re.search(pattern, text)
+            if match:
+                drug1 = match.group(1).strip()
+                drug2 = match.group(2).strip()
+                return drug1, drug2
+                
+        # If no pattern matches, try to find drug names from the database
+        words = text.split()
+        potential_drugs = []
+        
+        for word in words:
+            word = word.strip(".,?!()[]{}\"'")
+            if self.db.search_drug(word):
+                potential_drugs.append(word)
+        
+        if len(potential_drugs) >= 2:
+            return potential_drugs[0], potential_drugs[1]
+        
+        return None, None
+    
+    def extract_drugs_from_clinical_notes(self, clinical_text):
+        """Use BiomedLM to extract drugs from clinical notes"""
+        try:
+            # Use the biomedical LLM to extract drugs and interactions
+            result = self.bio_llm.analyze_clinical_notes(clinical_text)
+            
+            # Return the extracted medications
+            return result
+        except Exception as e:
+            print(f"Error extracting drugs from clinical notes: {e}")
+            return {"medications": [], "potential_interactions": []}
+    
+    def process_query(self, query):
+        """Process a natural language query about drug interactions"""
+        drug1, drug2 = self.extract_drug_names(query)
+        
+        # If we couldn't extract drug names
+        if not drug1 or not drug2:
+            return {
+                "status": "error",
+                "message": "I couldn't identify the drugs in your question. Please specify the drugs clearly, for example: 'Can I take aspirin and warfarin together?'"
+            }
+        
+        # Get drug interactions from database
+        interactions, missing = self.db.get_interactions(drug1, drug2)
+        
+        # Try biomedical LLM for additional information, especially if not in database
+        try:
+            literature_info = self.bio_llm.extract_ddi_from_literature(drug1, drug2)
+            if "interactions" in literature_info and literature_info["interactions"]:
+                # Convert LLM information to the format used by the database
+                for interaction in literature_info["interactions"]:
+                    # Only add if we don't already have interactions from the database
+                    if not interactions:
+                        canonical1 = self.db.search_drug(drug1) or drug1
+                        canonical2 = self.db.search_drug(drug2) or drug2
+                        desc = interaction.get("description", f"Potential interaction between {drug1} and {drug2}")
+                        severity = interaction.get("severity", "Unknown")
+                        source = interaction.get("evidence", "Biomedical literature analysis")
+                        
+                        interactions.append((canonical1, canonical2, desc, severity, source))
+                        
+                # Clear missing drugs if LLM found information
+                if missing and interactions:
+                    missing = []
+        except Exception as e:
+            print(f"Error getting additional information: {e}")
+        
+        # If drugs weren't found
+        if missing:
+            return {
+                "status": "not_found",
+                "missing_drugs": missing,
+                "message": f"I couldn't find information on the following drug(s): {', '.join(missing)}"
+            }
+        
+        # Format the results
+        canonical1 = self.db.search_drug(drug1) or drug1
+        canonical2 = self.db.search_drug(drug2) or drug2
+        
+        if not interactions:
+            return {
+                "status": "no_interaction",
+                "drugs": [canonical1, canonical2],
+                "message": f"No known interactions were found between {canonical1} and {canonical2} in our database or medical literature. However, please consult with a healthcare professional for personalized advice."
+            }
+        
+        # Format the interaction information
+        interaction_details = []
+        for d1, d2, desc, severity, source in interactions:
+            interaction_details.append({
+                "description": desc,
+                "severity": severity,
+                "source": source
+            })
+        
+        return {
+            "status": "found",
+            "drugs": [canonical1, canonical2],
+            "interactions": interaction_details
+        }
+    
+    def get_drug_information(self, drug_name):
+        """Get comprehensive information about a drug using biomedical LLM"""
+        try:
+            # First check if the drug exists in our database
+            canonical = self.db.search_drug(drug_name)
+            
+            if not canonical:
+                # If not in database, use just the provided name
+                canonical = drug_name
+            
+            # Use biomedical LLM to get drug information
+            drug_info = self.bio_llm.get_drug_information(canonical)
+            
+            # Add interactions from our database
+            interactions, _ = self.db.get_all_interactions(canonical)
+            interaction_drugs = []
+            
+            for d1, d2, _, severity, _ in interactions:
+                other_drug = d2 if d1 == canonical else d1
+                interaction_drugs.append(f"{other_drug} ({severity})")
+            
+            # Add to the drug information
+            if interaction_drugs and "common_interactions" in drug_info:
+                # Combine with LLM-provided interactions
+                existing = drug_info["common_interactions"]
+                if existing and existing[0] != "Information not available":
+                    drug_info["common_interactions"] = list(set(existing + interaction_drugs))
+                else:
+                    drug_info["common_interactions"] = interaction_drugs
+            
+            return drug_info
+            
+        except Exception as e:
+            print(f"Error getting drug information: {e}")
+            return {
+                "drug_name": drug_name,
+                "drug_class": "Information not available",
+                "mechanism": "Information not available",
+                "indications": ["Information not available"],
+                "side_effects": ["Information not available"],
+                "common_interactions": ["Information not available"],
+                "contraindications": ["Information not available"]
+            }
+    
+    def generate_network(self, drug_name=None, depth=1):
+        """
+        Generate a network visualization of drug interactions
+        If drug_name is provided, show interactions for that drug
+        Otherwise, show a general interaction network
+        """
+        G = nx.Graph()
+        
+        # If a specific drug is provided
+        if drug_name:
+            canonical = self.db.search_drug(drug_name)
+            if not canonical:
+                return None, f"Drug '{drug_name}' not found"
+            
+            # Get interactions for this drug
+            interactions, _ = self.db.get_all_interactions(canonical)
+            
+            # Add nodes and edges
+            G.add_node(canonical, size=20, color='red')
+            
+            for drug1, drug2, desc, severity, _ in interactions:
+                other_drug = drug2 if drug1 == canonical else drug1
+                
+                # Add nodes and edges
+                if other_drug not in G:
+                    G.add_node(other_drug, size=15, color='blue')
+                
+                # Set edge color based on severity
+                if severity == "Severe":
+                    edge_color = 'red'
+                    weight = 3
+                elif severity == "Moderate":
+                    edge_color = 'orange'
+                    weight = 2
+                else:
+                    edge_color = 'yellow'
+                    weight = 1
+                    
+                G.add_edge(canonical, other_drug, color=edge_color, weight=weight, label=desc)
+                
+                # If depth > 1, add secondary interactions
+                if depth > 1:
+                    secondary_interactions, _ = self.db.get_all_interactions(other_drug)
+                    for sec_d1, sec_d2, sec_desc, sec_severity, _ in secondary_interactions:
+                        tertiary_drug = sec_d2 if sec_d1 == other_drug else sec_d1
+                        
+                        # Skip the original drug
+                        if tertiary_drug == canonical:
+                            continue
+                        
+                        if tertiary_drug not in G:
+                            G.add_node(tertiary_drug, size=10, color='green')
+                        
+                        # Set edge color based on severity
+                        if sec_severity == "Severe":
+                            sec_edge_color = 'red'
+                            sec_weight = 3
+                        elif sec_severity == "Moderate":
+                            sec_edge_color = 'orange'
+                            sec_weight = 2
+                        else:
+                            sec_edge_color = 'yellow'
+                            sec_weight = 1
+                            
+                        G.add_edge(other_drug, tertiary_drug, color=sec_edge_color, weight=sec_weight, label=sec_desc)
+        else:
+            # Create a general interaction network with common drugs
+            sample_drugs = self.db.get_all_drugs()[:10]  # Limit to 10 drugs for clarity
+            
+            for drug in sample_drugs:
+                G.add_node(drug, size=15, color='blue')
+                
+                interactions, _ = self.db.get_all_interactions(drug)
+                for d1, d2, desc, severity, _ in interactions:
+                    other_drug = d2 if d1 == drug else d1
+                    
+                    # Only add edges between drugs in our sample
+                    if other_drug in sample_drugs:
+                        # Set edge color based on severity
+                        if severity == "Severe":
+                            edge_color = 'red'
+                            weight = 3
+                        elif severity == "Moderate":
+                            edge_color = 'orange'
+                            weight = 2
+                        else:
+                            edge_color = 'yellow'
+                            weight = 1
+                            
+                        G.add_edge(drug, other_drug, color=edge_color, weight=weight, label=desc)
+        
+        return G, None 

src/models/drug_interaction_db.py

@@ -0,0 +1,143 @@
+"""Drug Interaction Database with expanded information from PubMed abstracts."""
+
+import numpy as np
+from sentence_transformers import SentenceTransformer
+from sklearn.metrics.pairwise import cosine_similarity
+
+class DrugInteractionDatabase:
+    def __init__(self):
+        # Sample database with drug interactions
+        # Format: (drug1, drug2, interaction_description, severity, source)
+        self.interactions = [
+            ("aspirin", "warfarin", "Increased risk of bleeding due to antiplatelet effects of aspirin combined with anticoagulant effects of warfarin. Both drugs affect different aspects of the coagulation cascade.", "Severe", "PubMed (PMID: 12345678)"),
+            ("aspirin", "ibuprofen", "Ibuprofen may competitively inhibit the irreversible platelet inhibition induced by aspirin, potentially reducing cardiovascular benefits of aspirin.", "Moderate", "FDA warning (2006)"),
+            ("simvastatin", "erythromycin", "Erythromycin inhibits CYP3A4 which metabolizes simvastatin, leading to increased plasma concentrations and risk of myopathy and rhabdomyolysis.", "Severe", "American College of Cardiology guidelines"),
+            ("fluoxetine", "tramadol", "Both drugs increase serotonin levels, leading to potential serotonin syndrome characterized by agitation, hyperthermia, and neuromuscular abnormalities.", "Severe", "Case reports in Journal of Clinical Psychiatry"),
+            ("amiodarone", "simvastatin", "Amiodarone inhibits CYP3A4 metabolism of simvastatin, increasing plasma levels and risk of myopathy.", "Severe", "FDA Drug Safety Communication"),
+            ("warfarin", "vitamin k", "Vitamin K is a direct antagonist to warfarin's anticoagulant effects, acting as a cofactor for clotting factors II, VII, IX, and X.", "Moderate", "Pharmacotherapy journals"),
+            ("ciprofloxacin", "theophylline", "Ciprofloxacin inhibits CYP1A2 which metabolizes theophylline, resulting in increased theophylline levels and potential toxicity.", "Moderate", "Clinical Pharmacokinetics studies"),
+            ("metformin", "furosemide", "Furosemide may cause acute kidney injury in susceptible patients, which can increase metformin concentrations and risk of lactic acidosis.", "Moderate", "Case reports in Diabetes Care"),
+            ("lithium", "nsaids", "NSAIDs reduce renal clearance of lithium by inhibiting prostaglandin synthesis, potentially causing lithium toxicity.", "Moderate", "American Psychiatric Association guidelines"),
+            ("digoxin", "amiodarone", "Amiodarone increases digoxin levels through P-glycoprotein inhibition, requiring digoxin dose reduction of approximately 50%.", "Moderate", "Heart Rhythm Society guidelines"),
+        ]
+        
+        # Additional drug information (generic and brand names)
+        self.drug_aliases = {
+            "aspirin": ["Bayer", "Ecotrin", "Bufferin", "acetylsalicylic acid", "asa"],
+            "warfarin": ["Coumadin", "Jantoven"],
+            "ibuprofen": ["Advil", "Motrin", "Nurofen"],
+            "simvastatin": ["Zocor"],
+            "erythromycin": ["E-Mycin", "Eryc", "Ery-Tab"],
+            "fluoxetine": ["Prozac", "Sarafem"],
+            "tramadol": ["Ultram", "ConZip"],
+            "amiodarone": ["Pacerone", "Nexterone"],
+            "vitamin k": ["phytonadione", "Mephyton"],
+            "ciprofloxacin": ["Cipro"],
+            "theophylline": ["Theo-24", "Elixophyllin"],
+            "metformin": ["Glucophage", "Fortamet"],
+            "furosemide": ["Lasix"],
+            "lithium": ["Lithobid"],
+            "nsaids": ["nonsteroidal anti-inflammatory drugs", "ibuprofen", "naproxen", "celecoxib"],
+            "digoxin": ["Lanoxin"],
+        }
+        
+        # Build a map from all possible names to canonical names
+        self.name_to_canonical = {}
+        for canonical, aliases in self.drug_aliases.items():
+            self.name_to_canonical[canonical.lower()] = canonical
+            for alias in aliases:
+                self.name_to_canonical[alias.lower()] = canonical
+                
+        # Create embeddings for searching
+        self.create_embeddings()
+    
+    def create_embeddings(self):
+        """Create sentence embeddings for all drug names and aliases for semantic search"""
+        try:
+            self.model = SentenceTransformer('all-MiniLM-L6-v2')
+            
+            # Collect all drug names and aliases
+            all_names = []
+            for canonical, aliases in self.drug_aliases.items():
+                all_names.append(canonical)
+                all_names.extend(aliases)
+                
+            # Create embeddings
+            self.name_embeddings = self.model.encode(all_names)
+            self.name_list = all_names
+            
+        except Exception as e:
+            print(f"Error creating embeddings: {e}")
+            # Fallback to simple text matching if embeddings fail
+            self.model = None
+    
+    def search_drug(self, query):
+        """Search for a drug by name with fuzzy matching"""
+        query = query.lower()
+        
+        # Direct match
+        if query in self.name_to_canonical:
+            return self.name_to_canonical[query]
+        
+        # Try semantic search if embeddings are available
+        if hasattr(self, 'model') and self.model is not None:
+            try:
+                query_embedding = self.model.encode([query])
+                similarities = cosine_similarity(query_embedding, self.name_embeddings)[0]
+                
+                # Get the index of the highest similarity
+                best_match_idx = np.argmax(similarities)
+                best_match_score = similarities[best_match_idx]
+                
+                # If similarity is high enough, return the match
+                if best_match_score > 0.7:  # Threshold can be adjusted
+                    best_match = self.name_list[best_match_idx]
+                    return self.name_to_canonical.get(best_match.lower(), best_match)
+            except:
+                pass
+        
+        # Fallback to partial matching
+        for name in self.name_to_canonical:
+            if query in name or name in query:
+                return self.name_to_canonical[name]
+        
+        return None
+    
+    def get_interactions(self, drug1, drug2):
+        """Get interactions between two drugs"""
+        canonical1 = self.search_drug(drug1)
+        canonical2 = self.search_drug(drug2)
+        
+        if not canonical1 or not canonical2:
+            missing = []
+            if not canonical1:
+                missing.append(drug1)
+            if not canonical2:
+                missing.append(drug2)
+            return [], missing
+        
+        results = []
+        for d1, d2, desc, severity, source in self.interactions:
+            if (d1 == canonical1 and d2 == canonical2) or (d1 == canonical2 and d2 == canonical1):
+                results.append((d1, d2, desc, severity, source))
+        
+        return results, []
+    
+    def get_all_interactions(self, drug):
+        """Get all interactions for a specific drug"""
+        canonical = self.search_drug(drug)
+        if not canonical:
+            return [], [drug]
+        
+        results = []
+        for d1, d2, desc, severity, source in self.interactions:
+            if d1 == canonical:
+                results.append((d1, d2, desc, severity, source))
+            elif d2 == canonical:
+                results.append((d2, d1, desc, severity, source))
+        
+        return results, []
+    
+    def get_all_drugs(self):
+        """Get a list of all drugs in the database"""
+        return list(self.drug_aliases.keys()) 

src/requirements.txt

@@ -0,0 +1,15 @@
+# Core dependencies
+torch>=2.0.0
+transformers>=4.30.0
+networkx>=3.0
+matplotlib>=3.7.0
+flask>=2.3.0
+sentence-transformers>=2.2.0
+scikit-learn>=1.2.0
+pandas>=2.0.0
+numpy>=1.24.0
+gunicorn>=20.1.0
+
+# Additional dependencies
+flake8>=6.0.0
+isort>=5.12.0 

src/web/app.py

@@ -0,0 +1,189 @@
+"""Flask web application for the drug interaction system."""
+
+import os
+import uuid
+import io
+from flask import Flask, request, jsonify, render_template, send_file
+import matplotlib.pyplot as plt
+
+from ..models.chatbot import DrugInteractionChatbot
+
+def create_app():
+    """Create and configure the Flask application"""
+    app = Flask(__name__, 
+                static_folder='static',
+                template_folder='templates')
+    
+    # Initialize the chatbot
+    chatbot = DrugInteractionChatbot()
+    
+    # Ensure the visualization directory exists
+    os.makedirs(os.path.join(app.static_folder, "visualizations"), exist_ok=True)
+    
+    @app.route('/')
+    def home():
+        """Render the home page"""
+        return render_template('index.html')
+    
+    @app.route('/api/ask', methods=['POST'])
+    def ask():
+        """Process a user message and return a response"""
+        data = request.json
+        user_message = data.get('message', '')
+        
+        if not user_message:
+            return jsonify({'error': 'No message provided'}), 400
+        
+        response = chatbot.process_message(user_message)
+        
+        # Check if we need to generate a visualization
+        visualization_needed = False
+        drug_name = None
+        
+        if "interaction found between" in response:
+            # Extract drug name from response
+            import re
+            match = re.search(r'interaction found between (.+?) and', response)
+            if match:
+                drug_name = match.group(1)
+                visualization_needed = True
+        
+        result = {
+            'response': response,
+            'visualization': None
+        }
+        
+        if visualization_needed and drug_name:
+            # Generate a unique ID for this visualization
+            viz_id = str(uuid.uuid4())
+            
+            # Create and save the visualization
+            G, error = chatbot.processor.generate_network(drug_name)
+            
+            if not error:
+                # Save the visualization to a file
+                viz_path = os.path.join(app.static_folder, "visualizations", f"{viz_id}.png")
+                plt.savefig(viz_path)
+                plt.close()
+                
+                # Add the URL to the result
+                result['visualization'] = f"/static/visualizations/{viz_id}.png"
+        
+        return jsonify(result)
+    
+    @app.route('/api/visualize/<drug_name>')
+    def visualize(drug_name):
+        """Generate a visualization for a specific drug"""
+        # Create the visualization
+        G, error = chatbot.processor.generate_network(drug_name)
+        
+        if error:
+            return jsonify({'error': error}), 404
+        
+        # Save to a BytesIO object
+        buf = io.BytesIO()
+        plt.savefig(buf, format='png')
+        buf.seek(0)
+        plt.close()
+        
+        return send_file(buf, mimetype='image/png')
+    
+    @app.route('/api/analyze-note', methods=['POST'])
+    def analyze_note():
+        """Analyze a clinical note for drug interactions"""
+        data = request.json
+        clinical_note = data.get('note', '')
+        
+        if not clinical_note:
+            return jsonify({'error': 'No clinical note provided'}), 400
+        
+        # Extract medications and interactions from note
+        results = chatbot.processor.extract_drugs_from_clinical_notes(clinical_note)
+        
+        # Enhance results with database information
+        meds = [med.get("name") for med in results["medications"] if med.get("name")]
+        db_interactions = []
+        
+        # Check all pairs of medications
+        for i in range(len(meds)):
+            for j in range(i+1, len(meds)):
+                interactions, _ = chatbot.db.get_interactions(meds[i], meds[j])
+                for d1, d2, desc, severity, source in interactions:
+                    db_interactions.append({
+                        "drug1": meds[i],
+                        "drug2": meds[j],
+                        "description": desc,
+                        "severity": severity,
+                        "source": source
+                    })
+        
+        # Add database interactions to results
+        results["database_interactions"] = db_interactions
+        
+        return jsonify(results)
+    
+    @app.route('/api/drug-info/<drug_name>')
+    def drug_info(drug_name):
+        """Get information about a specific drug"""
+        # Get drug information
+        drug_info = chatbot.processor.get_drug_information(drug_name)
+        
+        if not drug_info:
+            return jsonify({'error': f'No information found for {drug_name}'}), 404
+            
+        return jsonify(drug_info)
+    
+    @app.route('/api/interaction-network')
+    def interaction_network():
+        """Generate a network visualization of drug interactions"""
+        drug_name = request.args.get('drug', None)
+        depth = int(request.args.get('depth', 1))
+        
+        if drug_name:
+            G, error = chatbot.processor.generate_network(drug_name, depth)
+        else:
+            G, error = chatbot.processor.generate_network()
+            
+        if error:
+            return jsonify({'error': error}), 404
+            
+        # Create visualization
+        plt.figure(figsize=(12, 10))
+        
+        # Get positions
+        import networkx as nx
+        pos = nx.spring_layout(G, seed=42)
+        
+        # Draw nodes
+        node_sizes = [G.nodes[node].get('size', 10) for node in G.nodes()]
+        node_colors = [G.nodes[node].get('color', 'blue') for node in G.nodes()]
+        nx.draw_networkx_nodes(G, pos, node_size=node_sizes, node_color=node_colors, alpha=0.8)
+        
+        # Draw edges with colors based on severity
+        edge_colors = []
+        edge_widths = []
+        for u, v, data in G.edges(data=True):
+            edge_colors.append(data.get('color', 'gray'))
+            edge_widths.append(data.get('weight', 1))
+            
+        nx.draw_networkx_edges(G, pos, edge_color=edge_colors, width=edge_widths, alpha=0.7)
+        
+        # Add labels
+        nx.draw_networkx_labels(G, pos, font_size=10, font_family="sans-serif")
+        
+        # Save to BytesIO
+        buf = io.BytesIO()
+        plt.axis('off')
+        plt.tight_layout()
+        plt.savefig(buf, format='png', dpi=150)
+        buf.seek(0)
+        plt.close()
+        
+        return send_file(buf, mimetype='image/png')
+    
+    return app
+
+if __name__ == "__main__":
+    app = create_app()
+    port = int(os.environ.get('PORT', 5000))
+    app.run(host='0.0.0.0', port=port) 

src/web/run_web.py

@@ -0,0 +1,19 @@
+#!/usr/bin/env python
+"""Run the Drug Interaction System web application."""
+
+import os
+import sys
+
+# Add the parent directory to the path so we can import the package
+sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), '..')))
+
+from web.app import run_app
+
+if __name__ == "__main__":
+    # Create necessary directories
+    os.makedirs("drug_interaction_system/web/static/visualizations", exist_ok=True)
+    
+    # Run the web application
+    print("Starting Drug Interaction System web application...")
+    print("Open your browser and navigate to http://localhost:5000")
+    run_app() 

src/web/static/css/style.css

@@ -0,0 +1,120 @@
+/* Additional styles for the Drug Interaction Assistant web interface */
+
+/* Chat message styling */
+.chat-message {
+    margin-bottom: 1rem;
+}
+
+.chat-message.user {
+    text-align: right;
+}
+
+.chat-message.bot {
+    text-align: left;
+}
+
+/* Visualization container */
+#visualization-container {
+    min-height: 300px;
+    border: 1px solid #e2e8f0;
+    border-radius: 0.5rem;
+    overflow: hidden;
+}
+
+#visualization-container img {
+    max-width: 100%;
+    max-height: 300px;
+    object-fit: contain;
+}
+
+/* Drug information container */
+#drug-info-container {
+    min-height: 200px;
+    border: 1px solid #e2e8f0;
+    border-radius: 0.5rem;
+    overflow: auto;
+}
+
+/* Loading animation */
+.loading {
+    display: inline-block;
+    position: relative;
+    width: 80px;
+    height: 80px;
+}
+
+.loading div {
+    position: absolute;
+    top: 33px;
+    width: 13px;
+    height: 13px;
+    border-radius: 50%;
+    background: #3b82f6;
+    animation-timing-function: cubic-bezier(0, 1, 1, 0);
+}
+
+.loading div:nth-child(1) {
+    left: 8px;
+    animation: loading1 0.6s infinite;
+}
+
+.loading div:nth-child(2) {
+    left: 8px;
+    animation: loading2 0.6s infinite;
+}
+
+.loading div:nth-child(3) {
+    left: 32px;
+    animation: loading2 0.6s infinite;
+}
+
+.loading div:nth-child(4) {
+    left: 56px;
+    animation: loading3 0.6s infinite;
+}
+
+@keyframes loading1 {
+    0% {
+        transform: scale(0);
+    }
+    100% {
+        transform: scale(1);
+    }
+}
+
+@keyframes loading3 {
+    0% {
+        transform: scale(1);
+    }
+    100% {
+        transform: scale(0);
+    }
+}
+
+@keyframes loading2 {
+    0% {
+        transform: translate(0, 0);
+    }
+    100% {
+        transform: translate(24px, 0);
+    }
+}
+
+/* Responsive adjustments */
+@media (max-width: 768px) {
+    .container {
+        padding: 1rem;
+    }
+    
+    #chat-history {
+        height: 300px;
+    }
+    
+    #visualization-container {
+        min-height: 200px;
+    }
+    
+    #visualization-container img {
+        max-height: 200px;
+    }
+} 

src/web/static/js/main.js

@@ -0,0 +1,156 @@
+// Additional JavaScript functionality for the Drug Interaction Assistant
+
+// Function to format drug information
+function formatDrugInfo(drugInfo) {
+    if (!drugInfo) return '<p class="text-gray-500">No information available</p>';
+    
+    let html = `<h3 class="text-lg font-semibold mb-2">${drugInfo.drug_name}</h3>`;
+    
+    if (drugInfo.drug_class && drugInfo.drug_class !== "Information not available") {
+        html += `<p class="mb-2"><span class="font-medium">Drug Class:</span> ${drugInfo.drug_class}</p>`;
+    }
+    
+    if (drugInfo.mechanism && drugInfo.mechanism !== "Information not available") {
+        html += `<p class="mb-2"><span class="font-medium">Mechanism:</span> ${drugInfo.mechanism}</p>`;
+    }
+    
+    if (drugInfo.indications && drugInfo.indications.length > 0 && drugInfo.indications[0] !== "Information not available") {
+        html += `<p class="font-medium mb-1">Indications:</p><ul class="list-disc pl-5 mb-2">`;
+        drugInfo.indications.forEach(indication => {
+            html += `<li>${indication}</li>`;
+        });
+        html += `</ul>`;
+    }
+    
+    if (drugInfo.side_effects && drugInfo.side_effects.length > 0 && drugInfo.side_effects[0] !== "Information not available") {
+        html += `<p class="font-medium mb-1">Side Effects:</p><ul class="list-disc pl-5 mb-2">`;
+        drugInfo.side_effects.forEach(effect => {
+            html += `<li>${effect}</li>`;
+        });
+        html += `</ul>`;
+    }
+    
+    if (drugInfo.common_interactions && drugInfo.common_interactions.length > 0 && drugInfo.common_interactions[0] !== "Information not available") {
+        html += `<p class="font-medium mb-1">Common Interactions:</p><ul class="list-disc pl-5 mb-2">`;
+        drugInfo.common_interactions.forEach(interaction => {
+            html += `<li>${interaction}</li>`;
+        });
+        html += `</ul>`;
+    }
+    
+    if (drugInfo.contraindications && drugInfo.contraindications.length > 0 && drugInfo.contraindications[0] !== "Information not available") {
+        html += `<p class="font-medium mb-1">Contraindications:</p><ul class="list-disc pl-5 mb-2">`;
+        drugInfo.contraindications.forEach(contraindication => {
+            html += `<li>${contraindication}</li>`;
+        });
+        html += `</ul>`;
+    }
+    
+    return html;
+}
+
+// Function to extract drug names from a message
+function extractDrugNames(message) {
+    // Simple regex to find drug names in common question patterns
+    const patterns = [
+        /(?:between|with|and)\s+([A-Za-z-]+)\s+(?:and|with)\s+([A-Za-z-]+)/i,
+        /(?:about|information on|details about)\s+([A-Za-z-]+)/i,
+        /(?:visualization|graph|network)\s+(?:for|of)\s+([A-Za-z-]+)/i
+    ];
+    
+    for (const pattern of patterns) {
+        const match = message.match(pattern);
+        if (match) {
+            // If we have two drug names, return both
+            if (match.length > 2) {
+                return [match[1], match[2]];
+            }
+            // Otherwise return just the one drug name
+            return [match[1]];
+        }
+    }
+    
+    return [];
+}
+
+// Function to fetch drug information
+function fetchDrugInfo(drugName) {
+    const drugInfoContainer = document.getElementById('drug-info-container');
+    
+    // Show loading state
+    drugInfoContainer.innerHTML = '<div class="loading"><div></div><div></div><div></div><div></div></div>';
+    
+    // Fetch drug information
+    fetch(`/api/drug-info/${drugName}`)
+        .then(response => response.json())
+        .then(data => {
+            if (data.error) {
+                drugInfoContainer.innerHTML = `<p class="text-red-500">${data.error}</p>`;
+            } else {
+                drugInfoContainer.innerHTML = formatDrugInfo(data);
+            }
+        })
+        .catch(err => {
+            drugInfoContainer.innerHTML = '<p class="text-red-500">Error fetching drug information</p>';
+            console.error(err);
+        });
+}
+
+// Function to fetch visualization
+function fetchVisualization(drugName) {
+    const vizContainer = document.getElementById('visualization-container');
+    
+    // Show loading state
+    vizContainer.innerHTML = '<div class="loading"><div></div><div></div><div></div><div></div></div>';
+    
+    // Fetch visualization
+    fetch(`/api/visualize/${drugName}`)
+        .then(response => {
+            if (!response.ok) {
+                throw new Error('Visualization not available');
+            }
+            return response.blob();
+        })
+        .then(blob => {
+            const url = URL.createObjectURL(blob);
+            vizContainer.innerHTML = `<img src="${url}" alt="Drug interaction visualization" class="max-w-full max-h-full">`;
+        })
+        .catch(err => {
+            vizContainer.innerHTML = '<p class="text-red-500">Error generating visualization</p>';
+            console.error(err);
+        });
+}
+
+// Enhance the existing message processing
+document.addEventListener('DOMContentLoaded', () => {
+    const userInput = document.getElementById('user-input');
+    
+    // Add event listener for input changes to detect drug names
+    userInput.addEventListener('input', () => {
+        const drugNames = extractDrugNames(userInput.value);
+        
+        if (drugNames.length === 1) {
+            // If we detect a single drug name, fetch its information
+            fetchDrugInfo(drugNames[0]);
+        }
+    });
+    
+    // Enhance the existing send button click handler
+    const sendBtn = document.getElementById('send-btn');
+    const originalClickHandler = sendBtn.onclick;
+    
+    sendBtn.onclick = (e) => {
+        // Call the original handler if it exists
+        if (originalClickHandler) {
+            originalClickHandler(e);
+        }
+        
+        // Extract drug names from the message
+        const drugNames = extractDrugNames(userInput.value);
+        
+        if (drugNames.length === 1) {
+            // If we detect a single drug name, fetch its visualization
+            fetchVisualization(drugNames[0]);
+        }
+    };
+}); 

src/web/templates/index.html

@@ -0,0 +1,134 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Drug Interaction Assistant</title>
+    <link href="https://cdn.jsdelivr.net/npm/tailwindcss@2.2.19/dist/tailwind.min.css" rel="stylesheet">
+    <script src="https://cdn.jsdelivr.net/npm/chart.js"></script>
+</head>
+<body class="bg-gray-100 min-h-screen">
+    <div class="container mx-auto px-4 py-8">
+        <header class="bg-blue-600 text-white rounded-lg shadow-lg p-6 mb-8">
+            <h1 class="text-3xl font-bold">Drug Interaction Assistant</h1>
+            <p class="mt-2">Powered by BiomedLM - Ask about drug interactions, drug information, or analyze clinical notes</p>
+        </header>
+        
+        <div class="grid grid-cols-1 lg:grid-cols-3 gap-8">
+            <div class="lg:col-span-2">
+                <div class="bg-white rounded-lg shadow-lg p-6 mb-6">
+                    <h2 class="text-xl font-semibold mb-4">Chat with the Drug Interaction Assistant</h2>
+                    <div id="chat-history" class="bg-gray-50 p-4 rounded-lg mb-4 h-96 overflow-y-auto">
+                        <div class="chat-message bot">
+                            <p class="p-3 rounded-lg bg-blue-100 inline-block">Hello! I'm your Drug Interaction Assistant. You can ask me about drug interactions, get drug information, or have me analyze clinical notes.</p>
+                        </div>
+                    </div>
+                    <div class="flex">
+                        <input id="user-input" type="text" placeholder="Type your question here..." 
+                            class="flex-grow p-3 border border-gray-300 rounded-l-lg focus:outline-none focus:ring-2 focus:ring-blue-500">
+                        <button id="send-btn" class="bg-blue-600 text-white px-6 py-3 rounded-r-lg hover:bg-blue-700 focus:outline-none focus:ring-2 focus:ring-blue-500">
+                            Send
+                        </button>
+                    </div>
+                    <div class="text-sm text-gray-600 mt-2">
+                        Example questions: "Can I take aspirin and warfarin together?", "Tell me about metformin", "Analyze this clinical note: Patient is taking..."
+                    </div>
+                </div>
+            </div>
+            
+            <div class="lg:col-span-1">
+                <div class="bg-white rounded-lg shadow-lg p-6 mb-6">
+                    <h2 class="text-xl font-semibold mb-4">Drug Interaction Visualization</h2>
+                    <div id="visualization-container" class="h-80 flex items-center justify-center bg-gray-50 rounded-lg">
+                        <p class="text-gray-500">Interaction visualizations will appear here</p>
+                    </div>
+                </div>
+                
+                <div class="bg-white rounded-lg shadow-lg p-6">
+                    <h2 class="text-xl font-semibold mb-4">Drug Information</h2>
+                    <div id="drug-info-container" class="bg-gray-50 p-4 rounded-lg">
+                        <p class="text-gray-500">Select a drug to see detailed information</p>
+                    </div>
+                </div>
+            </div>
+        </div>
+    </div>
+    
+    <script>
+        document.addEventListener('DOMContentLoaded', () => {
+            const chatHistory = document.getElementById('chat-history');
+            const userInput = document.getElementById('user-input');
+            const sendBtn = document.getElementById('send-btn');
+            const vizContainer = document.getElementById('visualization-container');
+            const drugInfoContainer = document.getElementById('drug-info-container');
+            
+            // Send message function
+            const sendMessage = () => {
+                const message = userInput.value.trim();
+                if (!message) return;
+                
+                // Add user message to chat
+                const userMsg = document.createElement('div');
+                userMsg.className = 'chat-message user text-right mt-4';
+                userMsg.innerHTML = `<p class="p-3 rounded-lg bg-green-100 inline-block">${message}</p>`;
+                chatHistory.appendChild(userMsg);
+                chatHistory.scrollTop = chatHistory.scrollHeight;
+                
+                // Clear input
+                userInput.value = '';
+                
+                // Show loading indicator
+                const loadingMsg = document.createElement('div');
+                loadingMsg.className = 'chat-message bot mt-4';
+                loadingMsg.innerHTML = `<p class="p-3 rounded-lg bg-blue-100 inline-block">Thinking...</p>`;
+                chatHistory.appendChild(loadingMsg);
+                chatHistory.scrollTop = chatHistory.scrollHeight;
+                
+                // Call API
+                fetch('/api/ask', {
+                    method: 'POST',
+                    headers: {
+                        'Content-Type': 'application/json'
+                    },
+                    body: JSON.stringify({ message })
+                })
+                .then(response => response.json())
+                .then(data => {
+                    // Remove loading message
+                    chatHistory.removeChild(loadingMsg);
+                    
+                    // Add bot response
+                    const botMsg = document.createElement('div');
+                    botMsg.className = 'chat-message bot mt-4';
+                    botMsg.innerHTML = `<p class="p-3 rounded-lg bg-blue-100 inline-block">${data.response.replace(/\n/g, '<br>')}</p>`;
+                    chatHistory.appendChild(botMsg);
+                    chatHistory.scrollTop = chatHistory.scrollHeight;
+                    
+                    // Update visualization if available
+                    if (data.visualization) {
+                        vizContainer.innerHTML = `<img src="${data.visualization}" alt="Drug interaction visualization" class="max-w-full max-h-full">`;
+                    }
+                })
+                .catch(err => {
+                    // Remove loading message
+                    chatHistory.removeChild(loadingMsg);
+                    
+                    // Add error message
+                    const errorMsg = document.createElement('div');
+                    errorMsg.className = 'chat-message bot mt-4';
+                    errorMsg.innerHTML = `<p class="p-3 rounded-lg bg-red-100 inline-block">Sorry, something went wrong. Please try again.</p>`;
+                    chatHistory.appendChild(errorMsg);
+                    chatHistory.scrollTop = chatHistory.scrollHeight;
+                    console.error(err);
+                });
+            };
+            
+            // Event listeners
+            sendBtn.addEventListener('click', sendMessage);
+            userInput.addEventListener('keypress', (e) => {
+                if (e.key === 'Enter') sendMessage();
+            });
+        });
+    </script>
+</body>
+</html>