MyFitnessPal MCP Server

A Model Context Protocol (MCP) server that enables AI assistants like Claude to interact with your MyFitnessPal data, including food diary, exercises, body measurements, nutrition goals, and water intake.

Features

Tool	Type	Description
`mfp_get_diary`	Read	Get food diary entries for any date
`mfp_search_food`	Read	Search the MyFitnessPal food database
`mfp_get_food_details`	Read	Get detailed nutrition info for a food item
`mfp_add_food_to_diary`	Write	Add a food item to your diary for a specific meal and date
`mfp_get_measurements`	Read	Get weight/body measurement history
`mfp_set_measurement`	Write	Log a new weight or body measurement
`mfp_get_exercises`	Read	Get logged exercises (cardio & strength)
`mfp_get_goals`	Read	Get daily nutrition goals
`mfp_set_goals`	Write	Update daily nutrition goals
`mfp_get_water`	Read	Get water intake for a date
`mfp_set_water`	Write	Log water intake for a date
`mfp_get_report`	Read	Get nutrition reports over a date range
`refresh_browser_cookies`	Utility	Extract and save session cookies from browser

How diary writes work

MyFitnessPal has no public API. Reads here are scraped from the website via python-myfitnesspal, and diary writes go through MFP's internal v2 JSON API — the same one their web client uses, authenticated with your existing session token.

That interface is undocumented and was determined by observing the web client. It works today, but MyFitnessPal can change it without notice. They have already done so once: this server originally posted to /food/diary/{user}/add, which now returns 404, leaving food logging broken. If logging starts failing, that is the most likely cause.

Prerequisites

Python 3.10–3.12 (check with python3 --version)

Not 3.13+: lxml, pulled in by myfitnesspal, has no wheels for it and fails to build against the 3.14 C API. On macOS, brew install python@3.12.
pip 21.3+ (for pyproject.toml support; upgrade with pip install --upgrade pip)
MyFitnessPal account
One of the following for authentication:
- Recommended (macOS): any Chromium-based browser (Arc, Chrome, Edge, Brave, Vivaldi, Opera, ...) with an active MyFitnessPal login session — the MCP auto-discovers the session on next call
- Firefox with an active MyFitnessPal login session (via the browser_cookie3 fallback)
- Legacy: your MFP username/email and password (see caveats below — MFP's NextAuth backend rejects the form-POST flow, so credential auth only works while cached cookies remain valid)

Authentication Options

This MCP supports multiple authentication methods:

Method	Setup	Persistence
Chromium browser auto-discovery (macOS, recommended)	Log into myfitnesspal.com in any Chromium-based browser (Arc, Chrome, Edge, Brave, Vivaldi, Opera, ...). The MCP auto-detects installed browsers via the macOS keychain and uses whichever one is logged in.	Until browser session expires (cached for 30 days in `~/.mfp_mcp/cookies.json`)
Encrypted credentials (legacy)	Add encrypted `MFP_USERNAME` and `MFP_PASSWORD` to Claude Desktop config; set `MFP_SECRET_KEY` outside the config (for example via shell env or OS keychain)	Form login no longer works against MFP's NextAuth backend — only useful if cached cookies are still valid
Plain credentials (legacy)	Add `MFP_USERNAME` and `MFP_PASSWORD` to Claude Desktop config	Same as above — form login flow is deprecated
Browser cookies (browser_cookie3 fallback)	Log into myfitnesspal.com in Chrome or Firefox via the default profile paths	Until browser session expires

Note: MyFitnessPal migrated their authentication to NextAuth, so the legacy form-POST authenticate_with_credentials path almost always fails for fresh logins. The Chromium auto-discovery path is the reliable way to get a session on macOS — just log in via any modern browser and the MCP picks it up automatically on the next call.

Installation

Option 1: Install from Source (Recommended)

# Clone the repository
git clone https://github.com/YOUR_USERNAME/myfitnesspal-mcp-python.git
cd myfitnesspal-mcp-python

# Create virtual environment (use python3.10+ on macOS/Linux)
python3 -m venv venv
# On macOS, you may need to specify version: python3.12 -m venv venv

# Activate virtual environment
source venv/bin/activate  # macOS/Linux
# On Windows: .\venv\Scripts\activate

# Upgrade pip (required for pyproject.toml support)
pip install --upgrade pip

# Install the package in editable mode
pip install -e .

Option 2: Install with pip (when published)

pip install mfp-mcp

Note: Option 2 requires the package to be published to PyPI. For now, use Option 1.

Verify Installation

After installation, verify the server can start:

# With venv activated
python -m mfp_mcp.server

You should see the server waiting for input (it communicates via stdio). Press Ctrl+C to stop.

To test authentication (optional):

MFP_USERNAME="your_email" MFP_PASSWORD="your_password" python -c "
from mfp_mcp.server import get_mfp_client
client = get_mfp_client()
print('Authentication successful!')
"

Configuration for Claude Desktop

Step 1: Locate Your Config File

OS	Config File Location
macOS	`~/Library/Application Support/Claude/claude_desktop_config.json`
Windows	`%APPDATA%\Claude\claude_desktop_config.json`

Step 2: Add the MCP Server Configuration

If the file doesn't exist, create it. Add or merge the following configuration:

Option A: With Encrypted Credentials (Enhanced Security)

Encrypt your credentials before storing them in the config file. See Encrypted Credentials for setup instructions.

⚠️ Security note: Encryption only provides meaningful protection if MFP_SECRET_KEY is stored separately from the config file (e.g., set in your shell profile or OS keychain). Storing the key alongside the encrypted values in the same config file means anyone who obtains the config can still decrypt your credentials.

macOS Example (with key set separately in your shell environment):

{
  "mcpServers": {
    "myfitnesspal": {
      "command": "/Users/yourname/myfitnesspal-mcp-python/venv/bin/python",
      "args": ["-m", "mfp_mcp.server"],
      "env": {
        "MFP_USERNAME": "gAAAAAB...<encrypted_email>",
        "MFP_PASSWORD": "gAAAAAB...<encrypted_password>"
      }
    }
  }
}

Option B: With Plain Credentials (No Browser Required)

macOS Example:

{
  "mcpServers": {
    "myfitnesspal": {
      "command": "/Users/yourname/myfitnesspal-mcp-python/venv/bin/python",
      "args": ["-m", "mfp_mcp.server"],
      "env": {
        "MFP_USERNAME": "your_email@example.com",
        "MFP_PASSWORD": "your_password"
      }
    }
  }
}

Windows Example:

{
  "mcpServers": {
    "myfitnesspal": {
      "command": "C:\\Users\\YourName\\myfitnesspal-mcp-python\\venv\\Scripts\\python.exe",
      "args": ["-m", "mfp_mcp.server"],
      "env": {
        "MFP_USERNAME": "your_email@example.com",
        "MFP_PASSWORD": "your_password"
      }
    }
  }
}

Option C: Without Credentials (Browser Cookie Fallback)

macOS Example:

{
  "mcpServers": {
    "myfitnesspal": {
      "command": "/Users/yourname/myfitnesspal-mcp-python/venv/bin/python",
      "args": ["-m", "mfp_mcp.server"]
    }
  }
}

⚠️ Important: Use full absolute paths to the Python executable in your virtual environment. Replace yourname/YourName with your actual username.

Step 3: Restart Claude Desktop

After saving the config file, completely quit and restart Claude Desktop for the changes to take effect.

Step 4: Verify Connection

In Claude Desktop, you should see a hammer icon (🔨) indicating MCP tools are available. Try asking:

"Show my MyFitnessPal diary for today"

Authentication Methods

The MCP server supports four authentication methods, tried in this order:

1. Environment Variables (Legacy)

Set MFP_USERNAME and MFP_PASSWORD in your Claude Desktop config's env section. You can store them as plain text or encrypted (see below).

⚠️ Note: MyFitnessPal migrated to a NextAuth backend, so the form-POST flow this method uses no longer produces a session cookie. Credential auth only succeeds while ~/.mfp_mcp/cookies.json still holds a valid session from a previous browser login — after that, this method silently falls through to the browser cookie paths below. Prefer the Chromium auto-discovery method on macOS.

"env": {
  "MFP_USERNAME": "your_email@example.com",
  "MFP_PASSWORD": "your_password"
}

Encrypted Credentials (Enhanced Security)

Instead of storing plain-text credentials, you can encrypt them using Fernet symmetric encryption from the cryptography library. The server decrypts them at runtime using MFP_SECRET_KEY.

⚠️ Important: For encryption to be meaningful, MFP_SECRET_KEY must be kept outside the Claude Desktop config file. The server resolves it in this order:

MFP_SECRET_KEY environment variable (shell profile, not the Claude config)

OS keychain — service mfp-mcp, account MFP_SECRET_KEY (recommended)

Step 1 — Generate and store the key in one command:

npm install
npm run store-key

store-key generates a Fernet-compatible key, stores it in the OS keychain (mfp-mcp / MFP_SECRET_KEY), and prints the key so you can use it in Step 2. See Key Management CLI for all available flags.

Step 2 — Encrypt your credentials:

from cryptography.fernet import Fernet

key = b"abc123XYZ...=="  # your key from Step 1
f = Fernet(key)

encrypted_user = f.encrypt(b"your_email@example.com").decode()
encrypted_pass = f.encrypt(b"your_password").decode()

print("MFP_USERNAME:", encrypted_user)
print("MFP_PASSWORD:", encrypted_pass)

Step 3 — Add only the encrypted values to your Claude Desktop config:

"env": {
  "MFP_USERNAME": "gAAAAAB...<encrypted>",
  "MFP_PASSWORD": "gAAAAAB...<encrypted>"
}

The key stays in the keychain — it never touches the config file.

Alternative: shell profile (simpler, still outside the Claude config):

# Add to ~/.zshrc or ~/.bashrc — do NOT put this in claude_desktop_config.json
export MFP_SECRET_KEY="abc123XYZ...=="

If MFP_SECRET_KEY is not found in the environment or keychain, the server treats MFP_USERNAME and MFP_PASSWORD as plain text (backward compatible).

2. Stored Session Cookies

After successful authentication, session cookies are saved to ~/.mfp_mcp/cookies.json. These persist for 30 days, so you won't need to re-authenticate frequently.

3. Chromium Browser Auto-Discovery (macOS)

If no credentials are provided and stored cookies are absent or expired, the server scans the macOS keychain for <Browser> Safe Storage entries to find every installed Chromium-based browser, then tries each one's cookies database until it finds a valid MyFitnessPal session token.

This works out of the box with Arc, Chrome, Edge, Brave, Vivaldi, Opera, Chromium, and any other Chromium-derived browser. You only need to be logged into myfitnesspal.com in one of them.

The first successful extraction is persisted to ~/.mfp_mcp/cookies.json, so subsequent calls skip the discovery step until the session expires.

You can also force a specific browser via the refresh_browser_cookies MCP tool:

refresh_browser_cookies(browser="arc")     # or "chrome", "edge", "brave", ...
refresh_browser_cookies(browser="auto")    # scan everything (default)
refresh_browser_cookies(browser="firefox") # via browser_cookie3

4. browser_cookie3 Fallback (Legacy)

A final fallback uses browser_cookie3 to read Chrome or Firefox cookies from the default profile paths. Useful on Linux/Windows or if the macOS auto-discovery path can't access your keychain.

Security Note on Credentials

Your MyFitnessPal credentials in the Claude Desktop config are stored locally on your machine. The config file is only readable by your user account. Options to harden this further:

1. Encrypt credentials + store the key in the OS keychain

The strongest option. The ciphertext lives in the config; the key never does. See Encrypted Credentials.

2. Encrypt credentials + export the key in your shell profile

Still separates key from ciphertext, though the key is on disk.

3. Storing `MFP_PASSWORD` in your MCP client

Storing MFP_PASSWORD in your MCP client config puts your MyFitnessPal password in plaintext on disk, readable by anything running as your user. It is convenient — the server can re-authenticate indefinitely — but it is a real tradeoff, not a formality.

4. Use browser cookies instead (no credentials stored in config at all)

Prefer browser-cookie auth if you would rather not store the password: log into myfitnesspal.com and the server reads the session from your browser. The cost is that MFP sessions expire, so you will occasionally need to log in again.

Files this server writes to ~/.mfp_mcp/ (directory mode 0700):

File	Contents	Mode
`cookies.json`	Session cookies — full account access, treat as a password	`0600`

Note that this server can modify your diary — adding food entries and updating goals, measurements, and water.

Usage Examples

Once configured, you can interact with your MyFitnessPal data through Claude:

Food Diary

"Show me what I ate today"
"Get my food diary for 2026-01-05"
"What meals did I log yesterday?"

Logging and Correcting Food

"Log a grilled chicken breast, 6 oz, for lunch"
"Add 2 cups of oatmeal to breakfast"

Track Weight Progress

"Show my weight history for the past 30 days"
"Log my weight as 232.5 pounds"
"What's my weight trend this month?"

Search Foods

"Search MyFitnessPal for chicken breast"
"Find nutrition info for Greek yogurt"
"Look up calories in a banana"

Check Goals vs Actual

"Compare my nutrition goals to what I actually ate today"
"Am I on track with my protein intake?"
"How many calories do I have left today?"

Exercise Log

"What exercises did I log today?"
"Show my workout from yesterday"

Nutrition Reports

"Show my calorie intake over the past week"
"What's my average protein intake this week?"
"Generate a nutrition report for January"

Key Management CLI

scripts/store-key.ts is a one-time setup tool that generates and stores MFP_SECRET_KEY in your OS keychain (macOS Keychain, Windows Credential Vault, Linux Secret Service). Node.js 18+ is required.

Prerequisites

npm install

Commands

Command	What it does
`npm run store-key`	Generate a new Fernet key and store it in the keychain
`npm run store-key -- --key <val>`	Store an existing key instead of generating one
`npm run store-key -- --overwrite`	Replace a key that is already stored
`npm run store-key -- --show`	Print the currently stored key
`npm run store-key -- --delete`	Remove the stored key from the keychain

Example output

✅ MFP_SECRET_KEY stored in OS keychain
   service : mfp-mcp
   account : MFP_SECRET_KEY
   source  : generated

Your key (use this to encrypt MFP_USERNAME / MFP_PASSWORD):

  abc123XYZ...==

Next — encrypt your credentials with Python:

  from cryptography.fernet import Fernet
  f = Fernet(b"abc123XYZ...==")
  print("MFP_USERNAME:", f.encrypt(b"your_email@example.com").decode())
  print("MFP_PASSWORD:", f.encrypt(b"your_password").decode())

Project Structure

myfitnesspal-mcp-python/
├── Dockerfile              # Container deployment
├── package.json            # Node tooling (store-key CLI)
├── tsconfig.json           # TypeScript config for scripts/
├── pyproject.toml          # Python package configuration
├── README.md               # This file
├── scripts/
│   └── store-key.ts        # One-time key management CLI
└── src/
    └── mfp_mcp/
        ├── __init__.py     # Package initialization
        └── server.py       # MCP server implementation

Development

Setup Development Environment

# Clone and enter directory
git clone https://github.com/YOUR_USERNAME/myfitnesspal-mcp-python.git
cd myfitnesspal-mcp-python

# Create virtual environment (Python 3.10+ required)
python3 -m venv venv
source venv/bin/activate

# Upgrade pip and install with dev dependencies
pip install --upgrade pip
pip install -e ".[dev]"

Run Tests

pytest

Code Formatting

black src/
isort src/
ruff check src/

Type Checking

mypy src/

Docker Deployment

⚠️ Note: Docker deployment requires mounting your browser's cookie database for authentication.

# Build the image
docker build -t mfp-mcp .

# Run with Chrome cookies mounted (Linux example)
docker run -it --rm \
  -v ~/.config/google-chrome:/root/.config/google-chrome:ro \
  mfp-mcp

Troubleshooting

"python: command not found" or wrong Python version

Problem: Python is not in PATH or you need to specify version.

Solutions:

On macOS/Linux, use python3 instead of python
Check your version: python3 --version (must be 3.10+)
If needed, install Python 3.12 via Homebrew: brew install python@3.12
Then create venv with: python3.12 -m venv venv

"pip install -e ." fails with "setup.py not found"

Problem: Your pip version is too old to support pyproject.toml builds.

Solution: Upgrade pip first:

pip install --upgrade pip
pip install -e .

"Failed to authenticate with MyFitnessPal"

Problem: The server can't authenticate with your credentials or read browser cookies.

Solutions:

Easiest (macOS): Log into myfitnesspal.com in any Chromium-based browser (Arc, Chrome, Edge, Brave, ...). The MCP will auto-discover the session on the next call.
Force a refresh: Call the refresh_browser_cookies tool — auto scans every browser, or pass a specific name (arc, chrome, edge, brave, vivaldi, opera, firefox).
If using credentials: Double-check your MFP_USERNAME and MFP_PASSWORD in the config. Note that the legacy form-login flow no longer works against MFP's NextAuth backend — credentials are only useful while ~/.mfp_mcp/cookies.json still holds a valid session.
Try logging out and back in to MyFitnessPal in your browser.
Clear ~/.mfp_mcp/cookies.json and let the auto-discovery rebuild it.
On macOS, the auto-discovery path reads each browser's Safe Storage password from your login keychain. On the very first run, macOS shows a dialog: " wants to use information stored in your keychain" — click Always Allow. If Claude Desktop is spawning the MCP headlessly in the background, this dialog can be easy to miss; if auto-discovery returns "no browser had a session", bring Claude Desktop to the foreground and retry so the prompt is visible. Once approved, the key is cached and the prompt won't repeat.

"No module named 'mfp_mcp'"

Problem: Package not installed or wrong Python environment.

Solutions:

Ensure you're using the correct Python from your virtual environment
Reinstall the package: pip install -e .

Verify the path in your Claude Desktop config points to the venv Python:

/path/to/project/venv/bin/python  # macOS/Linux
C:\path\to\project\venv\Scripts\python.exe  # Windows

Tools not appearing in Claude Desktop

Problem: MCP server not connecting.

Solutions:

Check the config file syntax (must be valid JSON - use a JSON validator)
Use absolute paths in the configuration (no ~ or relative paths)
Restart Claude Desktop completely (Cmd+Q on macOS, then relaunch)
Check Claude Desktop logs:
- macOS: ~/Library/Logs/Claude/
- Windows: %APPDATA%\Claude\logs\

Empty responses or no data

Problem: Authentication works but no data returned.

Solutions:

Verify you have data logged in MyFitnessPal for the requested date
Check the date format (YYYY-MM-DD)
Try a recent date where you know you have entries

Double parentheses in terminal prompt like "((venv) )"

Problem: VS Code/Cursor Python extension bug with venv prompt.

Solutions:

Update the Python extension in VS Code/Cursor

Or manually fix the venv activate script - change line ~70 in venv/bin/activate:

# Change from:
PS1="("'(venv) '") ${PS1:-}"
# To:
PS1="(venv) ${PS1:-}"

API Reference

mfp_get_diary

Get food diary for a specific date.

date (optional): YYYY-MM-DD format, defaults to today
response_format: "markdown" or "json"

mfp_search_food

Search the MyFitnessPal food database.

query (required): Search term
limit (optional): Max results (default 10, max 50)
response_format: "markdown" or "json"

mfp_get_food_details

Get detailed nutrition for a food item.

mfp_id (required): MyFitnessPal food ID from search results
response_format: "markdown" or "json"

mfp_add_food_to_diary

Add a food item to your diary for a specific meal and date.

mfp_id (required): MyFitnessPal food ID from search results (use mfp_search_food first)
meal (optional): Meal name - "Breakfast", "Lunch", "Dinner", or "Snacks" (default: "Breakfast")
date (optional): YYYY-MM-DD format (default: today)
quantity (optional): Number of servings (default: 1.0)
unit (optional): Unit/serving size description (e.g., "1 cup", "100g")

Example workflow:

Use mfp_search_food to find a food item and get its mfp_id
Use mfp_add_food_to_diary with the mfp_id to add it to your diary

mfp_get_measurements

Get body measurement history.

measurement (optional): "Weight", "Body Fat", "Waist", etc.
start_date (optional): YYYY-MM-DD (default 30 days ago)
end_date (optional): YYYY-MM-DD (default today)
response_format: "markdown" or "json"

mfp_set_measurement

Log a body measurement for today.

measurement (optional): Type (default "Weight")
value (required): Numeric value

mfp_get_exercises

Get exercise log for a date.

date (optional): YYYY-MM-DD (default today)
response_format: "markdown" or "json"

mfp_get_goals

Get daily nutrition goals.

date (optional): YYYY-MM-DD (default today)
response_format: "markdown" or "json"

mfp_set_goals

Update nutrition goals.

calories (optional): Daily calorie goal
protein (optional): Daily protein in grams
carbohydrates (optional): Daily carbs in grams
fat (optional): Daily fat in grams

mfp_get_water

Get water intake for a date.

date (optional): YYYY-MM-DD (default today)

mfp_set_water

Log water intake for a date.

cups (required): Number of cups of water (e.g., 2.5 for 2.5 cups). Note: MyFitnessPal uses cups as the unit (1 cup = ~237ml)
date (optional): YYYY-MM-DD format (default: today)

mfp_get_report

Get nutrition report over a date range.

report_name (optional): "Net Calories", "Protein", "Fat", "Carbs"
start_date (optional): YYYY-MM-DD (default 7 days ago)
end_date (optional): YYYY-MM-DD (default today)
response_format: "markdown" or "json"

Security & Privacy

Encrypted Credentials: Credentials can be stored as Fernet-encrypted ciphertext in your config. MFP_SECRET_KEY is resolved at runtime from the environment variable first, then the OS keychain (mfp-mcp / MFP_SECRET_KEY). See Encrypted Credentials for setup.
OS Keychain: Storing MFP_SECRET_KEY in the native keychain (macOS Keychain, Windows Credential Vault, Linux Secret Service) means the decryption key never touches the config file or any backup.
Plain Credentials: If MFP_SECRET_KEY is absent from both environment and keychain, MFP_USERNAME and MFP_PASSWORD are used as-is (backward compatible).
Session Cookies: After successful authentication, session cookies are cached in ~/.mfp_mcp/cookies.json (restricted permissions) for 30 days.
Browser Cookies: As a fallback, the server can read your browser cookies to authenticate with MyFitnessPal.
Local Only: The server runs locally on your machine via stdio transport. No data is sent to any third-party servers.
No External Transmission: Your MyFitnessPal data is only transmitted between your computer and MyFitnessPal's servers (myfitnesspal.com).

License

MIT License - See LICENSE file for details.

Acknowledgments

python-myfitnesspal - The underlying library for MyFitnessPal access
MCP Python SDK - Model Context Protocol framework
Anthropic - Claude and the MCP specification

Name		Name	Last commit message	Last commit date
Latest commit History 18 Commits
.github		.github
scripts		scripts
src/mfp_mcp		src/mfp_mcp
tests		tests
.gitignore		.gitignore
Dockerfile		Dockerfile
LICENSE		LICENSE
README.md		README.md
package.json		package.json
pyproject.toml		pyproject.toml
tokens.json.example		tokens.json.example
tsconfig.json		tsconfig.json

Folders and files

Latest commit

History

Repository files navigation

MyFitnessPal MCP Server

Features

How diary writes work

Prerequisites

Authentication Options

Installation

Option 1: Install from Source (Recommended)

Option 2: Install with pip (when published)

Verify Installation

Configuration for Claude Desktop

Step 1: Locate Your Config File

Step 2: Add the MCP Server Configuration

Option A: With Encrypted Credentials (Enhanced Security)

Option B: With Plain Credentials (No Browser Required)

Option C: Without Credentials (Browser Cookie Fallback)

Step 3: Restart Claude Desktop

Step 4: Verify Connection

Authentication Methods

1. Environment Variables (Legacy)

Encrypted Credentials (Enhanced Security)

2. Stored Session Cookies

3. Chromium Browser Auto-Discovery (macOS)

4. browser_cookie3 Fallback (Legacy)

Security Note on Credentials

1. Encrypt credentials + store the key in the OS keychain

2. Encrypt credentials + export the key in your shell profile

3. Storing MFP_PASSWORD in your MCP client

4. Use browser cookies instead (no credentials stored in config at all)

Usage Examples

Food Diary

Logging and Correcting Food

Track Weight Progress

Search Foods

Check Goals vs Actual

Exercise Log

Nutrition Reports

Key Management CLI

Prerequisites

Commands

Example output

Project Structure

Development

Setup Development Environment

Run Tests

Code Formatting

Type Checking

Docker Deployment

Troubleshooting

"python: command not found" or wrong Python version

"pip install -e ." fails with "setup.py not found"

"Failed to authenticate with MyFitnessPal"

"No module named 'mfp_mcp'"

Tools not appearing in Claude Desktop

Empty responses or no data

Double parentheses in terminal prompt like "((venv) )"

API Reference

mfp_get_diary

mfp_search_food

mfp_get_food_details

mfp_add_food_to_diary

mfp_get_measurements

mfp_set_measurement

mfp_get_exercises

mfp_get_goals

mfp_set_goals

mfp_get_water

mfp_set_water

mfp_get_report

Security & Privacy

License

Acknowledgments

About

Resources

Stars

Watchers

Forks

3. Storing `MFP_PASSWORD` in your MCP client