Circadian REM Sleep Cycle Optimizer MCP for AI. Map your sleep schedule by natural biological cycles.
Works with every AI agent you already use
…and any MCP-compatible client








Connect to your AI in seconds.
The Circadian REM Sleep Cycle Optimizer calculates optimal wake-up and bedtime schedules based on deep chronobiology. It maps your sleep plan around natural 90-minute REM phases, factoring in how long it takes you to actually fall asleep.
Stop guessing—get a precise schedule that aligns with your body's rhythm.
What your AI can do
Calculate circadian rhythm
Maps out energy peaks and troughs throughout the day based on wake time
Calculate nap times
Requires wake-up time in HH:mm.
Calculates the ideal window for power naps based on wake-up time
Calculate sleep cycles
Provide a targetTimeStr (HH:mm) and the mode (sleep_at or wake_up_at).
Calculates optimal wake-up or bedtimes aligned with 90-minute REM sleep phases, incorporating latency buffers for circadian rhythm optimization
It maps out expected periods of high focus and low energy across an entire day based on when you plan to wake up.
It determines the best time for a quick rest, ensuring the nap falls within natural sleep cycles relative to your eventual wake-up time.
It calculates precise times you need to be asleep or woken up to complete a whole number of 90-minute sleep cycles.
It figures out how much rest you're truly missing and gives you an actionable plan for recovery.
Ask an AI about this
Waiting for input…
Circadian REM Sleep Cycle Optimizer: 4 Tools
Use these tools to map out energy peaks, calculate ideal naps, structure sleep cycles, and plan for recovery from accumulated sleep debt.
Make your AI actually useful.
Add this MCP to Claude, Cursor, or Windsurf and your AI stops guessing. It gets real tools to look things up, take action, and handle the stuff you keep doing by hand.
Start using Circadian REM Sleep Cycle Optimizer on VinkiusCalculate Circadian Rhythm
Maps out energy peaks and troughs throughout the day based on wake time
Calculate Nap Times
Requires wake-up time in HH:mm. Calculates the ideal window for power naps based on...
Calculate Sleep Cycles
Provide a targetTimeStr (HH:mm) and the mode (sleep_at or wake_up_at). Calculates...
Calculate Sleep Debt
Requires daily required hours and an array of actually slept hours. Calculates...
Security and governance baked right in.
Pick your AI client below to get set up. Just create a Vinkius account, subscribe, and you're instantly up and running. We handle the entire backend infrastructure, delivering out-of-the-box support for HTTPS Streamable, SSE, and OAuth2—zero messy routing required.
Choose How to Get Started
Build a custom MCP for your own tools, or connect a ready-made integration from our catalog.
Build Your Own
Turn any API into an MCP. Import a spec, define Agent Skills, or deploy with MCPFusion.
- Import from OpenAPI, Swagger, or YAML specs
- Create Agent Skills with progressive disclosure
- Deploy to edge with MCPFusion framework
- Built in DLP, auth, and compliance on every call
- Real time usage dashboard and cost metering
- Publish to catalog or keep private
Make Your AI Do More
Start with Circadian REM Sleep Cycle Optimizer, then connect any of our 5,100+ other servers whenever your AI needs more. One click, no limits.
- Use this MCP plus 5,100+ others, all in one place
- Add new capabilities to your AI anytime you want
- Every connection is secured and compliant automatically
- Track usage and costs across all your servers
- Works with Claude, ChatGPT, Cursor, and more
- New servers added to the catalog every week
Independent Platform Disclaimer: Vinkius is an independent platform and is not affiliated with, endorsed by, sponsored by, verified by, or otherwise authorized by sleep-cycle-planner. All third-party trademarks, logos, and brand names are the property of their respective owners. Their use on this website is strictly for informational purposes to identify service compatibility and interoperability.
VINKIUS INFRASTRUCTURE
Cloud Hosted
Managed infra
V8 Isolated
Sandboxed per request
Zero-Trust Proxy
No stored credentials
DLP Enforced
Policy on every call
GDPR Compliant
EU data residency
Token Compression
~60% cost reduction
Works with Claude, ChatGPT, Cursor, and more
The Model Context Protocol standardizes how applications expose capabilities to LLMs. Instead of operating in isolation, your AI gains direct access to external platforms, live data, and real-world actions through secure, standardized connections.
This connection provides 4 powerful capabilities that interface natively with Claude, ChatGPT, Cursor, and other compatible AI platforms. No middleware. No custom integration required.
The Difficulty of Timing Rest Right
Right now, figuring out a perfect sleep schedule means checking multiple sources: one site says you need 8 hours; another talks about REM cycles; and a third mentions 'sleep latency.' You end up cross-referencing math by hand, trying to reconcile all the conflicting data points into one clean plan that actually works.
With this MCP, your agent handles the whole calculation. It runs those complex chronobiology rules—the 90-minute cycles, the fall asleep buffer, everything—and spits out a single, clear timeline you can trust immediately.
Calculate Sleep Cycles: Precision Timing for Your Schedule
You no longer have to manually count cycles or guess when your alarm will interrupt deep sleep. This MCP takes the guesswork out of scheduling, ensuring every wake-up moment aligns with a natural energy ebb.
This isn't just about knowing how many hours you slept; it’s about making sure those hours were structured correctly for maximum mental output tomorrow.
What your AI can actually do with this
Sleep planning is complicated. Most generic advice suggesting '8 hours of sleep' misses the point; those arbitrary times often cut through deep restorative cycles, leaving you groggy when you wake up. This MCP solves that by applying real chronobiology rules. It handles everything from mapping your energy peaks to adjusting for how long it takes you to fall asleep.
Whether you need a rigid schedule for work or flexible timing for a weekend, this tool figures out the exact timestamps needed. You connect it through Vinkius and let your AI client handle the complex math instantly. Instead of getting generalized advice, you get a calculated timeline that respects your natural sleep architecture.
019e38ee-83c9-72db-8ecf-0668d92d969e Here's how it actually works
The bottom line is you feed it a time constraint, and it spits out the scientifically backed window you need to hit that target.
First, specify your goal: Are you setting a wake-up alarm or calculating bedtime? What time is that?
The MCP runs the data through chronobiology rules, accounting for sleep latency and mapping out full 90-minute REM cycles.
You get back specific optimal timestamps (e.g., 'Bed by 10:45 PM') that maximize your natural energy flow.
Who is this actually for?
Anyone whose performance depends on peak mental clarity—the biohacker, the high-stakes developer, or the coach managing an athlete's recovery. You are tired of feeling 'almost rested' and need actionable sleep schedules, not general wellness tips.
Determines optimal rest periods for athletes by calculating nap windows and analyzing total sleep debt.
Uses the MCP to plan work-life balance, ensuring early morning alarms align with full REM cycles so they can hit the ground running.
Calculates ideal schedules for intense project sprints, balancing deep work requirements against necessary restorative sleep periods.
What Changes When You Connect
Stop waking up groggy. The calculate_sleep_cycles tool guarantees your alarm aligns with light sleep phases, not the middle of a deep REM cycle.
Move beyond vague advice. Instead of guessing, use calculate_nap_times to pinpoint exactly when you need a rest window relative to your wake-up time.
Know your true deficit. The calculate_sleep_debt tool quantifies how much sleep you actually owe yourself and builds a recovery plan for it.
Plan the whole day's energy flow, not just bedtime. Use calculate_circadian_rhythm to see when your focus peaks throughout an entire work cycle.
It accounts for reality. The MCP includes latency buffers in its calculations, knowing that you don't fall asleep instantly.
See it in action
The high-intensity coder needs a sustainable schedule.
The developer works late nights and wants to maintain focus. They ask their agent to use calculate_sleep_cycles, setting the alarm for 07:00 AM. The MCP calculates that they must be asleep by 11:30 PM to complete five full cycles, giving them a realistic bedtime goal.
The parent needs a power nap during a busy day.
A working parent has a hard wake time of 5:30 PM but needs a quick rest. They use calculate_nap_times, and the MCP tells them that a 20-minute window between 1:00 PM and 2:00 PM will be most restorative.
The student prepping for exams needs to catch up.
A college student realizes they've been running on fumes. They use calculate_sleep_debt, which analyzes their required hours versus actual sleep and provides a multi-day recovery plan.
The team lead needs to structure an all-hands meeting schedule.
A manager uses the MCP with calculate_circadian_rhythm to avoid scheduling critical meetings during the afternoon energy trough, ensuring peak participation times are respected.
The honest tradeoffs
Just setting an alarm time.
Setting a simple reminder for 'Wake up at 6:00 AM' without considering the sleep cycle. This often means waking up during deep sleep, leaving you feeling worse than when you started.
Always use calculate_sleep_cycles. Tell it your target wake-up time (e.g., 6:00 AM) and let the MCP work backward to give you an optimal bedtime that respects full REM cycles.
Calculating sleep based on simple hours.
Saying, 'I need 8 hours of sleep,' which ignores the fact that a few extra minutes can make a huge difference in quality and focus.
Use calculate_sleep_cycles instead. It respects the biological rhythm, giving you precise windows—for example, aiming for five cycles (9 hours) rather than just 8 straight hours.
Forgetting about nap latency.
Booking a 'nap' window right up to wake-up time. You might get in bed but never actually fall asleep, wasting the whole period.
Always use calculate_nap_times or provide the sleep latency buffer when calculating cycles. This makes sure your schedule accounts for the time it takes you to drift off.
When It Fits, When It Doesn't
Use this MCP if your goal is deep, measurable performance improvement through timing—for instance, scheduling a complex project rollout or optimizing an athlete's recovery timeline. You need to know why a time works, not just when. Don't use it if you simply need a general reminder (e.g., 'Go to bed at 10 PM'). For basic reminders, simple calendar tools suffice. If your issue is generalized fatigue without timing concerns, start with calculate_sleep_debt; but for anything requiring precise scheduling, this MCP provides the necessary biological depth.
Questions you might have
How does calculate_sleep_cycles account for falling asleep? +
It incorporates an adjustable 'fall asleep' buffer (latency). This means the calculated bedtime isn't just a raw number; it's buffered to give you realistic time to drift off.
Can calculate_circadian_rhythm help with my workday timing? +
Yes. It maps out energy peaks and troughs across the day, letting you schedule your most complex tasks during naturally high-focus periods.
What does calculate_sleep_debt really show me? +
It calculates the difference between what your body needs and what you actually got. Crucially, it doesn't just give a number; it provides an actionable strategy to recover that deficit.
Is calculate_nap_times better than just taking a short nap? +
Yes, because calculate_nap_times finds the ideal window. It makes sure your power nap doesn't cut off a critical sleep cycle, maximizing the restorative benefit.
What specific time format does the `calculate_sleep_cycles` tool require for input? +
It requires standard HH:mm strings. The system handles 24-hour clock times consistently, so you don't need to worry about AM or PM when calculating optimal sleep windows.
If I use `calculate_sleep_debt` and my input hours are impossible, how does the MCP handle the error? +
The MCP validates all time inputs. If your provided array of actual sleep hours falls outside realistic human parameters (like negative or >24 hours), the tool returns a specific validation error detailing which value needs correction.
Can `calculate_circadian_rhythm` account for other lifestyle factors, like diet or intense exercise? +
No. This MCP focuses strictly on chronobiology and time metrics. While general wellness data is useful context, you must provide only time-based parameters to get accurate results from the rhythm calculation.
Are there any performance limitations when running `calculate_nap_times` repeatedly? +
No. The calculations are highly optimized. Since it only performs mathematical projections based on simple time inputs, results appear instantly, even if you make several nap window requests in a row.
What is the 90-minute REM rule? +
Human sleep cycles last approximately 90 minutes. Waking up in the middle of a deep REM phase causes 'sleep inertia' (grogginess). This algorithm targets wake-up times strictly at the end of a cycle, meaning sleeping 7.5 hours (5 cycles) often feels more refreshing than sleeping 8 hours.
Why use an MCP for sleep math? +
Because calculating multiple backward chronobiological subtraction paths in base-60 time causes frequent LLM errors. By offloading it to this deterministic timeline engine, the calculations are mathematically flawless.
Does it account for the time it takes to fall asleep? +
Yes. The algorithm incorporates a 'fallAsleepBufferMinutes' parameter (which defaults to 15 minutes). If you need to wake up at 07:00, the 5-cycle target recommends getting into bed at 23:15, allowing exactly 15 minutes to fall asleep before the cycles commence.
We've already built the connector for Circadian REM Sleep Cycle Optimizer. Just plug in your AI agents and start using Vinkius.
No hosting. No infrastructure. No complex setup.
All 4 tools are live and waiting.
You're up and running in seconds.
Vinkius gives your AI agents access to the full catalog of app connectors, all fully managed, secure, and enterprise-ready. One subscription, every tool you need.
Built, hosted, and secured by Vinkius. You just connect and go.