Beck_Moulton

Posted on Feb 4

Building a Personal Health Agent with LangGraph: From Blood Tests to Pharmacy Checkouts

#ai #productivity #devops #python

Managing your health shouldn't feel like a part-time job. Between decoding lab results, finding an available doctor, and remembering to refill your Vitamin D supplements, the cognitive load is real. What if you could build a stateful AI agent that does the heavy lifting for you?

In this tutorial, we are diving deep into LangGraph automation, AI agents, and Python health assistants. We will build a system that analyzes health data, checks your schedule via the Google Calendar API, and even navigates pharmacy websites using Playwright. By the end of this post, you'll understand how to manage complex workflows with LangChain’s most powerful orchestration tool: LangGraph.

Why LangGraph?

Traditional LLM chains are linear. However, real-world health management is cyclical and requires decision-making loops. You might need to check a calendar, find it's full, propose a new time, and wait for confirmation. LangGraph allows us to create cyclic graphs, making it the perfect choice for building a personal health agent that maintains state across multiple interactions.

The System Architecture

Before we touch the code, let’s visualize how our health agent thinks. We use a StateGraph to manage the flow between analyzing data, searching for services, and executing actions.

graph TD
    Start((Lab Result Ingested)) --> AnalysisNode[LLM: Analyze Deficiency]
    AnalysisNode --> Decision{Action Needed?}

    Decision -->|Schedule Appointment| CalendarNode[Google Calendar: Find Slot]
    Decision -->|Low Supplies| PharmacyNode[Playwright: Search Pharmacy]

    CalendarNode --> ConfirmNode[LLM: Draft Confirmation Email]
    PharmacyNode --> CartNode[Playwright: Add to Cart]

    ConfirmNode --> End((Task Complete))
    CartNode --> End

Prerequisites

To follow along, you’ll need:

Python 3.10+
LangChain / LangGraph: For orchestration.
Playwright: For browser automation.
Google Calendar API: To manage appointments.

Step 1: Defining the Agent State

In LangGraph, the State is the source of truth. It tracks what the agent knows and what it has done.

from typing import TypedDict, List, Annotated
from langgraph.graph import StateGraph, END

class AgentState(TypedDict):
    lab_results: str
    deficiencies: List[str]
    appointment_scheduled: bool
    cart_updated: bool
    next_step: str

Step 2: Building the Tools

Our agent needs hands. We'll give it a Google Calendar tool and a Playwright tool.

Playwright Pharmacy Tool

This tool automates the process of finding a supplement (like Vitamin D) and adding it to a cart.

from playwright.sync_api import sync_playwright

def manage_pharmacy_cart(supplement_name: str):
    with sync_playwright() as p:
        browser = p.chromium.launch(headless=True)
        page = browser.new_page()
        # Mocking a pharmacy search
        page.goto(f"https://example-pharmacy.com/search?q={supplement_name}")
        page.click("text=Add to Cart")
        print(f"✅ Added {supplement_name} to your cart.")
        browser.close()
        return True

Step 3: Orchestrating the Graph

Now, we define the nodes. Each node is a function that takes the current State and returns an updated version.

from langchain_openai import ChatOpenAI

llm = ChatOpenAI(model="gpt-4o")

def analyze_health_data(state: AgentState):
    prompt = f"Analyze these results: {state['lab_results']}. List deficiencies."
    response = llm.invoke(prompt)
    # logic to parse response...
    return {"deficiencies": ["Vitamin D"], "next_step": "pharmacy"}

def handle_pharmacy(state: AgentState):
    for item in state['deficiencies']:
        manage_pharmacy_cart(item)
    return {"cart_updated": True}

# Initialize the Graph
workflow = StateGraph(AgentState)

# Add Nodes
workflow.add_node("analyzer", analyze_health_data)
workflow.add_node("pharmacy_bot", handle_pharmacy)

# Define Edges
workflow.set_entry_point("analyzer")
workflow.add_edge("analyzer", "pharmacy_bot")
workflow.add_edge("pharmacy_bot", END)

app = workflow.compile()

The "Official" Way: Level Up Your Agents

Building a local prototype is great, but moving agents into production requires handling edge cases like rate limiting, sensitive data masking (HIPAA compliance), and complex UI interactions.

For more production-ready patterns and advanced architectural insights on AI-driven automation, I highly recommend checking out the technical deep dives at WellAlly Blog. They cover how to scale these types of agents for enterprise-grade health-tech solutions.

Step 4: Execution

Let's run our agent with a sample blood report.

inputs = {
    "lab_results": "Patient shows Vitamin D levels at 12ng/mL (Deficient). All other markers normal.",
    "deficiencies": [],
    "appointment_scheduled": False,
    "cart_updated": False
}

for output in app.stream(inputs):
    for key, value in output.items():
        print(f"Node '{key}' completed.")

Conclusion

We’ve just built a stateful health agent that doesn't just "chat" but acts. By combining LangGraph for logic, Playwright for web interaction, and the Google Calendar API for scheduling, we’ve bridged the gap between raw data and real-world utility.

What's next?

Human-in-the-loop: Use LangGraph's interrupt feature to ask for permission before the agent spends money in the pharmacy.
Persistence: Use a Checkpointer to save the agent's state so it remembers your health history over months.

Are you building AI agents for personal productivity? Drop a comment below or share your thoughts!

Love this content? Follow for more tutorials on LangChain, Autogen, and the future of Agentic Workflows.

DEV Community