Building a 'Chief Health Officer' with LangGraph: Automatically Filter Your Food Delivery Based on Real-Time Blood Sugar

We’ve all been there: it’s 7:00 PM, you’re exhausted after a long sprint, and you open a food delivery app. Your brain screams "Double Cheeseburger," but your body is still recovering from that mid-afternoon sugar spike. What if your phone was smart enough to say, "Hey, your blood sugar is currently 160 mg/dL and rising—maybe skip the extra fries?"

In this tutorial, we are building a Chief Health Officer (CHO) Agent. This isn't just a simple chatbot; it’s a sophisticated AI Agent using LangGraph to bridge the gap between real-time medical data (CGM) and real-world actions (Food Delivery APIs). By leveraging automation, function calling, and state machines, we’ll create a system that actively protects your metabolic health.

---

The Architecture: How the CHO Agent Thinks

To build a reliable agent, we need a "stateful" workflow. We aren't just sending a prompt to an LLM; we are creating a loop that monitors glucose levels, analyzes food options, and interacts with the browser.

graph TD
    A[Start: Hunger Trigger] --> B{Fetch CGM Data}
    B -->|Sugar High/Unstable| C[Constraint: Low GI Only]
    B -->|Sugar Stable| D[Constraint: Balanced Meal]
    C --> E[Scrape Delivery App Menu]
    D --> E
    E --> F[Agent: Analyze Ingredients & GI Index]
    F --> G[Selenium: Mark/Filter Non-Compliant Items]
    G --> H[End: Safe Ordering]

    subgraph "The LangGraph Loop"
    C
    D
    E
    F
    end

---

Prerequisites

Before we dive into the code, ensure you have the following:

• LangGraph & LangChain: For the agent's cognitive architecture.
• Dexcom API Credentials: To fetch real-time Continuous Glucose Monitor (CGM) data.
• Selenium: For interacting with food delivery web interfaces (Meituan/Ele.me).
• OpenAI API Key: Specifically for GPT-4o’s reasoning and function-calling capabilities.

---

Step 1: Defining the Agent State

In LangGraph, everything revolves around the State. Our CHO agent needs to track the current glucose level, the user's health constraints, and the list of available food items.

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

class AgentState(TypedDict):
    glucose_level: float
    trend: str  # Rising, Falling, Stable
    constraints: List[str]
    menu_items: List[dict]
    filtered_items: List[dict]
    action_log: List[str]

---

Step 2: Fetching Real-time CGM Data (Dexcom API)

We need to know the metabolic state before making decisions. If you're building a production version, you'd use the official Dexcom Share API. For this tutorial, we’ll implement a robust fetcher.

import requests

def fetch_glucose_data(state: AgentState):
    # In a real scenario, use Dexcom's OAuth2 flow
    # This node updates the state with the latest 'bio-context'
    latest_reading = 145.5  # mg/dL
    trend = "Rising" 

    constraints = []
    if latest_reading > 140:
        constraints.append("Strict Low-Glycemic Index (GI)")
        constraints.append("No added sugars")

    return {
        "glucose_level": latest_reading,
        "trend": trend,
        "constraints": constraints
    }

---

Step 3: The Brain — Analyzing the Menu

Now, we use Function Calling to allow the LLM to categorize food items based on their estimated Glycemic Index. This is the "Chief Health Officer" in action.

from langchain_openai import ChatOpenAI

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

def filter_menu_logic(state: AgentState):
    menu = state['menu_items']
    constraints = state['constraints']

    prompt = f"""
    Current Glucose: {state['glucose_level']} mg/dL ({state['trend']}).
    Constraints: {constraints}.
    Menu: {menu}

    Task: Identify items that violate constraints. Return a list of 'unsafe' item IDs.
    """

    # We use LLM to reason about the nutritional content
    response = llm.invoke(prompt)
    # logic to parse response...
    return {"filtered_items": response_parsed_list}

---

Step 4: Automating the UI with Selenium

Since most food delivery platforms don't have open "Order APIs" for individuals, we use Selenium to "gray out" or hide unhealthy options directly on the web interface. This creates a "Health Firewall" on your screen. 🛡️

from selenium import webdriver
from selenium.webdriver.common.by import By

def apply_ui_filter(state: AgentState):
    driver = webdriver.Chrome()
    driver.get("https://h5.ele.me/msite/") # Simplified example

    for item_id in state['filtered_items']:
        # We execute JavaScript to visually mark unhealthy items
        script = f"document.getElementById('{item_id}').style.opacity = '0.2';"
        script += f"document.getElementById('{item_id}').append(' [⚠️ HIGH SUGAR ALERT]');"
        driver.execute_script(script)

    return {"action_log": ["UI updated to hide high-GI items"]}

---

The "Official" Way to Scale Agents

While this tutorial covers the basics of connecting biological data to automation, building production-ready AI Agents requires handling edge cases like API rate limits, token costs, and multi-modal menu parsing (e.g., reading images of menus).

For more advanced patterns on building healthcare-compliant agents and production-ready LangGraph architectures, I highly recommend checking out the technical deep-dives at WellAlly Tech Blog. They have incredible resources on how to bridge the gap between LLMs and real-world health data.

---

Step 5: Compiling the Graph

Finally, we link our nodes together into a cohesive workflow.

workflow = StateGraph(AgentState)

workflow.add_node("fetch_health_data", fetch_glucose_data)
workflow.add_node("analyze_menu", filter_menu_logic)
workflow.add_node("apply_filters", apply_ui_filter)

workflow.set_entry_point("fetch_health_data")
workflow.add_edge("fetch_health_data", "analyze_menu")
workflow.add_edge("analyze_menu", "apply_filters")
workflow.add_edge("apply_filters", END)

app = workflow.compile()

Conclusion: Take Back Your Health 🥑

By building a Chief Health Officer Agent, we’ve moved beyond "AI as a toy" to "AI as a guardian." This system uses your own biological data to influence your digital environment, making it easier to make the right choices when your willpower is low.

What's next?

1. Multi-modal support: Use GPT-4o to look at photos of food and estimate calories.
2. Long-term memory: Teach the agent to learn which foods cause your specific glucose to spike.

Are you ready to stop fighting the delivery apps and start automating your health? Drop a comment below or check out more "Health-First" AI tutorials over at the WellAlly Blog! 🚀