Have you ever found yourself staring at an online pharmacy checkout page, wondering if that new allergy medication plays nice with your daily vitamins? Polypharmacy is a silent risk, and while doctors are the experts, having a real-time browser-based agent as a second pair of eyes can be a lifesaver.

In this tutorial, we’re building a Drug-Interaction Guard. This is a sophisticated LLM Agent that lives in your browser, scrapes medication names from your active tab, and cross-references them against your personal "current meds" list using the PubMed API and Tavily Search. We will leverage LangGraph to handle the complex reasoning loops required for medical safety checks.

Whether you're interested in LangGraph agentic workflows, Chrome Extension automation, or AI-driven healthcare safety, this guide has you covered.

The Architecture

A simple chatbot isn't enough for this task. We need an agent that can reason: "I see Drug A on the page. User takes Drug B. Let me search PubMed for interactions. If I find a conflict, I need to check if there's a specific dosage warning via Tavily."

Here is how the data flows:

graph TD
    A[Browser Tab: Pharmacy/Prescription] -->|Content Script| B(Extract Drug Names)
    B --> C{Agent Brain: LangGraph}
    C -->|Tool Call| D[PubMed API: Find Clinical Papers]
    C -->|Tool Call| E[Tavily Search: Latest Medical News]
    D --> F[State Manager]
    E --> F
    F -->|Reasoning| C
    C -->|Final Analysis| G[UI Overlay: Safety Alert]
    G -->|Click for Details| H[Detailed Report]

Prerequisites

To follow along, you’ll need:

• Node.js & Python (for the backend agent).
• Chrome Extension Manifest V3 knowledge.
• LangGraph (the secret sauce for cyclic agentic flows).
• API Keys: OpenAI (or Anthropic), Tavily, and NCBI (PubMed).

Step 1: The Browser "Eyes" (Content Script)

First, we need to extract drug names from the DOM. We use a simple regex-based scraper or a small LLM call to identify entities.

// content_script.js
const extractMedications = () => {
  // A simplified example: looking for common medication patterns
  const bodyText = document.body.innerText;
  const potentialMeds = bodyText.match(/[A-Z][a-z]{3,15} (mg|mcg|ml)/g) || [];

  if (potentialMeds.length > 0) {
    chrome.runtime.sendMessage({
      type: "CHECK_INTERACTIONS",
      payload: { foundMeds: [...new Set(potentialMeds)] }
    });
  }
};

window.addEventListener('load', extractMedications);

Step 2: The Agentic Brain (LangGraph)

We use LangGraph because checking medical interactions isn't linear. The agent might need to search PubMed, realize the results are ambiguous, and then pivot to a broader web search.

from typing import TypedDict, List
from langgraph.graph import StateGraph, END
from langchain_openai import ChatOpenAI

class AgentState(TypedDict):
    found_meds: List[str]
    user_meds: List[str]
    pubmed_results: str
    tavily_results: str
    risk_score: int
    final_report: str

def call_pubmed(state: AgentState):
    # Logic to query PubMed API
    query = f"interaction between {state['found_meds']} and {state['user_meds']}"
    # Mocking result
    return {"pubmed_results": "Found clinical trial data regarding contraindications..."}

def analyze_risk(state: AgentState):
    llm = ChatOpenAI(model="gpt-4o")
    prompt = f"Analyze these results: {state['pubmed_results']} and {state['tavily_results']}"
    response = llm.invoke(prompt)
    return {"final_report": response.content, "risk_score": 8} # Scale 1-10

# Define the Graph
workflow = StateGraph(AgentState)
workflow.add_node("pubmed_search", call_pubmed)
workflow.add_node("risk_analyzer", analyze_risk)

workflow.set_entry_point("pubmed_search")
workflow.add_edge("pubmed_search", "risk_analyzer")
workflow.add_edge("risk_analyzer", END)

app = workflow.compile()

Step 3: Integrating PubMed & Tavily

While PubMed gives us the peer-reviewed clinical data, Tavily Search is essential for "General Availability" warnings or recent FDA recalls that haven't hit the massive PubMed database yet.

from langchain_community.tools.tavily_search import TavilySearchResults

def call_tavily(state: AgentState):
    search = TavilySearchResults(k=3)
    query = f"Current warnings for {state['found_meds']}"
    results = search.run(query)
    return {"tavily_results": str(results)}

The "Official" Way to Build Agentic Systems

Building a prototype is easy, but making it production-ready (handling HIPAA compliance, latency, and hallucination checks) is where the real challenge lies. For those looking to scale their AI agents or implement more robust security patterns, I highly recommend checking out the advanced architecture guides on the WellAlly Blog.

Their recent deep-dives on LLM Guardrails and Agentic Error Handling were the primary inspiration for the safety logic used in this Drug-Interaction Guard.

Step 4: Visualizing the Alert

Once the agent completes its cycle, the Chrome Extension needs to inject a UI element to warn the user.

// background.js
chrome.runtime.onMessage.addListener(async (request, sender) => {
  if (request.type === "CHECK_INTERACTIONS") {
    const report = await fetchAgentAnalysis(request.payload);

    chrome.scripting.executeScript({
      target: { tabId: sender.tab.id },
      func: (data) => {
        const div = document.createElement('div');
        div.style = "position:fixed; top:20px; right:20px; background:red; color:white; padding:20px; z-index:9999; border-radius:8px; box-shadow: 0 4px 12px rgba(0,0,0,0.5);";
        div.innerHTML = `<h3>⚠️ Potential Interaction Found!</h3><p>${data.final_report}</p>`;
        document.body.appendChild(div);
      },
      args: [report]
    });
  }
});

Conclusion & Ethics

Building a browser-based agent with LangGraph and PubMed demonstrates how AI can move from a simple "chat box" to an active participant in our safety. However, a crucial disclaimer: This tool is an assistant, not a doctor. Always consult with a medical professional.

In this project, we've:

1. Scraped medication data using Chrome Extension APIs.
2. Built a reasoning loop with LangGraph.
3. Combined deep scientific data (PubMed) with real-time web data (Tavily).

What’s next? You could extend this agent to automatically check if a medication is covered by your specific insurance plan!

Have you built a browser agent yet? Let me know in the comments below! 👇

For more high-level AI tutorials and production-ready agent patterns, visit wellally.tech/blog.