class MedicalNER:
    """Extract medical entities from clinical text."""
    
    def __init__(self, llm, medical_kb):
        self.llm = llm
        self.kb = medical_kb
    
    def extract_entities(self, clinical_note):
        """Extract medical entities from clinical note."""
        prompt = f"""Extract medical entities from this clinical note:

{clinical_note}

Identify:
1. Diagnoses (with ICD-10 codes if possible)
2. Medications (with dosages)
3. Procedures
4. Lab values (with units and reference ranges)
5. Symptoms
6. Temporal relationships

Structured extraction:"""
        
        return self.llm.generate(prompt)
    
    def normalize_entities(self, entities):
        """Normalize entities to standard medical ontologies."""
        normalized = []
        for entity in entities:
            # Map to SNOMED CT, ICD-10, RxNorm
            standard_code = self.kb.lookup(entity)
            normalized.append({
                "text": entity,
                "code": standard_code["code"],
                "ontology": standard_code["ontology"],
                "preferred_name": standard_code["preferred"]
            })
        return normalized

class DiagnosticAssistant:
    """Assist in clinical diagnosis using LLMs."""
    
    def __init__(self, llm, medical_db):
        self.llm = llm
        self.db = medical_db
    
    def generate_differential(self, patient_info):
        """Generate differential diagnosis."""
        # Retrieve relevant medical knowledge
        relevant_conditions = self.db.query_symptoms(
            patient_info["symptoms"]
        )
        
        prompt = f"""Generate a differential diagnosis for this patient:

Patient Information:
{patient_info}

Relevant conditions from medical literature:
{relevant_conditions}

Provide:
1. Top 5 most likely diagnoses (with probability estimates)
2. Key distinguishing features for each
3. Recommended diagnostic tests
4. Red flags requiring immediate attention
5. Treatment considerations

Differential Diagnosis:"""
        
        return self.llm.generate(prompt)
    
    def suggest_tests(self, differential, patient_info):
        """Suggest diagnostic tests."""
        prompt = f"""Suggest diagnostic tests for:

Differential Diagnosis: {differential}
Patient: {patient_info}

For each test:
1. Name and type
2. Expected findings for each diagnosis
3. Sensitivity and specificity
4. Cost and availability
5. Risk/benefit analysis

Test recommendations:"""
        
        return self.llm.generate(prompt)

class MedicalRAG:
    """RAG system for medical knowledge."""
    
    def __init__(self, llm, medical_index):
        self.llm = llm
        self.index = medical_index
    
    def answer_question(self, question, patient_context=None):
        """Answer medical question with evidence."""
        # Retrieve relevant medical literature
        retrieved = self.index.search(question, top_k=10)
        
        prompt = f"""Answer this medical question using the provided evidence:

Question: {question}
Patient Context: {patient_context or 'General medical question'}

Evidence from medical literature:
{self.format_evidence(retrieved)}

Provide:
1. Evidence-based answer
2. Level of evidence (I-V)
3. Confidence level
4. Caveats and limitations
5. References to retrieved sources

Answer:"""
        
        return self.llm.generate(prompt)

class RadiologyReportGenerator:
    """Generate radiology reports from images."""
    
    def __init__(self, vision_llm, radiology_kb):
        self.model = vision_llm
        self.kb = radiology_kb
    
    def generate_report(self, image, clinical_context):
        """Generate radiology report from image."""
        prompt = f"""Generate a radiology report for this image.

Clinical Context: {clinical_context}

Analyze:
1. Modality and technique
2. Findings (systematic approach)
3. Impression
4. Recommendations

Use standard radiology terminology and provide structured findings.

Report:"""
        
        return self.model.generate(image, prompt)
    
    def compare_studies(self, current_image, prior_image, prior_report):
        """Compare current and prior studies."""
        prompt = f"""Compare these radiology studies:

Current Image: [attached]
Prior Image: [attached]
Prior Report: {prior_report}

Identify:
1. New findings
2. Interval changes
3. Stability of known findings
4. Clinical significance

Comparison:"""
        
        return self.model.generate([current_image, prior_image], prompt)

class DrugDiscoveryLLM:
    """Assist in drug discovery using LLMs."""
    
    def __init__(self, llm, molecular_db):
        self.llm = llm
        self.molecules = molecular_db
    
    def identify_targets(self, disease_description):
        """Identify potential drug targets."""
        prompt = f"""Identify potential drug targets for:

Disease: {disease_description}

Provide:
1. Protein targets with evidence
2. Mechanism of action
3. Existing drugs targeting these proteins
4. Novel target opportunities
5. Validation status

Drug targets:"""
        
        return self.llm.generate(prompt)
    
    def predict_interactions(self, molecule, target):
        """Predict drug-target interactions."""
        prompt = f"""Predict interactions between:

Molecule: {molecule}
Target: {target}

Provide:
1. Binding affinity prediction
2. Mechanism of binding
3. ADMET properties
4. Similarity to known drugs
5. Potential side effects

Interaction prediction:"""
        
        return self.llm.generate(prompt)

safety_considerations = {
    "accuracy": "Must meet or exceed expert physician performance",
    "bias": "Test across diverse populations (age, sex, ethnicity)",
    "explainability": "Provide reasoning for clinical recommendations",
    "auditability": "Log all AI recommendations for review",
    "fallback": "Clear escalation path to human experts",
    "informed_consent": "Patients must be informed of AI involvement",
    "liability": "Clear responsibility chain for AI-assisted decisions"
}