> For the complete documentation index, see [llms.txt](https://docs.graphlit.dev/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.graphlit.dev/api-guides/use-cases/knowledge-graph/knowledge-graph-medical-content.md).

# Extract Medical Entities from Clinical Content

## User Intent

"How do I extract medical entities (conditions, drugs, procedures, tests) from clinical documents and research papers? Show me how to build medical knowledge graphs for healthcare applications."

## Operation

**SDK Methods**: `createWorkflow()`, `ingestUri()`, `isContentDone()`, `getContent()`, `queryObservables()`\
**GraphQL**: Medical content ingestion + extraction of 12 medical entity types\
**Entity**: Medical Content → Observations → Medical Observables (Clinical Knowledge Graph)

## Prerequisites

* Graphlit project with API credentials
* Medical/clinical documents (PDFs, research papers, clinical notes)
* Understanding of medical entity types
* Appropriate data privacy/HIPAA compliance measures

***

## Complete Code Example (TypeScript)

```typescript
import { Graphlit } from 'graphlit-client';
import { ModelServiceTypes, ObservableTypes, SpecificationTypes } from 'graphlit-client/dist/generated/graphql-types';
import {
  FilePreparationServiceTypes,
  ExtractionServiceTypes,
  ObservableTypes,
  ModelServiceTypes,
  OpenAIModels
} from 'graphlit-client/dist/generated/graphql-types';

const graphlit = new Graphlit();

console.log('=== Building Medical Knowledge Graph ===\n');

// Step 1: Create high-quality medical extraction workflow
console.log('Step 1: Creating medical entity extraction workflow...');

// Use GPT-4 for medical accuracy
const spec = await graphlit.createSpecification({
  name: "GPT-4 Medical Extraction",
  type: SpecificationTypes.Completion,
  serviceType: ModelServiceTypes.OpenAi,
  openAI: {
    model: OpenAIModels.Gpt4,    // Best quality for medical
    temperature: 0.1              // Low temperature for consistency
  }
});

const workflow = await graphlit.createWorkflow({
  name: "Medical Entity Extraction",
  preparation: {
    jobs: [{
      connector: {
        type: FilePreparationServiceTypes.ModelDocument  // PDFs, Word, etc.
      }
    }]
  },
  extraction: {
    jobs: [{
      connector: {
        type: EntityExtractionServiceTypes.ModelText,
        extractedTypes: [
          // All 12 medical entity types
          ObservableTypes.MedicalCondition,         // Diseases, symptoms, diagnoses
          ObservableTypes.MedicalDrug,              // Medications, pharmaceuticals
          ObservableMedicalDrugClass,         // Drug categories (antibiotics, etc.)
          ObservableTypes.MedicalProcedure,         // Surgeries, treatments
          ObservableTypes.MedicalTest,              // Lab tests, diagnostics
          ObservableTypes.MedicalStudy,             // Clinical trials, research
          ObservableMedicalDevice,            // Medical equipment, implants
          ObservableMedicalTherapy,           // Therapies, treatments
          ObservableMedicalGuideline,         // Clinical guidelines, protocols
          ObservableMedicalIndication,        // Reasons for treatment
          ObservableMedicalContraindication,  // Reasons to avoid treatment
          
          // Also extract non-medical entities for context
          ObservableTypes.Person,                   // Patients, doctors, researchers
          ObservableTypes.Organization              // Hospitals, pharma companies
        ]
      }
    }]
  },
  specification: { id: spec.createSpecification.id }
});

console.log(`✓ Workflow: ${workflow.createWorkflow.id}\n`);

// Step 2: Ingest clinical research paper
console.log('Step 2: Ingesting clinical research paper...');
const paper = await graphlit.ingestUri('https://example.com/papers/clinical-trial.pdf', "Clinical Trial: Drug X for Condition Y", undefined, undefined, undefined, { id: workflow.createWorkflow.id  });

console.log(`✓ Ingested: ${paper.ingestUri.id}\n`);

// Step 3: Wait for extraction
console.log('Step 3: Extracting medical entities...');
let isDone = false;
while (!isDone) {
  const status = await graphlit.isContentDone(paper.ingestUri.id);
  isDone = status.isContentDone.result;
  
  if (!isDone) {
    console.log('  Processing...');
    await new Promise(resolve => setTimeout(resolve, 3000));
  }
}
console.log('✓ Extraction complete\n');

// Step 4: Retrieve extracted entities
console.log('Step 4: Retrieving medical entities...');
const paperDetails = await graphlit.getContent(paper.ingestUri.id);
const content = paperDetails.content;

console.log(`✓ Document: ${content.name}`);
console.log(`  Pages: ${content.document?.pageCount}`);
console.log(`  Total entities: ${content.observations?.length || 0}\n`);

// Step 5: Analyze by medical entity type
console.log('Step 5: Analyzing medical entities...\n');

const medicalTypes = [
  ObservableTypes.MedicalCondition,
  ObservableTypes.MedicalDrug,
  ObservableMedicalDrugClass,
  ObservableTypes.MedicalProcedure,
  ObservableTypes.MedicalTest,
  ObservableTypes.MedicalStudy,
  ObservableMedicalDevice,
  ObservableMedicalTherapy
];

medicalforEach(type => {
  const entities = content.observations?.filter(obs => obs.type === type) || [];
  const unique = new Set(entities.map(e => e.observable.name));
  
  if (unique.size > 0) {
    console.log(`${type} (${unique.size}):`);
    Array.from(unique).slice(0, 5).forEach(name => {
      console.log(`  - ${name}`);
    });
    if (unique.size > 5) {
      console.log(`  ... and ${unique.size - 5} more`);
    }
    console.log();
  }
});

// Step 6: Build drug-condition relationships
console.log('Step 6: Analyzing drug-condition relationships...\n');

const drugs = content.observations?.filter(obs => 
  obs.type === ObservableTypes.MedicalDrug
) || [];

const conditions = content.observations?.filter(obs =>
  obs.type === ObservableTypes.MedicalCondition
) || [];

// Co-occurrence analysis
const relationships: Array<{ drug: string; condition: string; confidence: number }> = [];

drugs.forEach(drug => {
  conditions.forEach(condition => {
    // Check if they appear on same pages
    const drugPages = new Set(drug.occurrences?.map(occ => occ.pageIndex));
    const condPages = new Set(condition.occurrences?.map(occ => occ.pageIndex));
    
    const sharedPages = Array.from(drugPages).filter(p => condPages.has(p));
    
    if (sharedPages.length > 0) {
      // Calculate average confidence
      const avgConf = (
        (drug.occurrences?.reduce((sum, occ) => sum + occ.confidence, 0) || 0) /
        (drug.occurrences?.length || 1) +
        (condition.occurrences?.reduce((sum, occ) => sum + occ.confidence, 0) || 0) /
        (condition.occurrences?.length || 1)
      ) / 2;
      
      relationships.push({
        drug: drug.observable.name,
        condition: condition.observable.name,
        confidence: avgConf
      });
    }
  });
});

console.log('Drug-Condition relationships:');
relationships
  .sort((a, b) => b.confidence - a.confidence)
  .slice(0, 5)
  .forEach(({ drug, condition, confidence }) => {
    console.log(`  ${drug} ↔ ${condition} (confidence: ${confidence.toFixed(2)})`);
  });

// Step 7: Query medical knowledge graph
console.log('\nStep 7: Querying medical knowledge graph...\n');

// Get all conditions across all documents
const allConditions = await graphlit.queryObservables({
  filter: { types: [ObservableTypes.MedicalCondition] }
});

console.log(`Total conditions in knowledge graph: ${allConditions.observables.results.length}`);

// Get all drugs
const allDrugs = await graphlit.queryObservables({
  filter: { types: [ObservableTypes.MedicalDrug] }
});

console.log(`Total drugs in knowledge graph: ${allDrugs.observables.results.length}`);

console.log('\n✓ Medical knowledge graph complete!');
```

***

## Step-by-Step Explanation

### Step 1: Understanding Medical Entity Types

Graphlit supports **12 medical entity types** (all fully supported, not beta):

**Core Clinical Entities**:

1. **MedicalCondition**:
   * Diseases, symptoms, diagnoses
   * Examples: "Type 2 diabetes", "hypertension", "chest pain", "COVID-19"
   * Schema.org: `@type: "MedicalCondition"`
2. **MedicalDrug**:
   * Specific medications, pharmaceuticals
   * Examples: "metformin", "lisinopril", "aspirin", "Pfizer-BioNTech vaccine"
   * Schema.org: `@type: "Drug"`
3. **MedicalDrugClass**:
   * Categories of drugs
   * Examples: "antibiotics", "beta-blockers", "statins", "ACE inhibitors"
   * Schema.org: `@type: "DrugClass"`
4. **MedicalProcedure**:
   * Surgeries, treatments, interventions
   * Examples: "coronary artery bypass", "hip replacement", "chemotherapy"
   * Schema.org: `@type: "MedicalProcedure"`
5. **MedicalTest**:
   * Diagnostic tests, lab tests
   * Examples: "HbA1c test", "MRI scan", "blood pressure measurement"
   * Schema.org: `@type: "MedicalTest"`

**Advanced Medical Entities**:

6. **MedicalStudy**:
   * Clinical trials, research studies
   * Examples: "Phase III trial", "randomized controlled trial", "cohort study"
   * Schema.org: `@type: "MedicalStudy"`
7. **MedicalDevice**:
   * Medical equipment, implants
   * Examples: "pacemaker", "insulin pump", "surgical robot", "stent"
   * Schema.org: `@type: "MedicalDevice"`
8. **MedicalTherapy**:
   * Therapies, treatment approaches
   * Examples: "physical therapy", "radiation therapy", "cognitive behavioral therapy"
   * Schema.org: `@type: "MedicalTherapy"`
9. **MedicalGuideline**:
   * Clinical guidelines, protocols
   * Examples: "WHO guidelines", "treatment protocol", "diagnostic criteria"
   * Schema.org: `@type: "MedicalGuideline"`
10. **MedicalIndication**:
    * Reasons for treatment
    * Examples: "indicated for hypertension", "approved for diabetes management"
    * Schema.org: `@type: "MedicalIndication"`
11. **MedicalContraindication**:
    * Reasons to avoid treatment
    * Examples: "contraindicated in pregnancy", "not for use with kidney disease"
    * Schema.org: `@type: "MedicalContraindication"`
12. **MedicalRiskFactor** (if supported):
    * Risk factors for conditions
    * Examples: "smoking", "obesity", "family history"

### Step 2: Model Selection for Medical Content

**GPT-4 (Recommended for Medical)**:

* Highest accuracy for medical terminology
* Best understanding of clinical context
* Lower false positive rate
* More expensive but worth it for healthcare

**GPT-4o**:

* Good balance for less critical medical content
* Faster processing
* Lower cost
* Acceptable for research papers, general medical content

**Claude 3.5 Sonnet**:

* Good alternative to GPT-4
* Strong medical knowledge
* Handles long clinical documents well

**NOT Recommended**:

* Gemini: Less accurate for medical terminology
* GPT-3.5: Too many medical errors

### Step 3: Clinical Document Types

**Research Papers**:

```typescript
// PubMed, ArXiv medical papers
extractedTypes: [
  ObservableTypes.MedicalCondition,
  ObservableTypes.MedicalDrug,
  ObservableTypes.MedicalStudy,
  ObservableTypes.MedicalProcedure,
  ObservableTypes.Person,  // Authors, researchers
  ObservableTypes.Organization  // Institutions
]
```

**Clinical Notes** (HIPAA considerations):

```typescript
// Patient records, clinical summaries
extractedTypes: [
  ObservableTypes.MedicalCondition,  // Diagnoses
  ObservableTypes.MedicalDrug,       // Medications
  ObservableTypes.MedicalProcedure,  // Treatments
  ObservableTypes.MedicalTest        // Lab results
  // NOTE: Do NOT extract Person for patient privacy
]
```

**Drug Information Sheets**:

```typescript
// Prescribing information, package inserts
extractedTypes: [
  ObservableTypes.MedicalDrug,
  ObservableMedicalDrugClass,
  ObservableMedicalIndication,
  ObservableMedicalContraindication,
  ObservableTypes.MedicalCondition  // What it treats
]
```

**Clinical Guidelines**:

```typescript
// Treatment protocols, best practices
extractedTypes: [
  ObservableMedicalGuideline,
  ObservableTypes.MedicalProcedure,
  ObservableTypes.MedicalTest,
  ObservableTypes.MedicalCondition
]
```

### Step 4: Medical Entity Relationships

**Drug-Condition Relationships**:

* Co-occurrence on same pages
* "Drug X is indicated for Condition Y"
* "Patients with Condition Y treated with Drug X"

**Procedure-Condition Relationships**:

* "Procedure X performed for Condition Y"
* Diagnostic procedures for conditions

**Drug-Drug Interactions**:

* Contraindications between drugs
* Combination therapies

**Test-Condition Relationships**:

* Diagnostic tests for conditions
* Monitoring tests for treated conditions

### Step 5: Confidence Scoring for Medical Entities

**High Confidence (>=0.9)**:

* Explicit medical terminology
* Standard nomenclature (ICD, SNOMED CT terms)
* Clear clinical context

**Medium Confidence (0.7-0.9)**:

* Common medical terms
* Some ambiguity in context
* Abbreviations with context

**Low Confidence (<0.7)**:

* Ambiguous terms
* Incomplete information
* Uncertain context

**Recommended Threshold**: **>=0.75 for medical applications** (higher than general content)

***

## Configuration Options

### Precision vs Recall Tradeoff

**High Precision** (fewer false positives):

```typescript
// Use GPT-4, high confidence threshold
specification: {
  model: OpenAIModels.Gpt4,
  temperature: 0.05  // Very low temperature
}

// Filter results
const highConfidence = observations.filter(obs =>
  obs.occurrences?.every(occ => occ.confidence >= 0.85)
);
```

**High Recall** (fewer false negatives):

```typescript
// Extract all possible entities, filter later
extractedTypes: [
  // All 12 medical types
  ...allMedicalTypes
]

// Lower confidence threshold
const allEntities = observations.filter(obs =>
  obs.occurrences?.some(occ => occ.confidence >= 0.6)
);
```

### Domain-Specific Extraction

**Cardiology**:

```typescript
extractedTypes: [
  ObservableTypes.MedicalCondition,  // Heart diseases
  ObservableTypes.MedicalProcedure,  // Cardiac procedures
  ObservableMedicalDevice,     // Pacemakers, stents
  ObservableTypes.MedicalDrug,       // Cardiac medications
  ObservableTypes.MedicalTest        // ECG, stress tests
]
```

**Oncology**:

```typescript
extractedTypes: [
  ObservableTypes.MedicalCondition,  // Cancer types
  ObservableMedicalTherapy,    // Chemotherapy, radiation
  ObservableTypes.MedicalDrug,       // Cancer drugs
  ObservableTypes.MedicalStudy,      // Clinical trials
  ObservableTypes.MedicalProcedure   // Surgeries, biopsies
]
```

**Pharmacology**:

```typescript
extractedTypes: [
  ObservableTypes.MedicalDrug,
  ObservableMedicalDrugClass,
  ObservableMedicalIndication,
  ObservableMedicalContraindication,
  ObservableTypes.MedicalCondition
]
```

***

## Variations

### Variation 1: Drug Information Database

Build comprehensive drug knowledge base:

```typescript
// Ingest drug information sheets
const drugDocs = [
  'https://example.com/drugs/metformin-info.pdf',
  'https://example.com/drugs/lisinopril-info.pdf',
  // ... more drugs
];

const drugWorkflow = await graphlit.createWorkflow({
  name: "Drug Information Extraction",
  extraction: {
    jobs: [{
      connector: {
        type: EntityExtractionServiceTypes.ModelText,
        extractedTypes: [
          ObservableTypes.MedicalDrug,
          ObservableMedicalDrugClass,
          ObservableMedicalIndication,
          ObservableMedicalContraindication,
          ObservableTypes.MedicalCondition
        ]
      }
    }]
  }
});

// Ingest all drug docs
await Promise.all(
  drugDocs.map(uri =>
    graphlit.ingestUri({ uri, workflow: { id: drugWorkflow.createWorkflow.id } })
  )
);

// Query drug database
const metformin = await graphlit.queryObservables({
  search: "metformin",
  filter: { types: [ObservableTypes.MedicalDrug] }
});

// Find what conditions it treats
const conditions = await graphlit.queryContents({
  
    observations: [
      { type: ObservableTypes.MedicalDrug, observable: { id: metformin.observables.results[0].observable.id } },
      { type: ObservableMedicalIndication, observable: { /* any indication */ } }
    ]
  });
```

### Variation 2: Clinical Trial Analysis

Analyze clinical trial results:

```typescript
const trialWorkflow = await graphlit.createWorkflow({
  name: "Clinical Trial Extraction",
  extraction: {
    jobs: [{
      connector: {
        type: EntityExtractionServiceTypes.ModelText,
        extractedTypes: [
          ObservableTypes.MedicalStudy,
          ObservableTypes.MedicalDrug,
          ObservableTypes.MedicalCondition,
          ObservableTypes.MedicalProcedure,
          ObservableTypes.Person,          // Principal investigators
          ObservableTypes.Organization     // Sponsors
        ]
      }
    }]
  }
});

// Ingest clinical trial paper
const trial = await graphlit.ingestUri('https://clinicaltrials.gov/study/NCT12345678/document.pdf', undefined, undefined, undefined, undefined, { id: trialWorkflow.createWorkflow.id  });

// Wait and analyze
const trialDetails = await graphlit.getContent(trial.ingestUri.id);

// Extract trial metadata
const studyType = trialDetails.content.observations
  ?.find(obs => obs.type === ObservableTypes.MedicalStudy);

const drugTested = trialDetails.content.observations
  ?.find(obs => obs.type === ObservableTypes.MedicalDrug);

const conditionTreated = trialDetails.content.observations
  ?.find(obs => obs.type === ObservableTypes.MedicalCondition);

console.log(`Study: ${studyType?.observable.name}`);
console.log(`Drug: ${drugTested?.observable.name}`);
console.log(`Condition: ${conditionTreated?.observable.name}`);
```

### Variation 3: Adverse Event Monitoring

Track drug side effects and adverse events:

```typescript
// Process adverse event reports
const adverseWorkflow = await graphlit.createWorkflow({
  name: "Adverse Event Extraction",
  extraction: {
    jobs: [{
      connector: {
        type: EntityExtractionServiceTypes.ModelText,
        extractedTypes: [
          ObservableTypes.MedicalDrug,
          ObservableTypes.MedicalCondition,  // Side effects
          ObservableMedicalContraindication
        ]
      }
    }]
  }
});

// Ingest multiple adverse event reports
// ... (similar to above)

// Query for drug-side effect relationships
const drugId = 'drug-observable-id';
const adverseEvents = await graphlit.queryContents({
  
    observations: [{
      type: ObservableTypes.MedicalDrug,
      observable: { id: drugId }
    }]
  });

// Extract side effects co-occurring with drug
const sideEffects = new Map<string, number>();
adverseEvents.contents.results.forEach(report => {
  report.observations
    ?.filter(obs => obs.type === ObservableTypes.MedicalCondition)
    .forEach(obs => {
      sideEffects.set(
        obs.observable.name,
        (sideEffects.get(obs.observable.name) || 0) + 1
      );
    });
});

console.log('Common side effects:');
Array.from(sideEffects.entries())
  .sort((a, b) => b[1] - a[1])
  .slice(0, 10)
  .forEach(([effect, count]) => {
    console.log(`  ${effect}: ${count} reports`);
  });
```

### Variation 4: Medical Literature Review

Build knowledge base from research papers:

```typescript
// Process PubMed papers on specific topic
const reviewWorkflow = await graphlit.createWorkflow({
  name: "Literature Review Extraction",
  extraction: {
    jobs: [{
      connector: {
        type: EntityExtractionServiceTypes.ModelText,
        extractedTypes: [
          ObservableTypes.MedicalCondition,
          ObservableTypes.MedicalDrug,
          ObservableTypes.MedicalProcedure,
          ObservableTypes.MedicalStudy,
          ObservableTypes.Person,          // Authors
          ObservableTypes.Organization     // Institutions
        ]
      }
    }]
  }
});

// Ingest collection of papers
const papers = [
  'https://pubmed.ncbi.nlm.nih.gov/paper1.pdf',
  'https://pubmed.ncbi.nlm.nih.gov/paper2.pdf',
  // ... more papers
];

await Promise.all(
  papers.map(uri =>
    graphlit.ingestUri({ uri, workflow: { id: reviewWorkflow.createWorkflow.id } })
  )
);

// Analyze trends
const allConditions = await graphlit.queryObservables({
  filter: { types: [ObservableTypes.MedicalCondition] }
});

// Find most researched conditions
const researchCounts = new Map<string, number>();

for (const condition of allConditions.observables.results) {
  const papers = await graphlit.queryContents({
    
      observations: [{
        type: ObservableTypes.MedicalCondition,
        observable: { id: condition.observable.id }
      }]
    });
  
  researchCounts.set(condition.observable.name, papers.contents.results.length);
}

console.log('Most researched conditions:');
Array.from(researchCounts.entries())
  .sort((a, b) => b[1] - a[1])
  .slice(0, 10)
  .forEach(([condition, count]) => {
    console.log(`  ${condition}: ${count} papers`);
  });
```

### Variation 5: Treatment Protocol Assistant

RAG-based clinical decision support:

```typescript
// After ingesting clinical guidelines and protocols
const conversation = await graphlit.createConversation({
  name: "Treatment Protocol Assistant"
});

// Query for treatment recommendations
const response = await graphlit.promptConversation({
  prompt: "What is the recommended treatment protocol for a patient with Type 2 diabetes and hypertension?",
  id: conversation.createConversation.id
  // RAG will search across all ingested guidelines
});

console.log('Treatment Recommendation:');
console.log(response.message.message);

// Extract structured treatment plan
const structured = await graphlit.promptConversation({
  prompt: "Based on the guidelines, provide a structured treatment plan with: 1) First-line medications, 2) Monitoring tests, 3) Lifestyle modifications, 4) Follow-up schedule. Format as JSON.",
  id: conversation.createConversation.id
});

console.log('\nStructured Plan:');
console.log(structured.message.message);
```

***

## Common Issues & Solutions

### Issue: Medical Abbreviations Not Recognized

**Problem**: "HTN", "DM", "CHF" not extracted as conditions.

**Solution**: Medical abbreviations may have low confidence. Either:

1. Use lower confidence threshold (>=0.6)
2. Expand abbreviations in preprocessing
3. Train on medical-specific model (future feature)

### Issue: False Positives on Common Terms

**Problem**: "Cold" extracted as MedicalCondition when discussing weather.

**Solution**: Context-aware filtering:

```typescript
// Check surrounding context or confidence
const validConditions = conditions.filter(cond =>
  cond.occurrences?.some(occ => occ.confidence >= 0.8)
);
```

### Issue: Missing Drug-Condition Relationships

**Problem**: Drug and condition mentioned but not linked.

**Solution**: Use co-occurrence analysis (same page) or RAG queries:

```typescript
// Find relationships via RAG
const relationship = await graphlit.promptConversation({
  prompt: "What conditions is Drug X used to treat according to this document?",
  filter: { contents: [{ id: documentId }] }
});
```

### Issue: HIPAA Compliance Concerns

**Problem**: Patient names being extracted from clinical notes.

**Solution**: Don't extract Person entities from patient records:

```typescript
extractedTypes: [
  ObservableTypes.MedicalCondition,
  ObservableTypes.MedicalDrug,
  ObservableTypes.MedicalProcedure
  // DO NOT include ObservableTypes.Person for patient records
]
```

Also implement proper data handling:

* Encrypt data at rest
* Access controls
* Audit logging
* BAA with Graphlit (if processing PHI)

***

## Developer Hints

### Medical Entity Quality by Source

* **High quality**: Published research papers, drug information sheets
* **Medium quality**: Clinical guidelines, review articles
* **Variable quality**: Clinical notes (abbreviations, typos)

### Model Recommendations by Use Case

* **Clinical decision support**: GPT-4 (highest accuracy required)
* **Research literature review**: GPT-4o (good balance)
* **General medical knowledge**: Claude 3.5 Sonnet

### Confidence Thresholds

* **Regulatory/clinical use**: >=0.85
* **Research/analysis**: >=0.75
* **Exploratory/discovery**: >=0.65

### HIPAA and Privacy

* Graphlit is HIPAA-compliant when properly configured
* Sign BAA (Business Associate Agreement)
* Use encryption, access controls
* Don't extract identifiable patient information
* Consider de-identification before ingestion

### Performance Optimization

* Medical extraction is slower (complex terminology)
* Expect 20-30% longer processing than general content
* Batch process overnight for large volumes
* Cache commonly queried entities

***

## Production Patterns

### Healthcare Use Cases

* **Clinical decision support**: Query guidelines by condition
* **Drug information lookup**: Interactive drug database
* **Adverse event monitoring**: Track side effects across reports
* **Literature review**: Automated systematic reviews
* **Treatment protocol matching**: Match patients to protocols
* **Medical education**: Interactive medical knowledge base

### Compliance Considerations

* PHI (Protected Health Information) requires HIPAA compliance
* De-identify data when possible
* Implement access controls
* Audit all queries
* Regular security assessments
* Data retention policies

***