# 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

***


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://docs.graphlit.dev/api-guides/use-cases/knowledge-graph/knowledge-graph-medical-content.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.