BaseClaw

Your fantasy baseball team, managed by AI.

Ask Claude about your Yahoo Fantasy Baseball league in plain English. Get instant advice on trades, lineups, waiver pickups, and strategy — powered by your actual league data.

What can you ask?

Daily management

• "Set my lineup for today — bench anyone without a game"

• "Who on my roster is injured? Any IL moves I should make?"

• "What are the best streaming pitchers for this week?"

• "Show me my week planner — who has off days?"

• "Check for weather risks in today's games"

Waiver wire

• "Who should I pick up this week to help my batting average?"

• "Best available closers on the wire"

• "Run the waiver optimizer — what's the best add/drop sequence for my team?"

• "How much FAAB should I bid on this player?"

• "Who are the most added players across Yahoo right now?"

• "Show me players on waivers that clear tomorrow"

Trades

• "Find me a trade partner for my excess pitching"

• "Evaluate this trade — am I giving up too much?"

• "Who on other teams would fill my HR gap?"

• "Run the full trade pipeline — find complementary deals across the league"

• "Show me my pending trade offers"

Strategy

• "What categories should I punt?"

• "Where do I rank in each stat category for the full season?"

• "What's my playoff probability right now?"

• "Give me a category-by-category game plan for this week's matchup"

• "Am I on pace to make the playoffs?"

Advanced analytics

• "Who's leading the league in exit velocity?" (Statcast leaderboards for any advanced metric)

• "Which hitters are gaining bat speed this season? Show me bat tracking breakouts"

• "Any pitchers making significant pitch mix changes?"

• "Which teams are dealing with travel fatigue today?"

• "How confident should I be in this player's projections right now?"

• "How much FAAB should I bid on this player?" (now uses Kelly criterion math)

Prospect & intel

• "Top 20 prospects closest to a call-up"

• "Deep dive on this prospect — MiLB stats, scouting grades, call-up probability"

• "Which prospects stashed on other teams are worth trading for?"

• "What's the latest news on [player]?"

• "Show me regression candidates — who's due for a correction?"

• "Full Statcast report on [player]"

• "What's Reddit saying about fantasy baseball today?"

Season checkpoints

• "Give me the Monday morning briefing"

• "End-of-week recap — how'd my matchup go?"

• "Monthly checkpoint — where do I stand and what should I do?"

• "Show me category trends over the last month"

• "Head-to-head record vs each manager all-time"

Related MCP server: Yahoo Fantasy Baseball MCP Server

Quick start (10 minutes)

Prerequisites: Docker Desktop and a Yahoo Developer app with Fantasy Sports read permissions.

curl -fsSL https://raw.githubusercontent.com/jweingardt12/baseclaw/main/scripts/install.sh | bash

The installer pulls the Docker image, prompts for your Yahoo API credentials, starts the container, runs OAuth discovery, and configures your MCP client.

First query: Open Claude and ask "Show me my roster". If you see your players, you're all set.

1. Get Yahoo API credentials — Go to developer.yahoo.com/apps/create, create an app with Fantasy Sports read permissions and oob as the redirect URI.

2. Configure and run:

git clone https://github.com/jweingardt12/baseclaw.git
cd baseclaw
cp docker-compose.example.yml docker-compose.yml
cp .env.example .env
# Edit .env — set YAHOO_CONSUMER_KEY and YAHOO_CONSUMER_SECRET
mkdir -p config data
docker compose up -d

3. Discover your league — triggers Yahoo OAuth and finds your league/team IDs:

./yf discover

Copy the printed LEAGUE_ID and TEAM_ID into .env, then docker compose up -d to restart.

4. Connect to Claude — see the next section for your AI client's config.

Connect to your AI client

Add BaseClaw to your AI client with one JSON block. Copy the config for your client below.

Edit claude_desktop_config.json (macOS ~/Library/Application Support/Claude/claude_desktop_config.json | Windows %APPDATA%\Claude\claude_desktop_config.json):

{
  "mcpServers": {
    "baseclaw": {
      "command": "docker",
      "args": ["exec", "-i", "baseclaw", "node", "/app/mcp-apps/dist/main.js", "--stdio"]
    }
  }
}

Add to .mcp.json in your project root (or ~/.claude/.mcp.json for global):

{
  "mcpServers": {
    "baseclaw": {
      "command": "docker",
      "args": ["exec", "-i", "baseclaw", "node", "/app/mcp-apps/dist/main.js", "--stdio"]
    }
  }
}

Add to .vscode/mcp.json in your workspace:

{
  "servers": {
    "baseclaw": {
      "command": "docker",
      "args": ["exec", "-i", "baseclaw", "node", "/app/mcp-apps/dist/main.js", "--stdio"]
    }
  }
}

Add to .cursor/mcp.json in your project root:

{
  "mcpServers": {
    "baseclaw": {
      "command": "docker",
      "args": ["exec", "-i", "baseclaw", "node", "/app/mcp-apps/dist/main.js", "--stdio"]
    }
  }
}

Note: Cursor has a 40-tool limit per MCP server. BaseClaw exposes 130 tools, so Cursor will only load the first 40. Core roster, standings, and valuation tools load first. Advanced analytics, prospect, and workflow tools may be unavailable.

Open Cline settings > MCP Servers > Add, then paste:

{
  "mcpServers": {
    "baseclaw": {
      "command": "docker",
      "args": ["exec", "-i", "baseclaw", "node", "/app/mcp-apps/dist/main.js", "--stdio"]
    }
  }
}

Add to ~/.codeium/windsurf/mcp_config.json:

{
  "mcpServers": {
    "baseclaw": {
      "command": "docker",
      "args": ["exec", "-i", "baseclaw", "node", "/app/mcp-apps/dist/main.js", "--stdio"]
    }
  }
}

Claude.ai needs the server reachable over HTTPS. Set MCP_SERVER_URL and MCP_AUTH_PASSWORD in .env, put a reverse proxy (Caddy, nginx, Cloudflare Tunnel, Tailscale Funnel, Pangolin) in front of port 4951, and rebuild with docker compose up -d.

In Claude.ai: Settings > Integrations > Add MCP Server > enter https://your-domain.com/mcp. You'll be prompted for your password. The MCP server implements OAuth 2.1 — no third-party auth provider needed. Auth tokens persist across container restarts (stored in the mounted config/ volume) and access tokens last 7 days with 30-day refresh tokens, so Claude.ai stays connected through deploys and resets.

Automate with OpenClaw

Connect BaseClaw to OpenClaw and it runs your team autonomously. Lineups get set every morning, injuries get monitored, opponents get scouted, waiver pickups get found. You check in when you want to.

cd openclaw && bash install.sh

The installer copies workspace files, configures the OpenClaw Gateway, registers 8 cron jobs, installs 3 event hooks, and sets up 4 Lobster workflows with human-in-the-loop approval gates.

What gets installed

Cron schedule

All times Eastern, configurable in openclaw/cron/jobs.json:

Jobs sharing a session (baseclaw-daily, baseclaw-weekly) retain context across runs — the morning briefing knows what the pre-lock check found.

Lobster workflows

Multi-step pipelines with human-in-the-loop approval gates. Run from chat: "run the waiver-claim workflow."

Webhook endpoints

BaseClaw exposes OpenClaw-compatible webhook endpoints for external event triggers. Set WEBHOOK_TOKEN in .env to enable.

Auth via Authorization: Bearer <token> or x-openclaw-token: <token> header. Rate-limited after 5 failed attempts.

Autonomy levels

Set AGENT_AUTONOMY in .env. The agent auto-detects your league configuration — FAAB vs. priority waivers, scoring format, stat categories — and skips irrelevant tools.

The AGENTS.md file defines the agent's identity and behavior:

• League awareness — Learns your format, team count, scoring categories, and roster rules on first session

• Strategy principles — Target close categories, concede lost causes, stream pitchers with multi-factor scoring, monitor closers, trade from surplus

• Regression awareness — Check regression scores before any add/drop/trade; buy-low signals prevent panic-dropping slumping stars, sell-high signals maximize trade value

• Trade intelligence — Surplus value analysis, category fit over raw value, consolidation premium, catcher scarcity, rival blocking (never help teams within 2 standings positions)

• Prospect news intelligence — Signal classification from 16 news sources with Bayesian call-up probability blending. Injury news, reassignments, and bullish reports automatically adjust stash recommendations and trade targets

• Statcast decision rules — Research-backed thresholds for barrel rate, exit velocity, sprint speed, xwOBA gaps, ERA vs SIERA, Stuff+, velocity changes. Player cards show Savant-style percentile bars for league rankings across all advanced metrics

• Sample size awareness — Every tool and UI view flags low-confidence stats early in the season. Bayesian stabilization thresholds (200 PA batters, 117 IP pitchers) drive confidence labels so agents and users know when to trust stats vs. projections

• Season phases — Early (build depth, stream aggressively), mid (trade for balance, buy low), late (playoff positioning)

• Decision trees — Injury response pipelines, trade search with surplus value evaluation, waiver deadline claim chains

• FAAB management — Kelly criterion bid sizing with posterior variance from Bayesian model, competition shading, category scarcity bonus, season phase multipliers, contender detection

• League intelligence — Comprehensive league intel with multi-layer power rankings (adjusted z-scores blending projections + statcast quality + regression signals + hot/cold trends), top performers across all teams with quality/regression flags, team profiles with trade fit analysis, and z-upside detection. Pre-season uses 70% z-rank + 30% quality rank; in-season shifts to 50% z-rank + 35% standings + 15% quality

• Competitive intelligence — Track rival activity, react to opponent moves, standings-aware trade blocking

• Token efficiency — Workflow tools over individual tools, concise reports

Customize AGENTS.md to adjust strategy, risk tolerance, or reporting style.

How it works

BaseClaw pulls data from three sources: Yahoo Fantasy API (your roster, standings, matchups, free agents, transactions), FanGraphs (consensus projections from Steamer + ZiPS + Depth Charts), and Baseball Savant (Statcast metrics, Stuff+, pitch arsenal data, bat tracking). Prospect intelligence comes from MLB Stats API plus 16 news sources with Bayesian signal classification.

Player valuations use FVARz z-scores — volume-weighted rate stats so part-timers don't inflate rankings. Projections are park-factor adjusted and blended with live stats via Bayesian conjugate updating — each stat uses its own stabilization point (K-rate stabilizes at 60 PA, batting average at 400 PA), producing mathematically optimal shrinkage rates per player per stat instead of one-size-fits-all date thresholds. Raw z-scores are then adjusted into adjusted z-scores that blend in Statcast quality tier (+1.5 for elite, +0.75 for strong), regression signals (buy-low/sell-high from the 14-signal engine), and hot/cold momentum — so rankings reflect true talent, not just projections. All recommendations use adjusted z-scores — waiver picks, streaming pitchers, and trade surplus calculations factor in Statcast quality, regression signals, and momentum instead of raw projection z-scores. FAAB bidding uses Kelly criterion math for optimal bid sizing. Breakout detection uses bat tracking (bat speed, fast-swing rate, squared-up rate) and pitch mix screening (arsenal changes cross-referenced with effectiveness metrics). Travel fatigue scoring based on a peer-reviewed PNAS study of 46,535 games feeds into streaming and lineup decisions. Live game info — game times, live scores, and inning status from MLB Stats API appear on roster and free agent views. Free agents include toggleable advanced stat views (Overview, Statcast, Process, Value) with data from Baseball Savant and FanGraphs. Every tool response includes agent steering — strategic assessments and cross-tool next steps so the AI agent can guide users toward optimal decisions without being asked. Sample size awareness is built into the full stack — PA/IP counts with confidence labels (derived from Bayesian stabilization points) appear on every player in tool text, roster views, and free agent views, with automatic warnings when most players have low samples early in the season. Player cards include Savant-style percentile bar rankings showing where a player ranks in the league across xwOBA, xBA, exit velo, barrel%, hard hit%, K%, BB%, whiff%, chase rate, and sprint speed. Statcast leaderboards let you query MLB leaders for any advanced metric (exit velocity, barrel rate, xwOBA, sprint speed, bat speed, and more).

┌─────────────────────────────────────────────────┐
│  Docker Container (baseclaw)                     │
│                                                 │
│  ┌──────────────────┐  ┌─────────────────────┐  │
│  │  Python API       │  │  TypeScript MCP     │  │
│  │  (Flask :8766)    │──│  (Express :4951)    │  │
│  │                   │  │                     │  │
│  │  yahoo_fantasy_api│  │  MCP SDK + ext-apps │  │
│  │  pybaseball       │  │  130 tool defs      │  │
│  │  MLB-StatsAPI     │  │  4 apps / 80+ views  │  │
│  │  Playwright       │  │  11 workflow tools  │  │
│  │  CacheManager     │  │  11 tool files      │  │
│  └──────────────────┘  └─────────────────────┘  │
└─────────────────────────────────────────────────┘
         │                        │
    Yahoo Fantasy API        MCP Clients (stdio/HTTP)
    Yahoo Website (browser)  ├── Claude Code / Desktop
    FanGraphs (projections)  ├── Claude.ai (remote)
    Baseball Savant (intel)  ├── Agent orchestrators
                             │    (OpenClaw, cron-scheduled)
                             └── Webhooks (/hooks/wake, /hooks/agent)

• Read operations: Yahoo Fantasy OAuth API (fast, reliable)

• Write operations: Playwright browser automation against Yahoo Fantasy website (Yahoo's API no longer grants write scope to new developer apps)

• Valuations: FVARz z-scores with per-category projection blending (Steamer + ZiPS + Depth Charts), park-factor adjusted, Bayesian conjugate updating for in-season blending (per-stat stabilization points replace date-based decay), conditional catcher premium. Adjusted z-scores blend raw projections with Statcast quality tier, regression signals, and momentum for rankings that reflect true talent. ILP lineup optimizer (scipy) with greedy fallback. Surplus value trade analysis, Kelly criterion FAAB bidding, multi-factor streaming with Stuff+ and travel fatigue, research-backed punt viability

• Intelligence: Statcast data, SIERA, Stuff+/Location+/Pitching+, platoon splits, arsenal changes, bat tracking (bat speed, fast-swing rate, squared-up rate, blasts), batted ball profiles, historical comparisons, research-calibrated regression scoring (-100 to +100) with 14 signals across hitters and pitchers. Bat tracking breakout detector flags hitters gaining bat speed before stats reflect it. League-wide pitch mix screener surfaces pitchers making significant arsenal changes cross-referenced with effectiveness metrics. Travel fatigue scoring (PNAS-backed) factors timezone changes, schedule density, and eastward travel penalties into streaming and lineup decisions. Qualitative intelligence layer enriches every recommendation with injury severity, dealbreaker filtering, and context lines. Prospect news sentiment layer blends qualitative signals from 16 news sources with stat-based call-up probabilities using Bayesian updating. Cached with configurable TTL

• MCP Apps: Interactive inline UIs (React 19 + shadcn/ui + custom SVG charts) rendered in Claude via @modelcontextprotocol/ext-apps. Mobile-first card layouts for roster and free agents with inline stats, quality indicators, and matchup color-coding. Category comparison bars in matchup views. Morning briefing with rich waiver targets showing tier/z-score/context/rationale. Player reports with game logs, career year-by-year, news links, Statcast metrics, z-score rankings. Decision views surface context (warnings, news, trends) with action buttons. Navigation history with back button support

• Workflow tools: 11 aggregated endpoints that bundle 5-7+ API calls server-side to keep tool call counts low

Under the hood:

1. Yahoo Fantasy API — Your roster, standings, matchups, free agents, transactions, and league settings come from Yahoo's OAuth API in real time. Every tool call fetches current data, not cached snapshots.

2. Analytics engine — Z-score valuations using the FVARz method (volume-weighted rate stats so part-timers don't inflate rankings). Projections are consensus blends (Steamer + ZiPS + Depth Charts) with per-category weighting, park-factor adjusted, and blended with live stats via Bayesian conjugate updating — each stat uses its own research-backed stabilization point (K-rate stabilizes at 60 PA, batting average at 400 PA, ERA at 600 BF) to produce mathematically optimal shrinkage rates per player per stat. Adjusted z-scores then layer in Statcast quality tier (elite/strong/average/below/poor), regression signals from the 14-signal engine, and hot/cold momentum — so rankings, comparisons, and trade evaluations reflect true talent rather than just projections. Conditional catcher premium (2.0 for 2C leagues, 1.0 for 1C, auto-detected from league settings). ILP lineup optimizer (scipy) finds globally optimal player-to-slot assignments with greedy fallback. The engine also runs category gap analysis, research-backed punt strategy with viability ratings, matchup classification with category-specific volatility thresholds, trade evaluation with surplus value analysis (roster spot tax, category fit, consolidation premium, catcher scarcity, rival warnings), Kelly criterion FAAB bidding (half-Kelly with competition shading from ownership%, category scarcity bonus, posterior variance from Bayesian model), multi-factor streaming pitcher scoring (pitcher quality + park factor + opponent quality + Stuff+ + opponent travel fatigue), and a trade finder that scans every team for complementary deals. Every tool response includes agent steering — strategic assessments and cross-tool next-step recommendations appended to results so the AI agent proactively guides users toward optimal decisions.

3. Player intelligence — Every player surface pulls Statcast data (xwOBA, xERA, exit velocity, barrel rate, percentile rankings, pitch arsenal), Stuff+/Location+/Pitching+ metrics, platoon splits, historical comparisons, arsenal change detection, 7/14/30-day trend splits, FanGraphs plate discipline (SIERA, K-BB%, HR/FB%), Reddit sentiment from r/fantasybaseball, and MLB transaction alerts. A research-calibrated regression engine scores every qualified player from -100 (strong sell-high) to +100 (strong buy-low) using 6 hitter signals (xwOBA gap, career-regressed BABIP, HR/FB vs barrels, plate discipline via O-Swing%, hard-hit divergence, sprint speed) and 8 pitcher signals (ERA vs SIERA, K-BB% vs ERA, ERA vs xERA, K-rate adjusted BABIP, LOB%, HR/FB%, velocity trend, Stuff+ confidence modifier) — each with individual contribution breakdowns and confidence levels. A qualitative intelligence layer enriches every recommendation with real-world context: injury severity classification (MINOR/MODERATE/SEVERE), dealbreaker detection (DFA'd, released, suspended, or retired players auto-filtered from recommendations), and one-line context summaries attached to every player surface. API calls are cached with configurable TTL. Before the season starts, Savant data falls back to the prior year so intel surfaces stay populated during spring training.

4. Browser automation — Write operations (add, drop, trade, lineup changes) use Playwright to automate the Yahoo Fantasy website directly, since Yahoo's API no longer grants write scope to new developer apps. Read operations still use the fast OAuth API.

5. Prospect news intelligence — A qualitative news layer that ingests prospect-specific articles from 16 sources (via the news aggregator) plus MLB Stats API transactions, classifies call-up signals using 50+ keyword patterns (bullish: "called up", "expected to join", "likely for Opening Day"; bearish: "optioned", "assigned to minors", "placed on IL"), scores them with Bayesian updating (source tier weighting + exponential time decay), and blends the result with stat-based call-up probabilities (65% stat / 35% news, capped at +/-30pp). Event deduplication prevents multiple articles about the same roster move from over-compounding. Every prospect tool — rankings, stash advisor, trade targets, comparisons — reflects the news-adjusted probabilities.

6. Inline UI apps — Four single-file HTML apps (React 19 + shadcn/ui + custom SVG charts) render interactive UIs directly inside Claude's chat via MCP Apps. 80+ views cover rosters, matchups, trades, waivers, game logs, career stats, player reports with Statcast percentiles, and league history. Player names are tappable throughout — tap any name to drill into a full player report with game log, career stats, news with source links, advanced metrics, and z-score rankings. Decision views (waivers, streaming, trades) surface context chips (warnings, news, ownership trends) alongside action buttons to execute moves directly.

7. Workflow tools — Eleven aggregated tools (yahoo_morning_briefing, yahoo_game_day_manager, yahoo_trade_pipeline, etc.) each bundle 5-7+ API calls server-side so the agent gets everything it needs in one shot. A full daily routine takes 2-3 tool calls instead of 15+.

Built with: yahoo_fantasy_api | pybaseball | MLB-StatsAPI | MCP Apps (ext-apps) | Playwright | MCP SDK

Environment variables:

The game key changes each MLB season (e.g., 469 for 2026). Run ./yf discover to find your league and team IDs automatically.

Optional config files:

• config/league-history.json — Map of year to league key for historical records

• config/draft-cheatsheet.json — Draft strategy and targets (see .example)

• data/player-rankings-YYYY.json — Hand-curated player rankings (fallback for valuations engine)

Project files:

baseclaw/
├── docker-compose.yml
├── Dockerfile
├── .env.example
├── yf                              # CLI helper script (with --json and api modes)
├── SKILL.md                        # ClawHub manifest (install metadata + overview)
├── AGENTS.md                       # Agent persona for autonomous GM
├── openclaw/                       # OpenClaw integration package
│   ├── install.sh                  # OpenClaw workspace installer
│   ├── AGENTS.md                   # Agent operational framework
│   ├── SOUL.md                     # Agent persona and identity
│   ├── TOOLS.md                    # MCP tool conventions and profiles
│   ├── HEARTBEAT.md                # Proactive check checklist
│   ├── MEMORY.md                   # Persistent memory template
│   ├── USER.md                     # User preferences
│   ├── config/
│   │   ├── openclaw.json           # Gateway configuration template
│   │   └── mcporter.json           # MCP server registration
│   ├── cron/
│   │   └── jobs.json               # 8 scheduled cron jobs
│   ├── workflows/
│   │   ├── waiver-claim.lobster    # Waiver claim pipeline with approval
│   │   ├── trade-proposal.lobster  # Trade proposal pipeline with approval
│   │   ├── roster-cleanup.lobster  # Roster cleanup pipeline with approval
│   │   └── morning-routine.lobster # Daily briefing + lineup
│   └── hooks/
│       ├── baseclaw-roster-alerts/ # Push notifications for injuries/trades
│       ├── baseclaw-memory-flush/  # Pre-compaction memory persistence
│       └── baseclaw-health/        # Gateway startup health check
├── config/
│   ├── yahoo_oauth.json            # OAuth credentials + tokens (gitignored, auto-generated from env vars)
│   ├── yahoo_session.json          # Browser session (gitignored, for write ops)
│   ├── auth-state.json             # MCP OAuth tokens + client registrations (gitignored, auto-managed)
│   ├── league-history.json         # Optional: historical league keys
│   └── draft-cheatsheet.json       # Optional: draft strategy
├── data/
│   ├── player-rankings-YYYY.json   # Optional: curated rankings
│   ├── projections_hitters.csv     # Auto-fetched consensus projections (gitignored)
│   └── projections_pitchers.csv    # Auto-fetched consensus projections (gitignored)
├── scripts/
│   ├── install.sh                   # One-command installer (curl | bash)
│   ├── api-server.py               # Flask API server (~120 endpoints, workflow + strategy)
│   ├── yahoo-fantasy.py            # League management
│   ├── season-manager.py           # In-season management + strategy engine
│   ├── draft-assistant.py          # Draft day tool
│   ├── yahoo_browser.py            # Playwright browser automation
│   ├── history.py                  # Historical records
│   ├── intel.py                    # Fantasy intelligence (Statcast, splits, arsenal, caching)
│   ├── news.py                     # 16-source news aggregator (RSS, Reddit, Bluesky)
│   ├── prospects.py                # Prospect intelligence (MiLB stats, call-up probability, stash advisor)
│   ├── prospect_news.py            # Prospect news sentiment (signal classification, Bayesian updating)
│   ├── valuations.py               # Z-score valuation engine (consensus, park factors, ROS tracking)
│   ├── snapshot.py                 # Weekly state snapshots (projections, roster, standings)
│   ├── backtest.py                 # Backtest replay engine (lineup efficiency vs actuals)
│   ├── mlb-data.py                 # MLB Stats API helper
│   ├── mlb_id_cache.py             # Player name → MLB ID mapping
│   ├── shared.py                   # Shared utilities (team key detection, name normalization)
│   ├── setup-openclaw.sh           # OpenClaw integration setup (mcporter + skill + cron)
│   └── remove-openclaw.sh          # OpenClaw integration removal
└── mcp-apps/                       # TypeScript MCP server + UI apps
    ├── server.ts                   # MCP server setup + tool registration
    ├── main.ts                     # Entry point (stdio + HTTP + webhooks)
    ├── assets/logo-128.png         # Server icon (pixel-art baseball)
    ├── src/tools/                  # 12 tool files, 129 MCP tools
    ├── src/webhooks.ts             # Native webhook endpoints (/hooks/wake, /hooks/agent)
    ├── src/api/                    # Python API client + type definitions
    └── ui/                         # 4 inline HTML apps, 75+ views (React + Plex UI + Recharts)

CLI commands:

The ./yf helper script provides direct CLI access to all functionality:

./yf <command> [args]
./yf --json <command> [args]   # JSON output mode for programmatic use
./yf api <endpoint> [params]   # Direct API calls (e.g., yf api /api/rankings)
./yf api-list                  # List all available API endpoints

130 tools across 12 tool files. Default profile loads ~26 tools; set MCP_TOOLSET to load more (see env vars). Core dashboards and action tools (20) render interactive UI in Claude; the rest return text.

Roster Management (16 tools)

League & Standings (11 tools)

In-Season Management (27 tools)

Valuations (7 tools)

Intelligence (11 tools)

Prospect Intelligence (11 tools)

Analytics & Strategy (4 tools)

MLB Data (9 tools)

League History (8 tools, requires ENABLE_HISTORY=true)

Workflows (11 tools)

Aggregated tools that bundle 5-7+ API calls server-side so the agent gets a complete picture in one shot.

Meta (2 tools)

Write operations (12 tools, requires ENABLE_WRITE_OPS=true)

yahoo_add, yahoo_drop, yahoo_swap, yahoo_waiver_claim, yahoo_set_lineup, yahoo_propose_trade, yahoo_accept_trade, yahoo_reject_trade, yahoo_browser_status, yahoo_change_team_name, yahoo_change_team_logo, yahoo_auto_lineup

Write operations (optional)

To let Claude make roster moves (add, drop, trade, set lineup), set ENABLE_WRITE_OPS=true in .env, rebuild with docker compose up -d, and set up a browser session:

./yf browser-login

Log into Yahoo in the browser that opens. The session saves to config/yahoo_session.json and lasts 2-4 weeks. When ENABLE_WRITE_OPS=false (default), all 12 write tools are hidden entirely.

Uninstall

curl -fsSL https://raw.githubusercontent.com/jweingardt12/baseclaw/main/scripts/install.sh | bash -s -- --uninstall