ouraring-mcp
Read-only access to your own Oura Ring data through MCP for natural-language queries and summaries.
Check whether Oura credentials are configured and list all readable collections/scopes.
Fetch your personal profile (age, weight, height, email).
Get daily summaries for sleep, readiness, activity, stress, SpO2, resilience, and cardiovascular age.
Read any supported Oura v2 collection: sleep sessions, sleep time, workouts, sessions, tags/enhanced tags, heart rate, rest mode periods, ring configuration/battery, VO2 max, and daily_* summaries.
Query by date range, fetch one document by ID, or get latest heart-rate/battery samples.
Generate a one-call recent summary over the last N days (default 7, max 90).
All tools are read-only; results return as JSON text, with caching for repeated date-range queries.
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@ouraring-mcpHow did I sleep last night?"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
ouraring-mcp
MCP (Model Context Protocol) server that lets an AI assistant read your own Oura Ring data — sleep, readiness, activity, heart rate, SpO2, stress, workouts, sessions — so you can ask questions and get summaries in natural language. Personal, single-user, non-commercial use. Data is fetched on demand and not stored or shared.
Built for the Oura API v2 (api.ouraring.com), same stdio-MCP layout as
parksapi-mcp.
Tools
Tool | What it does | Oura scope(s) |
| Credential check (no network) | — |
| Every readable collection + required scope | — |
| Profile (age, weight, height, email) |
|
| Daily summaries: |
|
| Any collection: | per collection |
| Last N days (sleep + readiness + activity + stress) in one call |
|
All tools return JSON as text and are read-only. Unknown collections/types
return { isError: true } with a plain message, never a protocol error.
Date params are YYYY-MM-DD; heartrate also accepts ISO datetimes + latest.
Related MCP server: Oura Ring MCP Server
Requirements
Node 22+.
Setup
npm install
npm run buildOAuth2 (only method — Oura retired PATs Dec 2025)
Register at https://cloud.ouraring.com/oauth/applications with:
Redirect URI:
http://localhost:8080/callbackScopes:
email personal daily heartrate workout tag session spo2 ring_configuration stress heart_healthPrivacy / Terms: this repo's
PRIVACY.md/TERMS.md
Then:
npm run auth:oura # prints the authorize URL
# open the URL, approve, copy ?code= from the localhost redirect, then:
npm run auth:oura -- --code=PASTE_CODE_HEREauth:oura reads OURARING_CLIENT_ID/OURARING_CLIENT_SECRET from the
environment → local .env → ~/.hermes/.env, then prints
OURARING_ACCESS_TOKEN (short-lived) + OURARING_REFRESH_TOKEN (long-lived).
The server auto-refreshes via the refresh token when client credentials are present — no manual refresh needed.
Install in your tools
Build once (npm install && npm run build), then point any client at
dist/index.js via stdio with OURARING_REFRESH_TOKEN + OURARING_CLIENT_ID +
OURARING_CLIENT_SECRET in the environment (server auto-refreshes; access token alone expira rápido).
Replace /path/to/ouraring-mcp with your checkout below.
Claude Code
claude mcp add ouraring \
--env OURARING_REFRESH_TOKEN=... \
--env OURARING_CLIENT_ID=... \
--env OURARING_CLIENT_SECRET=... \
-- node /path/to/ouraring-mcp/dist/index.jsOr per-project .mcp.json (user scope: claude mcp add -s user ...):
{
"mcpServers": {
"ouraring": {
"command": "node",
"args": ["/path/to/ouraring-mcp/dist/index.js"],
"env": {
"OURARING_REFRESH_TOKEN": "...",
"OURARING_CLIENT_ID": "...",
"OURARING_CLIENT_SECRET": "..."
}
}
}
}Codex CLI (~/.codex/config.toml)
[mcp_servers.ouraring]
command = "node"
args = ["/path/to/ouraring-mcp/dist/index.js"]
[mcp_servers.ouraring.env]
OURARING_REFRESH_TOKEN = "..."
OURARING_CLIENT_ID = "..."
OURARING_CLIENT_SECRET = "..."OpenCode
opencode mcp add ouraring \
--env OURARING_REFRESH_TOKEN=... \
--env OURARING_CLIENT_ID=... \
--env OURARING_CLIENT_SECRET=... \
-- node /path/to/ouraring-mcp/dist/index.jsConfig-file equivalent (opencode.jsonc; v2 nests under mcp.servers,
older versions use flat mcp):
{
"$schema": "https://opencode.ai/config.json",
"mcp": {
"servers": {
"ouraring": {
"type": "local",
"command": ["node", "/path/to/ouraring-mcp/dist/index.js"],
"environment": {
"OURARING_REFRESH_TOKEN": "...",
"OURARING_CLIENT_ID": "...",
"OURARING_CLIENT_SECRET": "..."
}
}
}
}
}Hermes (~/.hermes/config.yaml)
mcp_servers:
ouraring:
command: node
args:
- /home/hermes/github/ouraring-mcp/dist/index.js
env:
OURARING_REFRESH_TOKEN: "..."
OURARING_CLIENT_ID: "..."
OURARING_CLIENT_SECRET: "..."
enabled: trueThen restart the gateway. Verify with oura_status (no network call).
OpenClaw
openclaw mcp add ouraring \
--cwd /path/to/ouraring-mcp \
-- command node --arg /path/to/ouraring-mcp/dist/index.js
openclaw mcp doctor ouraring --probeSet the tokens via Settings → MCP (scoped config editor → environment
values), or OURARING_REFRESH_TOKEN + client credentials in the gateway environment.
Claude Desktop (claude_desktop_config.json)
{
"mcpServers": {
"ouraring": {
"command": "node",
"args": ["/path/to/ouraring-mcp/dist/index.js"],
"env": {
"OURARING_REFRESH_TOKEN": "...",
"OURARING_CLIENT_ID": "...",
"OURARING_CLIENT_SECRET": "..."
}
}
}
}Examples
{ "data_type": "sleep", "start_date": "2026-10-15", "end_date": "2026-10-22" }
{ "collection": "heartrate", "start_datetime": "2026-10-22T00:00:00Z", "latest": true }
{ "collection": "ring_battery_level", "start_datetime": "2026-10-21T00:00:00-04:00" }
{ "collection": "workout", "start_date": "2026-10-01", "end_date": "2026-10-22", "fields": "activity_type,calories" }
{ "collection": "VO2_Max", "start_date": "2026-09-22", "end_date": "2026-10-22" }
{ "days": 7 }Notes (checked against Oura's OpenAPI spec):
Collection names are case-insensitive, but the API path for VO₂max is case-sensitive upstream (
vO2_max) — the server maps it automatically.heartrateandring_battery_levelquery by ISO datetime +latest;ring_configurationtakes no date params; everything else takesstart_date/end_date. Single-doc fetch viadocument_idonly where the API offers it (not forenhanced_tag/heartrate/personal_info/ring_battery_level).fieldsselects response fields on most routes (notdaily_resilience,enhanced_tag,tag).Webhooks (
/v2/webhook/*) are out of scope: they need a public HTTPS URL and write operations — this server is read-only by design.
Privacy
See PRIVACY.md and TERMS.md: on-demand reads only, no sharing, single user. Revoke any time from your Oura dashboard.
Cold cache
Repeat date-range queries don't re-hit Oura: responses are cached in
./oura-cache.sqlite (node:sqlite, git-ignored — never committed) with
per-day coverage. The last 2 days always refetch (Oura keeps finalizing
them); older days are immutable — fetched once, served forever. Range queries
that end in the past and are fully covered use zero upstream calls
(cacheHit: true in the response). personal_info / ring_configuration
are cached 30 days, single-document fetches 7 days. Any SQLite error
disables the cache silently and the call goes straight to the API.
OURARING_CACHE_PATH=/tmp/oura.sqlite # default ./oura-cache.sqlite
OURARING_CACHE_ENABLED=0 # bypass cache, fail-soft
OURARING_PERSONAL_INFO_TTL_HOURS=720 # default 30d
OURARING_RING_CONFIGURATION_TTL_HOURS=720
OURARING_CACHE_TTL_HOURS=168 # default 7d for the rest(OURA_* aliases work for every knob above.)
Develop
npm test # build + vitest (offline unit, stdio protocol, opt-in live)
npm audit --audit-level=moderate # fail on moderate+ advisories (dev + prod deps)tests/live.test.ts calls the real API only when OURARING_ACCESS_TOKEN is set;
otherwise it passes with a skip note.
Every push is gated: npm run setup:hooks installs a pre-push hook that
rebuilds and runs the suite — a red test blocks the push. GitHub Actions
(.github/workflows/ci.yml) enforces the same on every push/PR, plus
npm audit (moderate+) so new advisories break the build before merge.
Dependency upgrades that fix audit findings must keep the suite green
(e.g. vitest 3 → 5); if a fix needs a breaking major, do it in its own commit
with the audit delta in the message.
Available Tools
6 toolsget_collectionARead-only
Read any Oura v2 collection: sleep sessions, workouts, guided sessions, tags, heartrate samples, sleep_time, rest_mode_period, ring_configuration, vo2_max, or daily_* summaries. One document via document_id, or a date range.
| Name | Required | Description | Default |
|---|---|---|---|
| limit | No | Max items (default 50). | |
| fields | No | Comma-separated field selector (most routes; not daily_resilience/enhanced_tag/tag). | |
| latest | No | Heartrate and ring_battery_level: return the most recent sample. | |
| end_date | No | ||
| collection | Yes | Collection name — one of: sleep, sleep_time, workout, session, tag, enhanced_tag, heartrate, rest_mode_period, ring_configuration, ring_battery_level, vo2_max, daily_sleep, daily_readiness, daily_activity, daily_stress, daily_spo2, daily_resilience, daily_cardiovascular_age, personal_info. | |
| start_date | No | Calendar date YYYY-MM-DD. | |
| document_id | No | Fetch one document by id (not for enhanced_tag/heartrate/personal_info/ring_battery_level). | |
| end_datetime | No | Heartrate and ring_battery_level: ISO datetime. | |
| start_datetime | No | Heartrate and ring_battery_level: ISO datetime, e.g. 2026-10-15T00:00:00Z. |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true and openWorldHint=true, so the safety profile is covered. The description adds the single-vs-range retrieval modes but says nothing about pagination, rate limits, auth, or how large ranges behave — the traits an agent most needs beyond the annotations.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two tight sentences, zero filler, with the scope declared first and the retrieval modes second. Every clause carries information.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a 9-parameter, multi-route tool with no output schema, the description covers the main usage shape but its collection list is incomplete relative to the schema enum (it omits enhanced_tag, ring_battery_level, and personal_info), which could mislead an agent about availability. Pagination and response shape are unaddressed but partially implied by limit in the schema.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 89%, so the schema already documents limit, fields, latest, dates, and document_id. The description only re-summarizes the collection list and the document_id/date-range dichotomy, adding little syntax or format detail beyond the schema. Baseline 3 applies.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
States a concrete verb ('Read') and resource ('any Oura v2 collection') and enumerates the collection families, which makes the tool's scope unmistakable. It stops short of naming how it differs from siblings like get_daily or get_recent_summary, so an agent must infer the boundary.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The sentence 'One document via document_id, or a date range' communicates the two invocation modes, which is real usage guidance. It offers no when-to-use/when-not-to-use framing against get_daily, get_recent_summary, or list_collections, and no prerequisites.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_dailyBRead-only
Daily summaries for sleep, readiness, activity, stress, spo2, resilience or cardiovascular_age. Best for questions like 'how did I sleep this week?'.
| Name | Required | Description | Default |
|---|---|---|---|
| limit | No | Max items (default 50). | |
| fields | No | Comma-separated field selector (most routes; not daily_resilience/enhanced_tag/tag). | |
| end_date | No | ||
| data_type | Yes | Which daily summary. | |
| start_date | No | Calendar date YYYY-MM-DD. |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true and openWorldHint=true, so the safety profile is covered. The description adds no behavioral context beyond the enumeration of data types: nothing about date-range defaults, pagination, whether missing days are returned, or what the response looks like, which matters for an open-world data source.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two short sentences, front-loaded with the resource, followed by a concrete usage exemplar. Nothing is wasted and nothing is buried.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
With five parameters, no output schema, and no annotations about behavior, the description is adequate for invocation but thin on completeness: it never explains the return shape or what the date range does by default, leaving the agent to infer output structure from the data-type names alone.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 80%, so start_date, end_date, limit, and data_type are already documented in the schema. The description merely restates the same data-type list and adds no format or semantics beyond it; baseline 3 applies.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
Names a specific resource ('daily summaries') and enumerates the seven supported data types, which maps precisely onto the data_type enum. An agent can distinguish this from get_collection or list_collections, though it never explicitly contrasts with the close sibling get_recent_summary.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The line 'Best for questions like how did I sleep this week?' gives an implied usage context, which is more than nothing. However, there is no explicit when-not guidance and no named alternative for nearby cases such as get_recent_summary, so routing between the two is left to inference.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_personal_infoARead-only
Your Oura profile (age, weight, height, email). Scopes: personal, email.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true, so the safety profile is covered; the description goes beyond them by disclosing the required OAuth scopes (personal, email), which is real authorization context an agent needs before planning a call. It does not cover error behavior if a scope is missing, but the added scope information is substantive.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two short sentences: first the resource and its contents, then the auth scopes. Nothing is padded and the most important information leads.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a no-parameter read with annotations already declaring read-only and no output schema, the description covers what the tool returns (age, weight, height, email) and what it requires to run (scopes). That is everything an agent needs to select and invoke it.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool takes zero parameters, so the baseline is 4 and there is nothing the description could add about inputs. It instead documents the shape of the returned profile fields, which is useful given there is no output schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
Names the specific resource (the user's Oura profile) and enumerates the fields returned, so an agent knows exactly what data comes back. The verb is only implied by the tool name, and no sibling is named, but the resource is distinct enough from get_daily/get_recent_summary to be unambiguous.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Usage is implied: this is the only profile/metadata tool among data-retrieval siblings, so an agent can infer when to reach for it. There is no explicit 'use this when' or exclusion statement, and no mention of what to use instead for body-composition time series (a plausible confusion point with weight data).
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_recent_summaryARead-only
One-call overview of the last N days (sleep + readiness + activity + stress + spo2 daily summaries) for natural-language summaries like 'how was my week?'.
| Name | Required | Description | Default |
|---|---|---|---|
| days | No | Recent calendar days (default 7, max 90). |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already cover read-only and open-world traits, so the description only needs to add what they don't. It does: the key behavior is batching five domain summaries into a single call, and it enumerates which domains come back. It says nothing about response shape or payload size, which matters for the 90-day max, but the core behavior is disclosed.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
A single front-loaded clause covers what it does, which domains it includes, and a usage example. Every element earns its place, and nothing is padded.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
With one optional parameter, no output schema, and annotations covering safety, the remaining burden is telling the agent what comes back. The domain list does that adequately; a brief note on return granularity (daily-per-domain) would close the last gap.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100%, and the schema already documents the default of 7 and the max of 90. The description's 'last N days' only restates the parameter, so the baseline 3 applies.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
States a specific verb and resource: a one-call aggregated overview over the last N days spanning five named domains (sleep, readiness, activity, stress, spo2). That is clearly distinct from get_daily, though the description never names the sibling to make the contrast explicit.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Gives a concrete triggering scenario ('how was my week?') that tells the agent when to reach for this aggregated tool. It stops short of an explicit exclusion such as 'use get_daily for a single day', so the boundary is inferred rather than stated.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
list_collectionsARead-only
List every Oura collection this server can read, with the OAuth scope each needs.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The readOnlyHint annotation already establishes this as a safe read. The description adds useful context by saying each collection's required OAuth scope is included, but it does not describe return shape, pagination, or ordering.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
A single efficient sentence, front-loaded with the action and resource, with no filler.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a no-parameter, read-only list tool, the description is nearly complete: it says what is listed and that OAuth scope metadata is included. Minor gaps around return structure are acceptable given the simple contract and readOnly annotation.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool has zero parameters, so there are no parameter semantics to explain beyond what the schema already provides. Baseline is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description states a specific verb and resource: 'List every Oura collection this server can read.' It is distinguishable from the singular sibling get_collection, but it does not explicitly name the alternative or clarify the boundary beyond 'every'.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Usage is implied as a discovery/list operation for Oura collections, but there is no explicit guidance on when to use this versus get_collection or other siblings.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
oura_statusARead-only
Check whether Oura credentials are configured (no network call).
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true, so the safety profile is covered; the description adds genuinely new context by specifying the check is purely local and makes no network call, telling the agent it is fast and does not validate credentials against the API. It omits what the result looks like (boolean vs error), which keeps it below a 5.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
One short sentence, front-loaded with the action and immediately qualified by the surprising constraint (no network call). Nothing is wasted.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a trivial zero-arg status check with annotations covering safety, the description is nearly sufficient. The one gap is the return shape — a status check's usefulness depends on knowing whether it yields a boolean, an enum, or an error — which neither the description nor an output schema provides.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool takes zero parameters, so there is nothing to disambiguate and the schema is fully self-describing. Baseline 4 applies for a no-parameter tool.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
States a specific verb and resource — checking whether Oura credentials are configured — and adds the scoping qualifier 'no network call', which separates it from the data-fetching siblings like get_daily and get_personal_info. It does not name a sibling explicitly, so it falls just short of a 5.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Usage is only implied: an agent can infer this is a pre-flight/auth check to run before the get_* tools, but the description never says when to call it or what to do with the result. No explicit alternatives or exclusions are given.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
6 tool updates
v0.3.0- First observed
get_collection - First observed
get_daily - First observed
get_personal_info - First observed
get_recent_summary - First observed
list_collections - First observed
oura_status
TDQS
Scored across 6 tools
Each tool has a reasonably distinct intent, and descriptions proactively guide selection (get_daily 'best for how did I sleep this week', get_recent_summary for a one-call week overview). The only real overlap is that get_collection's daily_* option and get_daily both surface daily summaries, plus get_recent_summary is effectively a composite of those, but the convenience layering is explained well enough to choose correctly.
The surface follows a clear verb_noun pattern (list_collections, get_personal_info, get_daily, get_recent_summary, get_collection). oura_status is a minor deviation in style (server-prefixed noun_status), but it is still readable and unambiguous.
Six tools is well-scoped: a status check, a discovery helper, a profile reader, three tiers of data reads (single-day, multi-day summary, generic collection). The generic get_collection tool absorbs breadth so no per-resource tool sprawl is needed.
Read coverage is broad and essentially complete via get_collection (sleep, workouts, tags, heartrate, ring config, vo2_max, daily_*), plus profile and credentials status. The gap is that the surface is strictly read-only — no create/update operations for tags, workouts, or personal info — which limits write-oriented workflows.
Maintenance
Related MCP Connectors
- freddyOAuthcoach.freddy
Connect your wearables, rings and training apps, then ask your AI about your own health data.
Read sleep, readiness, activity, stress, heart rate and workouts from the Oura Ring.
Connect your Oura Ring account securely in minutes. Enable authorized access to your sleep, activi…
Connect your Oura Ring account and enable access to your wellness data in apps and automations. In…
Related MCP Servers
- FlicenseNot gradedqualityNot gradedmaintenanceEnables AI assistants to access and analyze Oura Ring health data including sleep, readiness, activity, and stress metrics. Supports customizable queries, correlation analysis, and visualization capabilities for comprehensive health insights.-
- AlicenseNot gradedqualityDmaintenanceEnables access to Oura Ring health data including sleep patterns, activity metrics, readiness scores, heart rate, workouts, and stress measurements with AI-powered analysis and personalized recommendations.179 npmMIT
- AlicenseNot gradedqualityDmaintenanceEnables AI assistants to access Oura Ring health data including sleep, readiness, activity, heart rate, and workouts through OAuth2-authenticated API calls with automatic token refresh and smart caching.3 npmMIT
- AlicenseNot gradedqualityFmaintenanceEnables AI assistants to access your Oura Ring health data through OAuth2-authenticated API calls.3 npm9MIT