Skip to main content
Multi-agent personalized medicine: genetic analysis → patient history → drug interactions → protocol generation. Includes SQLite patient records, structured output, and API deployment.

​
Setup

# Create environment
python3 -m venv venv && source venv/bin/activate

# Install packages
pip install praisonaiagents praisonai

# Set API key
export OPENAI_API_KEY="your-key"

​
Create Sample Data

# Create patient genetic data
cat > genetics.json << 'EOF'
{
  "PAT001": {"CYP2D6": "rapid_metabolizer", "CYP2C19": "normal", "DPYD": "poor_metabolizer", "HLA_B5701": false},
  "PAT002": {"CYP2D6": "normal", "CYP2C19": "poor_metabolizer", "DPYD": "normal", "HLA_B5701": true},
  "PAT003": {"CYP2D6": "ultra_rapid", "CYP2C19": "normal", "DPYD": "normal", "HLA_B5701": false}
}
EOF

# Create drug database
cat > drugs.json << 'EOF'
{
  "metformin": {"class": "biguanide", "cyp_metabolism": false, "contraindications": ["renal_failure"]},
  "codeine": {"class": "opioid", "cyp_metabolism": "CYP2D6", "contraindications": ["respiratory_depression"]},
  "clopidogrel": {"class": "antiplatelet", "cyp_metabolism": "CYP2C19", "contraindications": ["bleeding_disorder"]},
  "abacavir": {"class": "NRTI", "cyp_metabolism": false, "hla_b5701_required": true, "contraindications": []}
}
EOF

​
Run: Python Code

from praisonaiagents import Agent, AgentTeam, Task, tool
from pydantic import BaseModel
from typing import List
import json

# Structured output
class TreatmentProtocol(BaseModel):
    patient_id: str
    recommended_drugs: List[str]
    contraindicated_drugs: List[str]
    dosage_adjustments: List[str]
    monitoring_requirements: List[str]
    genetic_warnings: List[str]

# Database persistence is configured via memory={} parameter

# Tools
@tool
def get_genetic_profile(patient_id: str) -> str:
    """Get patient genetic profile."""
    with open("genetics.json") as f:
        genetics = json.load(f)
    return json.dumps(genetics.get(patient_id, {}))

@tool
def get_drug_info(drug_name: str) -> str:
    """Get drug information."""
    with open("drugs.json") as f:
        drugs = json.load(f)
    return json.dumps(drugs.get(drug_name, {}))

@tool
def check_drug_gene_interaction(drug_name: str, cyp2d6: str, cyp2c19: str, hla_b5701: bool) -> str:
    """Check drug-gene interactions."""
    with open("drugs.json") as f:
        drugs = json.load(f)
    
    drug = drugs.get(drug_name, {})
    warnings = []
    dosage_adj = "standard"
    
    # CYP2D6 interactions
    if drug.get("cyp_metabolism") == "CYP2D6":
        if cyp2d6 == "ultra_rapid":
            warnings.append(f"{drug_name}: ultra-rapid CYP2D6 - increased toxicity risk")
            dosage_adj = "reduce_50%"
        elif cyp2d6 == "poor_metabolizer":
            warnings.append(f"{drug_name}: poor CYP2D6 - reduced efficacy")
            dosage_adj = "increase_or_alternative"
    
    # CYP2C19 interactions
    if drug.get("cyp_metabolism") == "CYP2C19":
        if cyp2c19 == "poor_metabolizer":
            warnings.append(f"{drug_name}: poor CYP2C19 - reduced activation")
            dosage_adj = "alternative_required"
    
    # HLA-B*5701 check
    if drug.get("hla_b5701_required") and hla_b5701:
        warnings.append(f"{drug_name}: CONTRAINDICATED - HLA-B*5701 positive")
        dosage_adj = "contraindicated"
    
    return json.dumps({"drug": drug_name, "warnings": warnings, "dosage_adjustment": dosage_adj})

# Agents
geneticist = Agent(
    name="Pharmacogeneticist",
    instructions="Analyze patient genetics. Use get_genetic_profile tool.",
    tools=[get_genetic_profile],
    memory={
        "db": "sqlite:///medicine.db",
        "session_id": "medicine-protocol"
    }
)

pharmacist = Agent(
    name="ClinicalPharmacist",
    instructions="Check drug interactions. Use get_drug_info and check_drug_gene_interaction tools.",
    tools=[get_drug_info, check_drug_gene_interaction]
)

physician = Agent(
    name="Physician",
    instructions="Generate treatment protocol based on genetic and drug analysis."
)

# Tasks
genetic_task = Task(
    description="Analyze genetics for patient: {patient_id}",
    agent=geneticist,
    expected_output="Genetic profile with metabolizer status"
)

interaction_task = Task(
    description="Check drug-gene interactions for proposed medications",
    agent=pharmacist,
    expected_output="Drug interaction analysis"
)

protocol_task = Task(
    description="Generate personalized treatment protocol",
    agent=physician,
    expected_output="Treatment protocol",
    output_pydantic=TreatmentProtocol
)

# Run
agents = AgentTeam(agents=[geneticist, pharmacist, physician], tasks=[genetic_task, interaction_task, protocol_task])
result = agents.start(patient_id="PAT002")
print(result)

​
Run: CLI

# Analyze single patient
praisonai "Generate treatment protocol for patient with CYP2D6 rapid metabolizer" --verbose

# With persistence
praisonai "Check drug interactions for codeine prescription" --memory --user-id pharmacist1

# Interactive consultation
praisonai chat --memory --user-id clinical_team

​
Run: agents.yaml

Create agents.yaml: 
framework: praisonai
topic: "personalized medicine protocol"
roles:
  geneticist:
    role: Pharmacogeneticist
    goal: Analyze genetic markers
    backstory: Expert in pharmacogenomics
    tasks:
      analyze:
        description: |
          Analyze genetics:
          - CYP450 enzyme status
          - HLA markers
          - Drug metabolism genes
        expected_output: Genetic profile
        
  pharmacist:
    role: Clinical Pharmacist
    goal: Check drug interactions
    backstory: Expert in drug-gene interactions
    tasks:
      check:
        description: |
          Check interactions:
          - Drug-gene interactions
          - Dosage adjustments
          - Contraindications
        expected_output: Interaction report
        
  physician:
    role: Prescribing Physician
    goal: Generate treatment protocol
    backstory: Expert in personalized medicine
    tasks:
      prescribe:
        description: |
          Generate protocol:
          - Recommended drugs
          - Dosage adjustments
          - Monitoring plan
          - Genetic warnings
        expected_output: Treatment protocol
Run: 
praisonai agents.yaml --verbose

​
Monitor & Verify

# View patient history
praisonai --history 10 --user-id pharmacist1

# Check metrics
praisonai --metrics

# Export protocols
praisonai --save treatment_protocols

​
Serve API

from praisonaiagents import Agent, tool
import json

@tool
def quick_gene_check(drug: str, cyp2d6: str, cyp2c19: str) -> str:
    """Quick drug-gene compatibility check."""
    cyp2d6_drugs = ["codeine", "tramadol", "tamoxifen"]
    cyp2c19_drugs = ["clopidogrel", "omeprazole"]
    
    safe = True
    warnings = []
    
    if drug in cyp2d6_drugs:
        if cyp2d6 in ["ultra_rapid", "poor_metabolizer"]:
            safe = False
            warnings.append(f"CYP2D6 {cyp2d6}: dosage adjustment needed")
    
    if drug in cyp2c19_drugs:
        if cyp2c19 == "poor_metabolizer":
            safe = False
            warnings.append(f"CYP2C19 poor metabolizer: consider alternative")
    
    return json.dumps({"drug": drug, "safe": safe, "warnings": warnings})

agent = Agent(
    name="PharmacogenomicsAPI",
    instructions="Check drug-gene compatibility.",
    tools=[quick_gene_check]
)

agent.launch(path="/gene-check", port=8000)
Test: 
curl -X POST http://localhost:8000/gene-check \
  -H "Content-Type: application/json" \
  -d '{"message": "Check codeine for CYP2D6 ultra_rapid metabolizer"}'

​
Cleanup

rm -f medicine.db genetics.json drugs.json
deactivate

​
Features Demonstrated

FeatureImplementation
Multi-agentGeneticist → Pharmacist → Physician
Structured OutputPydantic TreatmentProtocol
PharmacogenomicsCYP450, HLA-B*5701 checks
Drug InteractionsGene-based contraindications
DB PersistenceSQLite via db()
CLIpraisonai chat for consult
YAML Config3-agent medical pipeline
API Endpointagent.launch()