DEV Community

Beck_Moulton
Beck_Moulton

Posted on

Build an Autonomous Health Agent: Syncing Apple HealthKit to Notion with OpenAI Function Calling

#openai #automation #node #healthtech

We live in an era of "quantified self," yet most of our health data sits rotting in silos. Your Apple Watch knows you're exhausted, your Oura ring knows your sleep was trash, but your Notion workout template still expects you to hit a Personal Best today. It’s time to bridge that gap with AI Agents, OpenAI Function Calling, and Health monitoring automation.

In this tutorial, we will build an "Autonomous Health Assistant" that detects Heart Rate Variability (HRV) anomalies and uses an AI Agent to rewrite your Notion training schedule and even draft doctor's appointments. By leveraging the OpenAI SDK and n8n workflows, we are moving from passive data collection to active, closed-loop health management.

The Architecture: The Feedback Loop

The goal is to create a system that doesn't just "alert" you, but "acts" for you. Here is the high-level data flow using Mermaid.js:

graph TD
    A[Apple HealthKit] -->|HRV/Sleep Data| B(n8n Webhook)
    B --> C{Node.js AI Agent}
    C -->|Analyze Data| D[OpenAI GPT-4o]
    D -->|Function Call: Update Notion| E[Notion API]
    D -->|Function Call: Suggest Appointment| F[Calendar/Email]
    E --> G[Personalized Training Plan]
    F --> H[Doctor Consultation]
    style C fill:#f9f,stroke:#333,stroke-width:2px
Enter fullscreen mode Exit fullscreen mode

Prerequisites

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

  • Node.js (v18+)
  • OpenAI API Key (supporting GPT-4o or GPT-3.5-Turbo)
  • n8n instance (Self-hosted or Cloud) to act as the bridge between mobile shortcuts and your backend.
  • Notion Integration Token and a Database ID for your workout logs.

Step 1: Define the AI Tools (Function Calling)

Function Calling is the "hands" of our AI Agent. We need to tell OpenAI exactly how it can interact with Notion and our communication tools.

// tools.js
export const tools = [
  {
    type: "function",
    function: {
      name: "update_notion_training_plan",
      description: "Adjust the user's training intensity in Notion based on recovery scores.",
      parameters: {
        type: "object",
        properties: {
          intensity: { type: "string", enum: ["Rest", "Light", "Moderate", "High"] },
          reasoning: { type: "string", description: "Why the adjustment is being made." }
        },
        required: ["intensity", "reasoning"]
      }
    }
  },
  {
    type: "function",
    function: {
      name: "suggest_doctor_appointment",
      description: "Trigger an email or calendar invite if health metrics are dangerously low.",
      parameters: {
        type: "object",
        properties: {
          urgency: { type: "string", enum: ["low", "high"] },
          summary: { type: "string" }
        },
        required: ["urgency", "summary"]
      }
    }
  }
];
Enter fullscreen mode Exit fullscreen mode

Step 2: The Agent Logic

The core logic involves receiving HealthKit data (via n8n) and letting the LLM decide what to do. If your HRV is 20% below your 7-day baseline, the agent shouldn't just tell you; it should invoke update_notion_training_plan.

import OpenAI from "openai";
import { tools } from "./tools.js";

const openai = new OpenAI();

async function runHealthAgent(healthMetrics) {
  const messages = [
    { 
      role: "system", 
      content: "You are a specialized Health AI Agent. Analyze the user's HRV and sleep data. If metrics are poor, reduce training intensity. If metrics indicate illness, suggest a doctor's visit." 
    },
    { 
      role: "user", 
      content: `Current HRV: ${healthMetrics.hrv}, Sleep: ${healthMetrics.sleepDuration} hrs, Baseline HRV: ${healthMetrics.baseline}.` 
    }
  ];

  const response = await openai.chat.completions.create({
    model: "gpt-4o",
    messages: messages,
    tools: tools,
    tool_choice: "auto",
  });

  const toolCalls = response.choices[0].message.tool_calls;

  if (toolCalls) {
    for (const toolCall of toolCalls) {
      const { name, arguments: args } = toolCall.function;
      const parsedArgs = JSON.parse(args);

      console.log(`🚀 Executing Tool: ${name} with ${args}`);

      if (name === "update_notion_training_plan") {
        // Logic to hit Notion API
        await updateNotion(parsedArgs.intensity, parsedArgs.reasoning);
      }
    }
  }
}
Enter fullscreen mode Exit fullscreen mode

Step 3: Bridging HealthKit with n8n

Apple HealthKit doesn't easily talk to custom backends. The easiest way to trigger this is via the iOS Shortcuts App:

  1. Shortcut: Every morning, "Get HRV" and "Get Sleep Data."
  2. Action: Send a POST request to an n8n Webhook.
  3. n8n Node: Forwards the JSON payload to your Node.js Agent.

Pro-Tip: Scaling Your Health Agent 🥑

Building a local script is great for a hobby, but if you want to scale this into a production-grade health monitoring system, you need to handle state, historical data analysis, and multi-modal inputs (like photos of your meals).

For a deeper dive into production-ready AI patterns, I highly recommend checking out the technical deep-dives at WellAlly Blog. They cover advanced concepts like RAG for Health Context and Secure Bio-data processing that take this simple agent to the next level.

Step 4: Updating Notion Automatically

Using the @notionhq/client, we can update the training plan. If the agent returns "Rest," we find today's entry and change the status.

async function updateNotion(intensity, reasoning) {
  // Mocking the Notion update
  console.log(`✅ Notion Updated: New Intensity -> ${intensity}`);
  console.log(`📝 Reason: ${reasoning}`);
  // In production, use notion.pages.update(...)
}
Enter fullscreen mode Exit fullscreen mode

Conclusion

We have successfully closed the loop. By combining Apple HealthKit for data, OpenAI for reasoning, and Notion for action, you've created a digital twin that looks out for your physical well-being. No more manually skipping workouts when you're burnt out—your AI already did it for you.

What's next?

  • Add Twilio integration to text your coach.
  • Incorporate Vision to analyze workout form via uploaded videos.

Are you building health-tech agents? Drop a comment below or share your thoughts! Don't forget to visit wellally.tech/blog for more insights on the future of AI-driven wellness. ✌️

Top comments (0)