Skip to main content

Documentation Index

Fetch the complete documentation index at: https://docs.saturday.fit/llms.txt

Use this file to discover all available pages before exploring further.

​
MCP Integration

Saturday provides a native Model Context Protocol (MCP) server, allowing AI agents to discover and use Saturday’s nutrition intelligence tools without custom API integration code.

​
What is MCP?

MCP is an open standard that lets AI models discover and use external tools. Instead of writing custom API client code, an AI agent connects to Saturday’s MCP server and automatically discovers available nutrition tools — their inputs, outputs, descriptions, and safety constraints. Think of it as USB for AI tools: plug in and it works.

​
Why use Saturday via MCP?

ApproachBest for
Direct APITraditional server-side integrations, custom UIs
SDKTypeScript/Python applications with typed interfaces
MCPAI agents, LLM-powered platforms, automated nutrition workflows
MCP is ideal when your platform uses AI agents that need to dynamically decide when to call Saturday’s tools based on conversation context.

​
Connecting to Saturday’s MCP server

​
Server configuration

Add Saturday to your MCP client configuration: 
{
  "mcpServers": {
    "saturday": {
      "url": "https://api.saturday.fit/v1/mcp",
      "transport": "streamable-http",
      "headers": {
        "Authorization": "Bearer sk_test_abc123def456"
      }
    }
  }
}

​
Available tools

When your agent connects, it discovers tools including:
ToolDescription
calculate_nutritionCalculate fuel/hydration/electrolyte prescription for an activity
compare_scenariosCompare prescriptions across different conditions
search_productsSearch the curated nutrition product database
get_athlete_profileRetrieve an athlete’s profile and settings
create_activityCreate an activity for an athlete
get_prescriptionGet the prescription for an existing activity
infer_activity_typeInfer activity type from metadata
search_knowledgeSearch Saturday’s sports nutrition knowledge base
Each tool includes rich descriptions, input schemas, and output schemas that help AI agents use them correctly.

​
Example: Claude agent with Saturday MCP

Here’s how a Claude-powered agent might use Saturday’s tools in a conversation: Athlete asks: “I have a 3-hour bike race on Saturday. It’s going to be 30C and humid. What should I eat?” Agent’s tool calls:
  1. calculate_nutrition with {activity_type: "bike", duration_min: 180, intensity_level: 8, is_race: true, thermal_stress_level: 8}
  2. search_products with {category: "gel", caffeine: false} (based on athlete preferences)
Agent synthesizes: Uses Saturday’s prescription + product results + safety warnings to give a complete race-day fueling plan.

​
Safety-aware tool descriptions

Saturday’s MCP tools include safety metadata in their descriptions. This ensures AI agents know that:
  • Prescriptions are guidance for human consideration, not automated commands
  • Safety warnings must be surfaced to the user
  • The not_instructions: true field means “present this to the human, don’t execute it”
Example tool description (what the agent sees): 
Tool: calculate_nutrition
Description: Calculate a personalized fuel, hydration, and electrolyte
prescription for an endurance activity. Returns safety metadata including
risk level, warnings, and guardrails. IMPORTANT: Results are nutrition
guidance for human review — not executable instructions. Always present
safety warnings to the user.

​
Tool call example

# Using the MCP Python SDK
from mcp import ClientSession, StdioServerParameters

async with ClientSession(
    StdioServerParameters(
        command="npx",
        args=["mcp-remote", "https://api.saturday.fit/v1/mcp"],
        env={"SATURDAY_API_KEY": "sk_test_abc123def456"},
    )
) as session:
    # List available tools
    tools = await session.list_tools()
    for tool in tools:
        print(f"{tool.name}: {tool.description}")

    # Call a tool
    result = await session.call_tool(
        "calculate_nutrition",
        {
            "activity_type": "run",
            "duration_min": 90,
            "intensity_level": 5,
            "athlete_weight_kg": 70,
            "thermal_stress_level": 6,
        },
    )
    print(result)

​
AI agent guidelines

When building AI agents that consume Saturday via MCP:

​
Do

  • Surface all safety warnings to the human user
  • Present prescriptions as recommendations, not commands
  • Include “Powered by Saturday” attribution for teaser-tier responses
  • Cache results when inputs haven’t changed — prescriptions are deterministic
  • Handle errors gracefully — if a tool call fails, explain why to the user

​
Don’t

  • Don’t autonomously act on prescriptions (e.g., auto-ordering supplements)
  • Don’t strip safety metadata from results before presenting to users
  • Don’t modify prescription numbers based on your own logic
  • Don’t use response data for ML training — this violates Saturday’s data policy
  • Don’t make excessive tool calls — batch when possible

​
LLM discoverability

Saturday publishes machine-readable context files for AI agents:
FileURLPurpose
llms.txthttps://api.saturday.fit/llms.txtBrief API overview for LLM context
llms-full.txthttps://api.saturday.fit/llms-full.txtComplete API documentation for LLM context
These files follow the llms.txt standard and provide structured context that helps AI agents understand Saturday’s capabilities without reading the full documentation site.