Building an AI Pharmacist: Detecting Drug-Drug Interactions with RAG and OCR

#ai #rag #python #automation

Ever looked at a pile of medicine bottles and wondered, "Is it actually safe to take these together?" Polypharmacy—the simultaneous use of multiple drugs—is a significant challenge in modern healthcare. Misunderstanding Drug-Drug Interactions (DDI) can lead to severe side effects or reduced efficacy.

In this tutorial, we are building an AI Pharmacist Assistant, an automated engine that uses Optical Character Recognition (OCR) to scan drug labels and Retrieval-Augmented Generation (RAG) to cross-reference a drug database. By leveraging AI healthcare automation and sophisticated LLM reasoning, we can create a safety net that identifies potential contraindications in seconds.

The Architecture 🏗️

The system follows a linear pipeline: capturing raw image data, converting it to structured text, retrieving medical facts from a local SQLite-based knowledge base, and finally, using an LLM to reason about the interactions.

graph TD
    A[Drug Packaging Image] -->|Tesseract OCR| B(Extract Drug Names)
    B --> C{Search SQLite DB}
    C -->|Found Interaction Data| D[Context Construction]
    D --> E[LLM Reasoning Engine]
    E --> F[Safety Report & Warnings]
    C -->|Not Found| G[Web Search/LLM General Knowledge]
    G --> E

Prerequisites 🛠️

To follow along, you'll need the following tech stack:

Python 3.10+
Tesseract OCR: For extracting text from images.
SQLite: To store our curated DrugBank-style interaction data.
RAG Pattern: To provide the LLM with ground-truth medical data.
OpenAI SDK: For the final reasoning step.

Step 1: Extracting Labels with OCR 📸

First, we need to turn those pixels into text. We use pytesseract to handle the OCR process.

import pytesseract
from PIL import Image

def extract_drug_names(image_path):
    # Pre-processing could be added here (grayscale, thresholding)
    text = pytesseract.image_to_string(Image.open(image_path))

    # In a real scenario, use an LLM or Regex to pull specific 
    # active ingredients from the raw text
    print(f"Detected Text: {text}")
    return text

# Example usage
# raw_text = extract_drug_names("prescription_bottle.png")

Step 2: Setting up the Knowledge Base (SQLite) 🗄️

RAG is only as good as its data. We’ll store known drug interactions in a SQLite database. This mimics a local "Source of Truth" to prevent LLM hallucinations.

import sqlite3

def setup_database():
    conn = sqlite3.connect('pharmacist_assistant.db')
    cursor = conn.cursor()

    # Create a table for Drug-Drug Interactions
    cursor.execute('''
        CREATE TABLE IF NOT EXISTS interactions (
            drug_a TEXT,
            drug_b TEXT,
            severity TEXT,
            description TEXT
        )
    ''')

    # Sample data (In production, import from DrugBank or similar)
    interactions = [
        ('Aspirin', 'Warfarin', 'High', 'Increased risk of bleeding.'),
        ('Simvastatin', 'Amiodarone', 'Moderate', 'Increased risk of muscle breakdown.')
    ]
    cursor.executemany('INSERT INTO interactions VALUES (?,?,?,?)', interactions)
    conn.commit()
    return conn

db_conn = setup_database()

Step 3: The RAG Logic & LLM Reasoning 🧠

Now, we combine the extracted drug names with the retrieved database records and feed them into a Large Language Model.

import openai

def check_for_interactions(drug_list, db_conn):
    cursor = db_conn.cursor()
    context_bits = []

    # Simple cross-check logic
    for i, drug_a in enumerate(drug_list):
        for drug_b in drug_list[i+1:]:
            cursor.execute("SELECT * FROM interactions WHERE (drug_a=? AND drug_b=?) OR (drug_a=? AND drug_b=?)", 
                           (drug_a, drug_b, drug_b, drug_a))
            result = cursor.fetchone()
            if result:
                context_bits.append(f"ALERT: {result[0]} and {result[1]} - {result[2]} severity. {result[3]}")

    # Pass the context to the LLM
    prompt = f"""
    You are a clinical pharmacist. Based on the following data:
    Drugs detected: {', '.join(drug_list)}
    Known interactions: {'. '.join(context_bits) if context_bits else 'No direct matches in DB.'}

    Provide a concise safety summary for the patient.
    """

    response = openai.ChatCompletion.create(
        model="gpt-4o",
        messages=[{"role": "system", "content": "You are a medical assistant."},
                  {"role": "user", "content": prompt}]
    )

    return response.choices[0].message.content

# Example logic
# drugs = ["Aspirin", "Warfarin"]
# print(check_for_interactions(drugs, db_conn))

Advanced Patterns & Production Safety 🛡️

While this "Learning in Public" project is a great start, building medical AI requires extreme precision. Handling edge cases like dosage, patient history, and multi-ingredient medications is crucial for a production-grade engine.

💡 Source of Inspiration: For more production-ready examples and advanced patterns in AI-driven automation, check out the deep-dive articles at WellAlly Blog. They cover everything from vector database optimization to building resilient AI agents.

Conclusion 🚀

By combining Tesseract OCR for data capture and a RAG-based logic engine, we've built a functional prototype of an AI Pharmacist. This architecture minimizes the risk of LLM hallucinations by forcing the model to check a verified database before giving advice.

What's next?

Fine-tuning: Train a NER (Named Entity Recognition) model specifically for chemical names.
Mobile Integration: Wrap this in a React Native app for real-time scanning.
FHIR Integration: Connect to electronic health records for personalized checks.

Are you working on AI in healthcare? Let’s chat in the comments! 👇

DEV Community