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

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 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

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

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"]
      }
    }
  }
];

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);
      }
    }
  }
}

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

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.

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(...)
}

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?

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. ✌️