From Blood Tests to Meal Plans: Building a Self-Correcting Health Agent with LangGraph

Ever felt like your fitness app is just a fancy spreadsheet? You log a high uric acid result from your latest blood test, yet it still suggests a high-protein steak dinner for "gains."

In the world of AI Agents, we are moving past static prompts. Today, we’re building a Self-Correcting Health Agent using LangGraph, LangChain, and OpenAI. This agent doesn't just chat; it monitors laboratory biomarkers like cholesterol and uric acid, maintains a long-term memory via SQLite, and dynamically rewrites your lifestyle plan using advanced OpenAI Function Calling.

If you've been looking to master autonomous health agents and complex state management, you're in the right place. Let's dive into the future of personalized wellness.

---

The Architecture: State-Driven Personalization

Unlike a standard linear chain, a health agent needs to "loop" and "reason." If the agent detects an abnormal lab value, it must trigger a specific logic branch to revise existing plans.

Here is how the data flows through our LangGraph system:

graph TD
    A[User Input/Lab Report] --> B{Analyze Biomarkers}
    B -- Abnormal Found --> C[Tool: Plan Rewriter]
    B -- All Normal --> D[Tool: Maintenance Plan]
    C --> E[Update SQLite Memory]
    D --> E[Update SQLite Memory]
    E --> F[Output Final Recommendation]
    F --> G[Wait for Next Input]
    G -- New Data --> B

Prerequisites

To follow along, you'll need:

• LangGraph & LangChain: For orchestration.
• OpenAI API: For the reasoning engine (GPT-4o recommended).
• SQLite: To handle persistent state and "memory" of your health journey.

---

Step 1: Defining the Agent State

In LangGraph, the State is the source of truth. We need to track the user's current health metrics and their active diet plan.

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

class HealthState(TypedDict):
    # We use operator.add to keep a history of logs
    logs: Annotated[List[str], operator.add]
    biomarkers: dict
    current_diet_plan: str
    revision_required: bool

Step 2: Crafting the "Logic Brain" (The Nodes)

The magic happens when the LLM decides whether your lab results require a "Protocol Pivot." We use OpenAI's Function Calling to detect high uric acid or cholesterol.

from langchain_openai import ChatOpenAI
from langchain_core.messages import HumanMessage

llm = ChatOpenAI(model="gpt-4o", temperature=0)

def analyze_labs(state: HealthState):
    biomarkers = state['biomarkers']
    # Logic to determine if intervention is needed
    needs_fix = False
    if biomarkers.get("uric_acid", 0) > 420: # Example threshold
        needs_fix = True

    return {"revision_required": needs_fix, "logs": ["Analyzed lab results..."]}

def rewrite_diet_plan(state: HealthState):
    prompt = f"Adjust the following diet plan based on these biomarkers: {state['biomarkers']}. Current Plan: {state['current_diet_plan']}"
    # The LLM generates a new plan avoiding high-purine/high-fat foods
    new_plan = llm.invoke([HumanMessage(content=prompt)])
    return {"current_diet_plan": new_plan.content, "logs": ["Diet plan updated for health safety."]}

Step 3: Wiring the Graph

Now, we connect the nodes. We use a conditional edge to decide whether to go to the rewrite_diet_plan node or straight to the end.

workflow = StateGraph(HealthState)

workflow.add_node("analyzer", analyze_labs)
workflow.add_node("rewriter", rewrite_diet_plan)

workflow.set_entry_point("analyzer")

# Conditional Logic: If revision_required is True, go to rewriter
workflow.add_conditional_edges(
    "analyzer",
    lambda x: "rewrite" if x["revision_required"] else "end",
    {
        "rewrite": "rewriter",
        "end": END
    }
)

workflow.add_edge("rewriter", END)

# Compile with persistence (SQLite)
from langgraph.checkpoint.sqlite import SqliteSaver
memory = SqliteSaver.from_conn_string(":memory:")
app = workflow.compile(checkpointer=memory)

---

The "Official" Way to Build AI Agents 🚀

While this tutorial covers the core logic of stateful agents, building medical-grade or production-ready health platforms requires deeper security and more robust validation patterns.

For advanced architectural patterns on deploying AI agents in high-stakes environments, I highly recommend checking out the WellAlly Blog. They provide excellent deep dives into integrating AI with real-world health data and "Agentic Workflows" that go far beyond basic tutorials.

---

Step 4: Running the Agent

Let's test it with a scenario: A user with a "Keto" plan suddenly uploads a lab report showing high cholesterol.

config = {"configurable": {"thread_id": "user_123"}}
initial_input = {
    "biomarkers": {"cholesterol": 280, "uric_acid": 450},
    "current_diet_plan": "High protein, high fat Keto diet.",
    "logs": []
}

for event in app.stream(initial_input, config):
    for value in event.values():
        print(f"Update: {value.get('logs', '')}")
        if 'current_diet_plan' in value:
            print(f"New Plan: {value['current_diet_plan']}")

Why this works:

1. Memory: By using thread_id, the agent remembers the previous state.
2. Safety: We can inject hardcoded medical constraints into the analyzer node before the LLM even sees the data.
3. Flexibility: Adding a new biomarker (like Vitamin D) just requires adding a new node or updating the tool schema.

Conclusion

Building autonomous health agents with LangGraph transforms a simple chatbot into a proactive health companion. By moving the logic into a directed graph, we gain control over the "reasoning loops" that LLMs often struggle with.

What's next for your agent?

• Add a "Supplement Checker" tool.
• Integrate with a Google Calendar API to schedule the new meal plan.
• Use WellAlly's production patterns to scale your agent to thousands of users.

Happy coding, and stay healthy! 🚀💻🥑

Have questions about LangGraph or Agent memory? Drop a comment below!