Stop Guessing Your Macros: Building an Autonomous Diet Agent with LangGraph and Oura Ring

#openai #python #learninginpublic #langgraph

We’ve all been there: you wake up feeling like a zombie 🧟‍♂️, but your fitness app tells you to eat a "high-carb, high-energy" breakfast. Or worse, you’re well-rested but stuck in a loop of generic diet advice that doesn't account for your actual physiological state. In the world of Autonomous Agents and Personalized Nutrition, generic is the enemy.

Today, we are moving beyond simple chatbots. We are building a "closed-loop" Autonomous Diet Agent using LangGraph, OpenAI Function Calling, and the Oura Cloud API. This agent doesn't just talk; it thinks, fetches your real-time recovery data, and automatically updates your food logs based on your body's needs. By leveraging LLM Function Calling and stateful graphs, we can create a truly proactive health companion.

The Architecture: A Closed-Loop System 🔄

Unlike a linear chain, a diet agent needs to handle cycles—fetching data, deciding on a plan, and confirming the action. Here is how our agent logic flows using Mermaid.js:

graph TD
    A[Start: User Inquiry/Scheduled Trigger] --> B{Check Oura Recovery Score}
    B --> C[Oura API: Fetch Sleep & Readiness]
    C --> D[State Update: recovery_score]
    D --> E[LLM: Analyze Context & Suggest Meal]
    E --> F{Tool Choice?}
    F -- Suggestion Only --> G[Output to User]
    F -- Update Log --> H[Tool: Update Nutrition App]
    H --> I[State Update: log_status]
    I --> G
    G --> J[End]

Prerequisites 🛠️

To follow along with this intermediate tutorial, you’ll need:

LangGraph: For managing the agent's state machine.
OpenAI GPT-4o: For intelligent function calling.
Pydantic: For strict data validation.
Oura Cloud API Access: To get that sweet, sweet biometric data.

Step 1: Defining the State and Schema

In LangGraph, the "State" is our source of truth. We’ll use Pydantic to ensure our agent knows exactly what a "Meal Plan" looks like.

from typing import TypedDict, Annotated, List
from pydantic import BaseModel, Field

# Define the shape of our nutrition data
class Meal(BaseModel):
    name: str = Field(description="Name of the meal")
    calories: int = Field(description="Total calories")
    protein: int = Annotated[int, "Grams of protein"]
    reasoning: str = Field(description="Why this meal fits the recovery score")

class AgentState(TypedDict):
    recovery_score: int
    current_plan: List[Meal]
    log_confirmed: bool
    user_input: str

Step 2: Empowering the Agent with Tools 🔧

An agent is only as good as its tools. We need a way to fetch data from the Oura Ring and a way to "write" to our food diary.

import requests

def get_oura_recovery(api_key: str):
    """Fetches the latest readiness score from Oura Cloud API."""
    # Mocking the API call for demonstration
    # In production, use: requests.get(f"{OURA_URL}/readiness", headers=...)
    return 85 

def update_food_log(meal_name: str):
    """Simulates updating a food tracking app like MyFitnessPal."""
    print(f"✅ Successfully logged: {meal_name}")
    return "Success"

# Define tools for OpenAI Function Calling
tools = [get_oura_recovery, update_food_log]

Step 3: Designing the LangGraph Logic

Now for the magic. We define nodes (the "brain" or "actions") and edges (the "paths"). This allows the agent to decide if it needs more data before giving an answer.

from langgraph.graph import StateGraph, END
from langchain_openai import ChatOpenAI

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

def nutrition_coach_node(state: AgentState):
    # The LLM decides if it needs to call get_oura_recovery
    response = llm.invoke(f"User says: {state['user_input']}. Check recovery and suggest meals.")
    return {"current_plan": response}

workflow = StateGraph(AgentState)
workflow.add_node("coach", nutrition_coach_node)
workflow.set_entry_point("coach")
workflow.add_edge("coach", END)

app = workflow.compile()

The "Official" Way: Scaling to Production 🚀

While this prototype is a great start, building production-ready AI health agents requires handling edge cases like HIPAA compliance, token optimization, and complex multi-agent handoffs.

For deeper dives into advanced AI patterns and more production-ready examples, I highly recommend checking out the WellAlly Blog. It's a goldmine for developers looking to bridge the gap between "cool demo" and "scalable product."

Step 4: Putting it into Action

When you run this agent, the flow looks like this:

User: "I just woke up, what should I eat?"
Agent: Sees it doesn't have the recovery score.
Tool Call: Calls get_oura_recovery.
Result: Score is 65 (Low).
Agent: "Your recovery is low today. I suggest an anti-inflammatory breakfast: Avocado toast with poached eggs. Shall I log this?"
User: "Yes, please."
Tool Call: Calls update_food_log.

Conclusion: The Future of Health is Autonomous

By combining LangGraph with biometric data, we’ve moved from a static Q&A bot to a proactive agent that understands the physical context of the user. This "closed-loop" approach is the blueprint for the next generation of wellness apps.

What are you building with LangGraph? Drop a comment below or share your latest agentic workflow! And don't forget to explore more architectural insights at wellally.tech/blog.

DEV Community