Koskamo

SportIQ MCP

An open-source MCP server providing over 25 AI-callable tools for sports analysis, including Dream11 team building for IPL, F1 pit strategy modeling, and FIFA World Cup 2026 bracket simulation. It supports multiple data sources with keyless fallbacks and works with Claude, Cursor, and Zed via hosted or local installation.

Endpoint and access

No sign-in to connect and list tools. Individual tools may still need a vendor account, credentials, or permissions; check the documented prerequisites.

SportIQ MCP logo, by Ninjabeam20Community listingStreamable HTTPNo sign-inEndpoint checked 2026-11-07Published by Ninjabeam20
MCP endpoint (Streamable HTTP)
https://sportiq.utkarshgupta.org/mcp
Vendor documentation

What its tools do

46 tools, grouped by the hints the server advertises. Hints are self-declared, not verified behavior.

46 of 46 have a description · 46 of 46 declare behavior hints · 42 of 42 with parameters document them all

Checks and signals

Each line is separate evidence, not a trust score.

  • Passed Endpoint answered the live check ·
  • Availability 1 of 1 checks passed in 30 days

What you can do with it

  • Build Dream11 fantasy cricket teams with captain recommendations
  • Analyze F1 race pace and predict pit strategy
  • Simulate FIFA World Cup 2026 brackets using Monte Carlo methods
  • Retrieve live cricket scores and football standings

Source and maintenance

Community listingRegistry 0.4.0
Maintenance checked

Protocol and capabilities

Server
sportiq 0.4.0
MCP protocol negotiated in check
2025-11-25
Tools
46 advertised
Resources
7 advertised
Resource templates
0 advertised
Prompts
10 advertised
Server-advertised capabilities
{
  "tools": {
    "listChanged": false
  },
  "prompts": {
    "listChanged": false
  },
  "resources": {
    "subscribe": false,
    "listChanged": false
  },
  "experimental": {}
}

Tools

46 advertised

sportiq_health
Advertised by the server during the last successful anonymous check.
Advertised read-onlyOpen-world

Report cache backend, per-adapter healthcheck, and quota status. Returns: HealthReport-shaped dict with `cache_backend`, `cache_ok`, `adapters` (per-source ok/detail), and `quotas`.

sportiq_health input schema
{
  "type": "object",
  "title": "sportiq_healthArguments",
  "properties": {}
}
sportiq_health output schema
{
  "type": "object",
  "title": "Envelope",
  "properties": {
    "data": {
      "anyOf": [
        {
          "type": "object",
          "additionalProperties": true
        },
        {
          "type": "null"
        }
      ],
      "title": "Data",
      "default": null
    },
    "meta": {
      "anyOf": [
        {
          "type": "object",
          "additionalProperties": true
        },
        {
          "type": "null"
        }
      ],
      "title": "Meta",
      "default": null
    },
    "error": {
      "anyOf": [
        {
          "type": "object",
          "additionalProperties": true
        },
        {
          "type": "null"
        }
      ],
      "title": "Error",
      "default": null
    }
  }
}
sportiq_health annotations
{
  "readOnlyHint": true,
  "openWorldHint": true,
  "idempotentHint": true,
  "destructiveHint": false
}
football_get_groups
Advertised by the server during the last successful anonymous check.
Advertised read-onlyOpen-world

Return the FIFA World Cup 2026 group draw and advancement format. Returns: data.groups: {group_letter: [4 team codes]} for all 12 groups. data.format: 48-team / 12-group / top-2 + 8-best-thirds rule. data.teams: team-code -> {name, fifa_code} metadata. meta.source: adapter that served the data.

football_get_groups input schema
{
  "type": "object",
  "title": "football_get_groupsArguments",
  "properties": {}
}
football_get_groups output schema
{
  "type": "object",
  "title": "Envelope",
  "properties": {
    "data": {
      "anyOf": [
        {
          "type": "object",
          "additionalProperties": true
        },
        {
          "type": "null"
        }
      ],
      "title": "Data",
      "default": null
    },
    "meta": {
      "anyOf": [
        {
          "type": "object",
          "additionalProperties": true
        },
        {
          "type": "null"
        }
      ],
      "title": "Meta",
      "default": null
    },
    "error": {
      "anyOf": [
        {
          "type": "object",
          "additionalProperties": true
        },
        {
          "type": "null"
        }
      ],
      "title": "Error",
      "default": null
    }
  }
}
football_get_groups annotations
{
  "readOnlyHint": true,
  "openWorldHint": true,
  "idempotentHint": true,
  "destructiveHint": false
}
football_get_fixtures
Advertised by the server during the last successful anonymous check.
Advertised read-onlyOpen-world

Return World Cup 2026 fixtures (live providers, else the group schedule). Args: limit: Max fixtures to return, 1..200 (default 50). offset: Number of fixtures to skip for paging (default 0). Returns: data.fixtures: page of {home, away, date/group, status, home_goals, away_goals}. data.pagination: {total, count, offset, limit, has_more, next_offset}. meta.source: adapter that served the data (static_seed = group schedule only).

football_get_fixtures input schema
{
  "type": "object",
  "title": "football_get_fixturesArguments",
  "properties": {
    "limit": {
      "type": "integer",
      "title": "Limit",
      "default": 50,
      "description": "Max fixtures to return, 1..200 (default 50)."
    },
    "offset": {
      "type": "integer",
      "title": "Offset",
      "default": 0,
      "description": "Number of fixtures to skip for paging (default 0)."
    }
  }
}
football_get_fixtures output schema
{
  "type": "object",
  "title": "Envelope",
  "properties": {
    "data": {
      "anyOf": [
        {
          "type": "object",
          "additionalProperties": true
        },
        {
          "type": "null"
        }
      ],
      "title": "Data",
      "default": null
    },
    "meta": {
      "anyOf": [
        {
          "type": "object",
          "additionalProperties": true
        },
        {
          "type": "null"
        }
      ],
      "title": "Meta",
      "default": null
    },
    "error": {
      "anyOf": [
        {
          "type": "object",
          "additionalProperties": true
        },
        {
          "type": "null"
        }
      ],
      "title": "Error",
      "default": null
    }
  }
}
football_get_fixtures annotations
{
  "readOnlyHint": true,
  "openWorldHint": true,
  "idempotentHint": true,
  "destructiveHint": false
}
football_get_standings
Advertised by the server during the last successful anonymous check.
Advertised read-onlyOpen-world

Return current World Cup 2026 group standings. Args: limit: Max standing rows to return, 1..200 (default 50). offset: Number of rows to skip for paging (default 0). Returns: data.standings: page of {rank, team, group, points, played, goals_diff}. data.pagination: {total, count, offset, limit, has_more, next_offset}. meta.source: adapter that served the data.

football_get_standings input schema
{
  "type": "object",
  "title": "football_get_standingsArguments",
  "properties": {
    "limit": {
      "type": "integer",
      "title": "Limit",
      "default": 50,
      "description": "Max standing rows to return, 1..200 (default 50)."
    },
    "offset": {
      "type": "integer",
      "title": "Offset",
      "default": 0,
      "description": "Number of rows to skip for paging (default 0)."
    }
  }
}
football_get_standings output schema
{
  "type": "object",
  "title": "Envelope",
  "properties": {
    "data": {
      "anyOf": [
        {
          "type": "object",
          "additionalProperties": true
        },
        {
          "type": "null"
        }
      ],
      "title": "Data",
      "default": null
    },
    "meta": {
      "anyOf": [
        {
          "type": "object",
          "additionalProperties": true
        },
        {
          "type": "null"
        }
      ],
      "title": "Meta",
      "default": null
    },
    "error": {
      "anyOf": [
        {
          "type": "object",
          "additionalProperties": true
        },
        {
          "type": "null"
        }
      ],
      "title": "Error",
      "default": null
    }
  }
}
football_get_standings annotations
{
  "readOnlyHint": true,
  "openWorldHint": true,
  "idempotentHint": true,
  "destructiveHint": false
}
football_get_squad
Advertised by the server during the last successful anonymous check.
Advertised read-onlyOpen-world

Return a national team's World Cup squad. Args: team: Team code or name (e.g. "ARG"). Live rosters need an API-Football key; without one the static seed serves an empty-but-valid squad (no rosters are bundled). Returns: data.squad: list of {name, number, position, age} (empty from the seed). meta.source: adapter that served the data. meta.note: present when the seed served it — how to get live squads.

football_get_squad input schema
{
  "type": "object",
  "title": "football_get_squadArguments",
  "required": [
    "team"
  ],
  "properties": {
    "team": {
      "type": "string",
      "title": "Team",
      "description": "Team code or name (e.g. \"ARG\"). Live rosters need an API-Football key; without one the static seed serves an empty-but-valid squad (no rosters are bundled)."
    }
  }
}
football_get_squad output schema
{
  "type": "object",
  "title": "Envelope",
  "properties": {
    "data": {
      "anyOf": [
        {
          "type": "object",
          "additionalProperties": true
        },
        {
          "type": "null"
        }
      ],
      "title": "Data",
      "default": null
    },
    "meta": {
      "anyOf": [
        {
          "type": "object",
          "additionalProperties": true
        },
        {
          "type": "null"
        }
      ],
      "title": "Meta",
      "default": null
    },
    "error": {
      "anyOf": [
        {
          "type": "object",
          "additionalProperties": true
        },
        {
          "type": "null"
        }
      ],
      "title": "Error",
      "default": null
    }
  }
}
football_get_squad annotations
{
  "readOnlyHint": true,
  "openWorldHint": true,
  "idempotentHint": true,
  "destructiveHint": false
}
football_get_match_stats
Advertised by the server during the last successful anonymous check.
Advertised read-onlyOpen-world

Return a team's aggregate World Cup tournament statistics. Network-only enrichment: requires a configured API-Football (or football-data.org) key. There is no offline static fallback, so without a key the call returns a clean ALL_SOURCES_FAILED envelope. Args: team: API-Football numeric team id (not a country code). Returns: data.team_stats: {team, played, wins, goals_for, goals_against}. meta.source: adapter that served the data.

football_get_match_stats input schema
{
  "type": "object",
  "title": "football_get_match_statsArguments",
  "required": [
    "team"
  ],
  "properties": {
    "team": {
      "type": "integer",
      "title": "Team",
      "description": "API-Football numeric team id (not a country code)."
    }
  }
}
football_get_match_stats output schema
{
  "type": "object",
  "title": "Envelope",
  "properties": {
    "data": {
      "anyOf": [
        {
          "type": "object",
          "additionalProperties": true
        },
        {
          "type": "null"
        }
      ],
      "title": "Data",
      "default": null
    },
    "meta": {
      "anyOf": [
        {
          "type": "object",
          "additionalProperties": true
        },
        {
          "type": "null"
        }
      ],
      "title": "Meta",
      "default": null
    },
    "error": {
      "anyOf": [
        {
          "type": "object",
          "additionalProperties": true
        },
        {
          "type": "null"
        }
      ],
      "title": "Error",
      "default": null
    }
  }
}
football_get_match_stats annotations
{
  "readOnlyHint": true,
  "openWorldHint": true,
  "idempotentHint": true,
  "destructiveHint": false
}
football_get_top_scorers
Advertised by the server during the last successful anonymous check.
Advertised read-onlyOpen-world

Return the World Cup 2026 top scorers. Returns: data.scorers: list of {name, team, goals, assists}. meta.source: adapter that served the data.

football_get_top_scorers input schema
{
  "type": "object",
  "title": "football_get_top_scorersArguments",
  "properties": {}
}
football_get_top_scorers output schema
{
  "type": "object",
  "title": "Envelope",
  "properties": {
    "data": {
      "anyOf": [
        {
          "type": "object",
          "additionalProperties": true
        },
        {
          "type": "null"
        }
      ],
      "title": "Data",
      "default": null
    },
    "meta": {
      "anyOf": [
        {
          "type": "object",
          "additionalProperties": true
        },
        {
          "type": "null"
        }
      ],
      "title": "Meta",
      "default": null
    },
    "error": {
      "anyOf": [
        {
          "type": "object",
          "additionalProperties": true
        },
        {
          "type": "null"
        }
      ],
      "title": "Error",
      "default": null
    }
  }
}
football_get_top_scorers annotations
{
  "readOnlyHint": true,
  "openWorldHint": true,
  "idempotentHint": true,
  "destructiveHint": false
}
football_get_odds
Advertised by the server during the last successful anonymous check.
Advertised read-onlyOpen-world

Return market head-to-head odds for any World Cup 2026 events the odds feed still lists. Sourced from The Odds API (requires THEODDS_KEY). Without a key the call returns a clean ALL_SOURCES_FAILED envelope rather than crashing. The tournament ended with the 2026-07-19 final, so the feed is normally empty. Args: team: Optional team name to filter events (case-insensitive substring, matched against both sides). Omit to return every WC event. Returns: data.events: list of {event_id, home, away, commence_time, bookmakers: [{name, home, draw, away, last_update}]} with decimal 1X2 prices per bookmaker. meta.source: adapter that served the data (theodds / cache:stale).

football_get_odds input schema
{
  "type": "object",
  "title": "football_get_oddsArguments",
  "properties": {
    "team": {
      "anyOf": [
        {
          "type": "string"
        },
        {
          "type": "null"
        }
      ],
      "title": "Team",
      "default": null,
      "description": "Optional team name to filter events (case-insensitive substring, matched against both sides). Omit to return every WC event."
    }
  }
}
football_get_odds output schema
{
  "type": "object",
  "title": "Envelope",
  "properties": {
    "data": {
      "anyOf": [
        {
          "type": "object",
          "additionalProperties": true
        },
        {
          "type": "null"
        }
      ],
      "title": "Data",
      "default": null
    },
    "meta": {
      "anyOf": [
        {
          "type": "object",
          "additionalProperties": true
        },
        {
          "type": "null"
        }
      ],
      "title": "Meta",
      "default": null
    },
    "error": {
      "anyOf": [
        {
          "type": "object",
          "additionalProperties": true
        },
        {
          "type": "null"
        }
      ],
      "title": "Error",
      "default": null
    }
  }
}
football_get_odds annotations
{
  "readOnlyHint": true,
  "openWorldHint": true,
  "idempotentHint": true,
  "destructiveHint": false
}
football_xg_model
Advertised by the server during the last successful anonymous check.
Advertised read-onlyOpen-world

Estimate a match's expected goals and win/draw/loss probabilities. Args: home_team: First team, FIFA code or name (e.g. "ARG" or "Argentina"). away_team: Second team, FIFA code or name (e.g. "BRA" or "Brazil"). neutral: True for a neutral venue (no home advantage). World Cup default. Returns: data: {expected_home_goals, expected_away_goals, home_win, draw, away_win}. meta.estimated: true.

football_xg_model input schema
{
  "type": "object",
  "title": "football_xg_modelArguments",
  "required": [
    "home_team",
    "away_team"
  ],
  "properties": {
    "neutral": {
      "type": "boolean",
      "title": "Neutral",
      "default": true,
      "description": "True for a neutral venue (no home advantage). World Cup default."
    },
    "away_team": {
      "type": "string",
      "title": "Away Team",
      "description": "Second team, FIFA code or name (e.g. \"BRA\" or \"Brazil\")."
    },
    "home_team": {
      "type": "string",
      "title": "Home Team",
      "description": "First team, FIFA code or name (e.g. \"ARG\" or \"Argentina\")."
    }
  }
}
football_xg_model output schema
{
  "type": "object",
  "title": "Envelope",
  "properties": {
    "data": {
      "anyOf": [
        {
          "type": "object",
          "additionalProperties": true
        },
        {
          "type": "null"
        }
      ],
      "title": "Data",
      "default": null
    },
    "meta": {
      "anyOf": [
        {
          "type": "object",
          "additionalProperties": true
        },
        {
          "type": "null"
        }
      ],
      "title": "Meta",
      "default": null
    },
    "error": {
      "anyOf": [
        {
          "type": "object",
          "additionalProperties": true
        },
        {
          "type": "null"
        }
      ],
      "title": "Error",
      "default": null
    }
  }
}
football_xg_model annotations
{
  "readOnlyHint": true,
  "openWorldHint": true,
  "idempotentHint": true,
  "destructiveHint": false
}
football_match_predictor
Advertised by the server during the last successful anonymous check.
Advertised read-onlyOpen-world

Predict a single match: most likely scoreline + outcome probabilities. Args: home_team: First team, FIFA code or name (e.g. "ESP" or "Spain"). away_team: Second team, FIFA code or name. neutral: True for a neutral venue (World Cup default). Returns: data: {most_likely_score, home_win, draw, away_win, predicted_winner}. meta.estimated: true.

football_match_predictor input schema
{
  "type": "object",
  "title": "football_match_predictorArguments",
  "required": [
    "home_team",
    "away_team"
  ],
  "properties": {
    "neutral": {
      "type": "boolean",
      "title": "Neutral",
      "default": true,
      "description": "True for a neutral venue (World Cup default)."
    },
    "away_team": {
      "type": "string",
      "title": "Away Team",
      "description": "Second team, FIFA code or name."
    },
    "home_team": {
      "type": "string",
      "title": "Home Team",
      "description": "First team, FIFA code or name (e.g. \"ESP\" or \"Spain\")."
    }
  }
}
football_match_predictor output schema
{
  "type": "object",
  "title": "Envelope",
  "properties": {
    "data": {
      "anyOf": [
        {
          "type": "object",
          "additionalProperties": true
        },
        {
          "type": "null"
        }
      ],
      "title": "Data",
      "default": null
    },
    "meta": {
      "anyOf": [
        {
          "type": "object",
          "additionalProperties": true
        },
        {
          "type": "null"
        }
      ],
      "title": "Meta",
      "default": null
    },
    "error": {
      "anyOf": [
        {
          "type": "object",
          "additionalProperties": true
        },
        {
          "type": "null"
        }
      ],
      "title": "Error",
      "default": null
    }
  }
}
football_match_predictor annotations
{
  "readOnlyHint": true,
  "openWorldHint": true,
  "idempotentHint": true,
  "destructiveHint": false
}
football_simulate_group
Advertised by the server during the last successful anonymous check.
Advertised read-onlyOpen-world

Monte Carlo one group within the full 12-group qualification context. Args: group: Group letter A-L (also accepts "Group A"). iterations: Number of simulations (clamped to 100..20000). Returns: data.teams: Per-team position probabilities, p_auto_advance, p_best_third_advance, truthful combined p_advance, and avg_points. data.iterations: iterations actually run. meta.estimated: true. meta.conditioned_matches: completed matches locked in.

football_simulate_group input schema
{
  "type": "object",
  "title": "football_simulate_groupArguments",
  "required": [
    "group"
  ],
  "properties": {
    "group": {
      "type": "string",
      "title": "Group",
      "description": "Group letter A-L (also accepts \"Group A\")."
    },
    "iterations": {
      "type": "integer",
      "title": "Iterations",
      "default": 5000,
      "description": "Number of simulations (clamped to 100..20000)."
    }
  }
}
football_simulate_group output schema
{
  "type": "object",
  "title": "Envelope",
  "properties": {
    "data": {
      "anyOf": [
        {
          "type": "object",
          "additionalProperties": true
        },
        {
          "type": "null"
        }
      ],
      "title": "Data",
      "default": null
    },
    "meta": {
      "anyOf": [
        {
          "type": "object",
          "additionalProperties": true
        },
        {
          "type": "null"
        }
      ],
      "title": "Meta",
      "default": null
    },
    "error": {
      "anyOf": [
        {
          "type": "object",
          "additionalProperties": true
        },
        {
          "type": "null"
        }
      ],
      "title": "Error",
      "default": null
    }
  }
}
football_simulate_group annotations
{
  "readOnlyHint": true,
  "openWorldHint": true,
  "idempotentHint": true,
  "destructiveHint": false
}
football_simulate_bracket
Advertised by the server during the last successful anonymous check.
Advertised read-onlyOpen-world

Monte Carlo the full World Cup 2026 — per-team round + title probabilities. Simulates all 12 groups, advances the top 2 + 8 best third-placed teams to a 32-team knockout, and plays it to a champion, ``iterations`` times. Args: iterations: Number of tournament simulations (clamped to 100..20000; ~10000 gives stable ±2% probabilities). seed: Optional RNG seed for reproducible output. Returns: data.teams: {code: {reach_r32, reach_r16, reach_qf, reach_sf, reach_final, win}} sorted by win probability descending. data.champion: most likely winner. data.iterations: iterations run. meta.estimated: true. meta.conditioned_matches: completed matches locked in (played group results fixed, decided knockout ties locked). Example: football_simulate_bracket() football_simulate_bracket(iterations=20000, seed=42)

football_simulate_bracket input schema
{
  "type": "object",
  "title": "football_simulate_bracketArguments",
  "properties": {
    "seed": {
      "anyOf": [
        {
          "type": "integer"
        },
        {
          "type": "null"
        }
      ],
      "title": "Seed",
      "default": null,
      "description": "Optional RNG seed for reproducible output."
    },
    "iterations": {
      "type": "integer",
      "title": "Iterations",
      "default": 10000,
      "description": "Number of tournament simulations (clamped to 100..20000; ~10000 gives stable ±2% probabilities)."
    }
  }
}
football_simulate_bracket output schema
{
  "type": "object",
  "title": "Envelope",
  "properties": {
    "data": {
      "anyOf": [
        {
          "type": "object",
          "additionalProperties": true
        },
        {
          "type": "null"
        }
      ],
      "title": "Data",
      "default": null
    },
    "meta": {
      "anyOf": [
        {
          "type": "object",
          "additionalProperties": true
        },
        {
          "type": "null"
        }
      ],
      "title": "Meta",
      "default": null
    },
    "error": {
      "anyOf": [
        {
          "type": "object",
          "additionalProperties": true
        },
        {
          "type": "null"
        }
      ],
      "title": "Error",
      "default": null
    }
  }
}
football_simulate_bracket annotations
{
  "readOnlyHint": true,
  "openWorldHint": true,
  "idempotentHint": true,
  "destructiveHint": false
}
football_knockout_path
Advertised by the server during the last successful anonymous check.
Advertised read-onlyOpen-world

Round-by-round survival probabilities for one team in the full sim. Args: team: FIFA code or name (e.g. "FRA" or "France"). iterations: Number of tournament simulations (clamped to 100..20000). seed: Optional RNG seed. Returns: data: {team, reach_r32, reach_r16, reach_qf, reach_sf, reach_final, win}. meta.estimated: true.

football_knockout_path input schema
{
  "type": "object",
  "title": "football_knockout_pathArguments",
  "required": [
    "team"
  ],
  "properties": {
    "seed": {
      "anyOf": [
        {
          "type": "integer"
        },
        {
          "type": "null"
        }
      ],
      "title": "Seed",
      "default": null,
      "description": "Optional RNG seed."
    },
    "team": {
      "type": "string",
      "title": "Team",
      "description": "FIFA code or name (e.g. \"FRA\" or \"France\")."
    },
    "iterations": {
      "type": "integer",
      "title": "Iterations",
      "default": 10000,
      "description": "Number of tournament simulations (clamped to 100..20000)."
    }
  }
}
football_knockout_path output schema
{
  "type": "object",
  "title": "Envelope",
  "properties": {
    "data": {
      "anyOf": [
        {
          "type": "object",
          "additionalProperties": true
        },
        {
          "type": "null"
        }
      ],
      "title": "Data",
      "default": null
    },
    "meta": {
      "anyOf": [
        {
          "type": "object",
          "additionalProperties": true
        },
        {
          "type": "null"
        }
      ],
      "title": "Meta",
      "default": null
    },
    "error": {
      "anyOf": [
        {
          "type": "object",
          "additionalProperties": true
        },
        {
          "type": "null"
        }
      ],
      "title": "Error",
      "default": null
    }
  }
}
football_knockout_path annotations
{
  "readOnlyHint": true,
  "openWorldHint": true,
  "idempotentHint": true,
  "destructiveHint": false
}
football_what_if
Advertised by the server during the last successful anonymous check.
Advertised read-onlyOpen-world

Replay World Cup 2026 from a chosen stage, optionally flipping one real knockout result. Keeps every real result played before ``replay_from`` and Monte-Carlos the rest of the tournament from there. ``flip_winner_of`` makes one decided knockout tie in the kept results go the other way first. Args: replay_from: Stage to re-simulate from: "group" (whole tournament, no real results kept), "r32", "r16", "qf", "sf" or "final" (keeps every result before the final and simulates only the final). flip_winner_of: Optional tie to flip, as two FIFA codes or names joined by a hyphen in any order (e.g. "ESP-FRA"). It must be a decided knockout tie before ``replay_from``. iterations: Number of tournament simulations (clamped to 100..20000). seed: Optional RNG seed for reproducible output. Returns: data.teams: {code: {reach_r32, reach_r16, reach_qf, reach_sf, reach_final, win}} sorted by win probability descending. data.champion: most likely winner. data.iterations: iterations run. meta.mode: "what_if". meta.replay_from: the stage. meta.flipped: {tie: [code_a, code_b], winner: code} or null. meta.estimated: true. Example: football_what_if(replay_from="qf") football_what_if(replay_from="final", flip_winner_of="ESP-FRA", seed=7)

football_what_if input schema
{
  "type": "object",
  "title": "football_what_ifArguments",
  "properties": {
    "seed": {
      "anyOf": [
        {
          "type": "integer"
        },
        {
          "type": "null"
        }
      ],
      "title": "Seed",
      "default": null,
      "description": "Optional RNG seed for reproducible output."
    },
    "iterations": {
      "type": "integer",
      "title": "Iterations",
      "default": 10000,
      "description": "Number of tournament simulations (clamped to 100..20000)."
    },
    "replay_from": {
      "enum": [
        "group",
        "r32",
        "r16",
        "qf",
        "sf",
        "final"
      ],
      "type": "string",
      "title": "Replay From",
      "default": "group",
      "description": "Stage to re-simulate from: \"group\" (whole tournament, no real results kept), \"r32\", \"r16\", \"qf\", \"sf\" or \"final\" (keeps every result before the final and simulates only the final)."
    },
    "flip_winner_of": {
      "anyOf": [
        {
          "type": "string"
        },
        {
          "type": "null"
        }
      ],
      "title": "Flip Winner Of",
      "default": null,
      "description": "Optional tie to flip, as two FIFA codes or names joined by a hyphen in any order (e.g. \"ESP-FRA\"). It must be a decided knockout tie before ``replay_from``."
    }
  }
}
football_what_if output schema
{
  "type": "object",
  "title": "Envelope",
  "properties": {
    "data": {
      "anyOf": [
        {
          "type": "object",
          "additionalProperties": true
        },
        {
          "type": "null"
        }
      ],
      "title": "Data",
      "default": null
    },
    "meta": {
      "anyOf": [
        {
          "type": "object",
          "additionalProperties": true
        },
        {
          "type": "null"
        }
      ],
      "title": "Meta",
      "default": null
    },
    "error": {
      "anyOf": [
        {
          "type": "object",
          "additionalProperties": true
        },
        {
          "type": "null"
        }
      ],
      "title": "Error",
      "default": null
    }
  }
}
football_what_if annotations
{
  "readOnlyHint": true,
  "openWorldHint": true,
  "idempotentHint": true,
  "destructiveHint": false
}
football_find_value_bets
Advertised by the server during the last successful anonymous check.
Advertised read-onlyOpen-world

Surface the largest gaps between the model's win probability and the market. De-vigs each market's 1X2 decimal odds (removes the margin so implied probabilities sum to 1) and compares them to this server's own match-outcome probabilities — the same Elo/Poisson path ``football_match_predictor`` uses. Flags outcomes where the model beats the de-vigged market by ``min_edge`` **and** the offered price has positive expected value, with the edge, the expected value and the model's fair odds. Events that have already started are skipped. Args: team: Optional FIFA code or team name to filter events (matched against both sides; an unrecognised value falls back to a case-insensitive substring match). Omit to scan every WC 2026 odds event. min_edge: Minimum edge (model_prob - devigged_market_prob), 0..1. Default 0.05 (5 percentage points). Returns: data.value_bets: list of {event_id, home, away, outcome, model_prob, fair_odds, market_odds, edge, ev_pct, bookmaker, price_updated_at}, sorted by edge descending. data.events_analysed: not-yet-started events with both teams in the draw. meta.estimated: true. meta.is_stale reflects the odds freshness.

football_find_value_bets input schema
{
  "type": "object",
  "title": "football_find_value_betsArguments",
  "properties": {
    "team": {
      "anyOf": [
        {
          "type": "string"
        },
        {
          "type": "null"
        }
      ],
      "title": "Team",
      "default": null,
      "description": "Optional FIFA code or team name to filter events (matched against both sides; an unrecognised value falls back to a case-insensitive substring match). Omit to scan every WC 2026 odds event."
    },
    "min_edge": {
      "type": "number",
      "title": "Min Edge",
      "default": 0.05,
      "description": "Minimum edge (model_prob - devigged_market_prob), 0..1. Default 0.05 (5 percentage points)."
    }
  }
}
football_find_value_bets output schema
{
  "type": "object",
  "title": "Envelope",
  "properties": {
    "data": {
      "anyOf": [
        {
          "type": "object",
          "additionalProperties": true
        },
        {
          "type": "null"
        }
      ],
      "title": "Data",
      "default": null
    },
    "meta": {
      "anyOf": [
        {
          "type": "object",
          "additionalProperties": true
        },
        {
          "type": "null"
        }
      ],
      "title": "Meta",
      "default": null
    },
    "error": {
      "anyOf": [
        {
          "type": "object",
          "additionalProperties": true
        },
        {
          "type": "null"
        }
      ],
      "title": "Error",
      "default": null
    }
  }
}
football_find_value_bets annotations
{
  "readOnlyHint": true,
  "openWorldHint": true,
  "idempotentHint": true,
  "destructiveHint": false
}
football_form_trends
Advertised by the server during the last successful anonymous check.
Advertised read-onlyOpen-world

Return rolling form, goal record, and xG trend for a football team. Args: team: FIFA code (e.g. ARG) or name (e.g. "Argentina", "South Korea"). Returns: data: {form_string, wins, draws, losses, goals_scored, goals_conceded, xg_for, xg_against, recent_trend, matches_analysed}. meta.estimated: true — derived from available fixture data.

football_form_trends input schema
{
  "type": "object",
  "title": "football_form_trendsArguments",
  "required": [
    "team"
  ],
  "properties": {
    "team": {
      "type": "string",
      "title": "Team",
      "description": "FIFA code (e.g. ARG) or name (e.g. \"Argentina\", \"South Korea\")."
    }
  }
}
football_form_trends output schema
{
  "type": "object",
  "title": "Envelope",
  "properties": {
    "data": {
      "anyOf": [
        {
          "type": "object",
          "additionalProperties": true
        },
        {
          "type": "null"
        }
      ],
      "title": "Data",
      "default": null
    },
    "meta": {
      "anyOf": [
        {
          "type": "object",
          "additionalProperties": true
        },
        {
          "type": "null"
        }
      ],
      "title": "Meta",
      "default": null
    },
    "error": {
      "anyOf": [
        {
          "type": "object",
          "additionalProperties": true
        },
        {
          "type": "null"
        }
      ],
      "title": "Error",
      "default": null
    }
  }
}
football_form_trends annotations
{
  "readOnlyHint": true,
  "openWorldHint": true,
  "idempotentHint": true,
  "destructiveHint": false
}
football_build_accumulator
Advertised by the server during the last successful anonymous check.
Advertised read-onlyOpen-world

Model the joint probability of several match outcomes from the top model-vs-market gaps. Calls ``football_find_value_bets`` internally to fetch live odds, then selects the strongest legs and combines them under the joint-probability model. Args: legs: Number of legs (2-8). Default 3. min_edge: Minimum edge threshold per leg. Default 0.05. Returns: data: {legs, legs_used, combined_odds, combined_model_prob, combined_edge, risk_flag, independence_warning}. meta.estimated: true.

football_build_accumulator input schema
{
  "type": "object",
  "title": "football_build_accumulatorArguments",
  "properties": {
    "legs": {
      "type": "integer",
      "title": "Legs",
      "default": 3,
      "description": "Number of legs (2-8). Default 3."
    },
    "min_edge": {
      "type": "number",
      "title": "Min Edge",
      "default": 0.05,
      "description": "Minimum edge threshold per leg. Default 0.05."
    }
  }
}
football_build_accumulator output schema
{
  "type": "object",
  "title": "Envelope",
  "properties": {
    "data": {
      "anyOf": [
        {
          "type": "object",
          "additionalProperties": true
        },
        {
          "type": "null"
        }
      ],
      "title": "Data",
      "default": null
    },
    "meta": {
      "anyOf": [
        {
          "type": "object",
          "additionalProperties": true
        },
        {
          "type": "null"
        }
      ],
      "title": "Meta",
      "default": null
    },
    "error": {
      "anyOf": [
        {
          "type": "object",
          "additionalProperties": true
        },
        {
          "type": "null"
        }
      ],
      "title": "Error",
      "default": null
    }
  }
}
football_build_accumulator annotations
{
  "readOnlyHint": true,
  "openWorldHint": true,
  "idempotentHint": true,
  "destructiveHint": false
}
f1_get_sessions
Advertised by the server during the last successful anonymous check.
Advertised read-onlyOpen-world

Return F1 sessions for a given year, optionally filtered by country or session name. Args: year: Championship year (e.g. 2026). country: Optional country name to filter (e.g. "Netherlands"). session_name: Optional session name to keep, case-insensitive (e.g. "Race", "Qualifying", "Sprint"). latest_completed: When true, return only the single session that ended most recently (greatest date_end before now, UTC) — e.g. with session_name="Race", the latest finished Grand Prix. Returns: data.sessions: list of session objects with session_key, session_type, date. meta.source: adapter that served the data.

f1_get_sessions input schema
{
  "type": "object",
  "title": "f1_get_sessionsArguments",
  "required": [
    "year"
  ],
  "properties": {
    "year": {
      "type": "integer",
      "title": "Year",
      "description": "Championship year (e.g. 2026)."
    },
    "country": {
      "anyOf": [
        {
          "type": "string"
        },
        {
          "type": "null"
        }
      ],
      "title": "Country",
      "default": null,
      "description": "Optional country name to filter (e.g. \"Netherlands\")."
    },
    "session_name": {
      "anyOf": [
        {
          "type": "string"
        },
        {
          "type": "null"
        }
      ],
      "title": "Session Name",
      "default": null,
      "description": "Optional session name to keep, case-insensitive (e.g. \"Race\", \"Qualifying\", \"Sprint\")."
    },
    "latest_completed": {
      "type": "boolean",
      "title": "Latest Completed",
      "default": false,
      "description": "When true, return only the single session that ended most recently (greatest date_end before now, UTC) — e.g. with session_name=\"Race\", the latest finished Grand Prix."
    }
  }
}
f1_get_sessions output schema
{
  "type": "object",
  "title": "Envelope",
  "properties": {
    "data": {
      "anyOf": [
        {
          "type": "object",
          "additionalProperties": true
        },
        {
          "type": "null"
        }
      ],
      "title": "Data",
      "default": null
    },
    "meta": {
      "anyOf": [
        {
          "type": "object",
          "additionalProperties": true
        },
        {
          "type": "null"
        }
      ],
      "title": "Meta",
      "default": null
    },
    "error": {
      "anyOf": [
        {
          "type": "object",
          "additionalProperties": true
        },
        {
          "type": "null"
        }
      ],
      "title": "Error",
      "default": null
    }
  }
}
f1_get_sessions annotations
{
  "readOnlyHint": true,
  "openWorldHint": true,
  "idempotentHint": true,
  "destructiveHint": false
}
f1_get_drivers
Advertised by the server during the last successful anonymous check.
Advertised read-onlyOpen-world

Return driver list for a specific F1 session. Args: session_key: OpenF1 session identifier. Returns: data.drivers: list of driver objects with driver_number, full_name, team. meta.source: adapter that served the data.

f1_get_drivers input schema
{
  "type": "object",
  "title": "f1_get_driversArguments",
  "required": [
    "session_key"
  ],
  "properties": {
    "session_key": {
      "type": "integer",
      "title": "Session Key",
      "description": "OpenF1 session identifier."
    }
  }
}
f1_get_drivers output schema
{
  "type": "object",
  "title": "Envelope",
  "properties": {
    "data": {
      "anyOf": [
        {
          "type": "object",
          "additionalProperties": true
        },
        {
          "type": "null"
        }
      ],
      "title": "Data",
      "default": null
    },
    "meta": {
      "anyOf": [
        {
          "type": "object",
          "additionalProperties": true
        },
        {
          "type": "null"
        }
      ],
      "title": "Meta",
      "default": null
    },
    "error": {
      "anyOf": [
        {
          "type": "object",
          "additionalProperties": true
        },
        {
          "type": "null"
        }
      ],
      "title": "Error",
      "default": null
    }
  }
}
f1_get_drivers annotations
{
  "readOnlyHint": true,
  "openWorldHint": true,
  "idempotentHint": true,
  "destructiveHint": false
}
f1_get_lap_times
Advertised by the server during the last successful anonymous check.
Advertised read-onlyOpen-world

Return lap times for a driver in a specific F1 session. Args: session_key: OpenF1 session identifier. driver_number: Driver's race number (driver numbers change by season; use f1_get_drivers). limit: Max laps to return, 1..200 (default 100 — covers most full races). offset: Number of laps to skip for paging (default 0). Returns: data.laps: page of lap objects with lap_number and lap_duration. OpenF1 does not put compound/tyre_life here — those live on the stints endpoint. data.pagination: {total, count, offset, limit, has_more, next_offset}. meta.source: adapter that served the data.

f1_get_lap_times input schema
{
  "type": "object",
  "title": "f1_get_lap_timesArguments",
  "required": [
    "session_key",
    "driver_number"
  ],
  "properties": {
    "limit": {
      "type": "integer",
      "title": "Limit",
      "default": 100,
      "description": "Max laps to return, 1..200 (default 100 — covers most full races)."
    },
    "offset": {
      "type": "integer",
      "title": "Offset",
      "default": 0,
      "description": "Number of laps to skip for paging (default 0)."
    },
    "session_key": {
      "type": "integer",
      "title": "Session Key",
      "description": "OpenF1 session identifier."
    },
    "driver_number": {
      "type": "integer",
      "title": "Driver Number",
      "description": "Driver's race number (driver numbers change by season; use f1_get_drivers)."
    }
  }
}
f1_get_lap_times output schema
{
  "type": "object",
  "title": "Envelope",
  "properties": {
    "data": {
      "anyOf": [
        {
          "type": "object",
          "additionalProperties": true
        },
        {
          "type": "null"
        }
      ],
      "title": "Data",
      "default": null
    },
    "meta": {
      "anyOf": [
        {
          "type": "object",
          "additionalProperties": true
        },
        {
          "type": "null"
        }
      ],
      "title": "Meta",
      "default": null
    },
    "error": {
      "anyOf": [
        {
          "type": "object",
          "additionalProperties": true
        },
        {
          "type": "null"
        }
      ],
      "title": "Error",
      "default": null
    }
  }
}
f1_get_lap_times annotations
{
  "readOnlyHint": true,
  "openWorldHint": true,
  "idempotentHint": true,
  "destructiveHint": false
}
f1_get_standings
Advertised by the server during the last successful anonymous check.
Advertised read-onlyOpen-world

Return F1 driver and constructor championship standings for a year. Use this for "who is leading / who will win the F1 championship this year". For title probabilities use f1_simulate_championship. This is not a cricket or football tool. Args: year: Championship year (e.g. 2026). Returns: data.season / data.round: season and the last round counted. data.drivers: [{position, driver_number, code, name, team, points, wins}] (points are season totals). data.constructors: [{position, team, points, wins}]. Same shape from every source (Jolpica primary; the FastF1 fallback sums per-race points and omits sprint points). meta.source: adapter that served the data.

f1_get_standings input schema
{
  "type": "object",
  "title": "f1_get_standingsArguments",
  "required": [
    "year"
  ],
  "properties": {
    "year": {
      "type": "integer",
      "title": "Year",
      "description": "Championship year (e.g. 2026)."
    }
  }
}
f1_get_standings output schema
{
  "type": "object",
  "title": "Envelope",
  "properties": {
    "data": {
      "anyOf": [
        {
          "type": "object",
          "additionalProperties": true
        },
        {
          "type": "null"
        }
      ],
      "title": "Data",
      "default": null
    },
    "meta": {
      "anyOf": [
        {
          "type": "object",
          "additionalProperties": true
        },
        {
          "type": "null"
        }
      ],
      "title": "Meta",
      "default": null
    },
    "error": {
      "anyOf": [
        {
          "type": "object",
          "additionalProperties": true
        },
        {
          "type": "null"
        }
      ],
      "title": "Error",
      "default": null
    }
  }
}
f1_get_standings annotations
{
  "readOnlyHint": true,
  "openWorldHint": true,
  "idempotentHint": true,
  "destructiveHint": false
}
f1_get_race_results
Advertised by the server during the last successful anonymous check.
Advertised read-onlyOpen-world

Return the final classification for one F1 race, keyed by year and round. Args: year: Championship year (e.g. 2025). round: Round number within the season (1-based; e.g. 1 for the opener). Returns: data.results: Ergast/Jolpica RaceTable payload — finishing order, times, grid positions, points, and fastest laps for the race. meta.source: adapter that served the data.

f1_get_race_results input schema
{
  "type": "object",
  "title": "f1_get_race_resultsArguments",
  "required": [
    "year",
    "round"
  ],
  "properties": {
    "year": {
      "type": "integer",
      "title": "Year",
      "description": "Championship year (e.g. 2025)."
    },
    "round": {
      "type": "integer",
      "title": "Round",
      "description": "Round number within the season (1-based; e.g. 1 for the opener)."
    }
  }
}
f1_get_race_results output schema
{
  "type": "object",
  "title": "Envelope",
  "properties": {
    "data": {
      "anyOf": [
        {
          "type": "object",
          "additionalProperties": true
        },
        {
          "type": "null"
        }
      ],
      "title": "Data",
      "default": null
    },
    "meta": {
      "anyOf": [
        {
          "type": "object",
          "additionalProperties": true
        },
        {
          "type": "null"
        }
      ],
      "title": "Meta",
      "default": null
    },
    "error": {
      "anyOf": [
        {
          "type": "object",
          "additionalProperties": true
        },
        {
          "type": "null"
        }
      ],
      "title": "Error",
      "default": null
    }
  }
}
f1_get_race_results annotations
{
  "readOnlyHint": true,
  "openWorldHint": true,
  "idempotentHint": true,
  "destructiveHint": false
}
f1_get_weather
Advertised by the server during the last successful anonymous check.
Advertised read-onlyOpen-world

Return weather data for a specific F1 session. Args: session_key: OpenF1 session identifier. Returns: data.weather: list of weather snapshots with temperature, rainfall, wind. meta.source: adapter that served the data.

f1_get_weather input schema
{
  "type": "object",
  "title": "f1_get_weatherArguments",
  "required": [
    "session_key"
  ],
  "properties": {
    "session_key": {
      "type": "integer",
      "title": "Session Key",
      "description": "OpenF1 session identifier."
    }
  }
}
f1_get_weather output schema
{
  "type": "object",
  "title": "Envelope",
  "properties": {
    "data": {
      "anyOf": [
        {
          "type": "object",
          "additionalProperties": true
        },
        {
          "type": "null"
        }
      ],
      "title": "Data",
      "default": null
    },
    "meta": {
      "anyOf": [
        {
          "type": "object",
          "additionalProperties": true
        },
        {
          "type": "null"
        }
      ],
      "title": "Meta",
      "default": null
    },
    "error": {
      "anyOf": [
        {
          "type": "object",
          "additionalProperties": true
        },
        {
          "type": "null"
        }
      ],
      "title": "Error",
      "default": null
    }
  }
}
f1_get_weather annotations
{
  "readOnlyHint": true,
  "openWorldHint": true,
  "idempotentHint": true,
  "destructiveHint": false
}
f1_tyre_degradation
Advertised by the server during the last successful anonymous check.
Advertised read-onlyOpen-world

Fit a tyre degradation model for a driver + compound in a session. Args: session_key: OpenF1 session identifier. driver_number: Driver's race number. compound: Tyre compound (SOFT, MEDIUM, HARD, INTER, WET; "INTERMEDIATE" = INTER). Returns: data: {intercept, slope, residual_std, sample_count}. meta.estimated: true — model output, not telemetry oracle.

f1_tyre_degradation input schema
{
  "type": "object",
  "title": "f1_tyre_degradationArguments",
  "required": [
    "session_key",
    "driver_number",
    "compound"
  ],
  "properties": {
    "compound": {
      "type": "string",
      "title": "Compound",
      "description": "Tyre compound (SOFT, MEDIUM, HARD, INTER, WET; \"INTERMEDIATE\" = INTER)."
    },
    "session_key": {
      "type": "integer",
      "title": "Session Key",
      "description": "OpenF1 session identifier."
    },
    "driver_number": {
      "type": "integer",
      "title": "Driver Number",
      "description": "Driver's race number."
    }
  }
}
f1_tyre_degradation output schema
{
  "type": "object",
  "title": "Envelope",
  "properties": {
    "data": {
      "anyOf": [
        {
          "type": "object",
          "additionalProperties": true
        },
        {
          "type": "null"
        }
      ],
      "title": "Data",
      "default": null
    },
    "meta": {
      "anyOf": [
        {
          "type": "object",
          "additionalProperties": true
        },
        {
          "type": "null"
        }
      ],
      "title": "Meta",
      "default": null
    },
    "error": {
      "anyOf": [
        {
          "type": "object",
          "additionalProperties": true
        },
        {
          "type": "null"
        }
      ],
      "title": "Error",
      "default": null
    }
  }
}
f1_tyre_degradation annotations
{
  "readOnlyHint": true,
  "openWorldHint": true,
  "idempotentHint": true,
  "destructiveHint": false
}
f1_undercut_window
Advertised by the server during the last successful anonymous check.
Advertised read-onlyOpen-world

Estimate whether an undercut is viable for the attacker against the target. Args: session_key: OpenF1 session identifier. attacker_number: Attacking driver's race number. target_number: Target driver's race number. current_lap: Current lap number in the race. Returns: data: {laps_to_clear, viable, marginal}. meta.gap_to_target_s: attacker-minus-target race time at current_lap. meta.gap_source: "cumulative_lap_time", or "default" (assumed 2.0 s, also in meta.assumed_gap_s) when either driver lacks a full lap history. meta.estimated: true.

f1_undercut_window input schema
{
  "type": "object",
  "title": "f1_undercut_windowArguments",
  "required": [
    "session_key",
    "attacker_number",
    "target_number",
    "current_lap"
  ],
  "properties": {
    "current_lap": {
      "type": "integer",
      "title": "Current Lap",
      "description": "Current lap number in the race."
    },
    "session_key": {
      "type": "integer",
      "title": "Session Key",
      "description": "OpenF1 session identifier."
    },
    "target_number": {
      "type": "integer",
      "title": "Target Number",
      "description": "Target driver's race number."
    },
    "attacker_number": {
      "type": "integer",
      "title": "Attacker Number",
      "description": "Attacking driver's race number."
    }
  }
}
f1_undercut_window output schema
{
  "type": "object",
  "title": "Envelope",
  "properties": {
    "data": {
      "anyOf": [
        {
          "type": "object",
          "additionalProperties": true
        },
        {
          "type": "null"
        }
      ],
      "title": "Data",
      "default": null
    },
    "meta": {
      "anyOf": [
        {
          "type": "object",
          "additionalProperties": true
        },
        {
          "type": "null"
        }
      ],
      "title": "Meta",
      "default": null
    },
    "error": {
      "anyOf": [
        {
          "type": "object",
          "additionalProperties": true
        },
        {
          "type": "null"
        }
      ],
      "title": "Error",
      "default": null
    }
  }
}
f1_undercut_window annotations
{
  "readOnlyHint": true,
  "openWorldHint": true,
  "idempotentHint": true,
  "destructiveHint": false
}
f1_head_to_head_pace
Advertised by the server during the last successful anonymous check.
Advertised read-onlyOpen-world

Compare lap-time pace distribution between two drivers in a session. Args: session_key: OpenF1 session identifier. driver_a: First driver's race number. driver_b: Second driver's race number. Returns: data: {driver_a_avg_s, driver_b_avg_s, delta_s, faster_driver}. The "avg" values are median lap times after dropping pit-out laps and slow outliers (safety-car / in-laps). meta.estimated: true.

f1_head_to_head_pace input schema
{
  "type": "object",
  "title": "f1_head_to_head_paceArguments",
  "required": [
    "session_key",
    "driver_a",
    "driver_b"
  ],
  "properties": {
    "driver_a": {
      "type": "integer",
      "title": "Driver A",
      "description": "First driver's race number."
    },
    "driver_b": {
      "type": "integer",
      "title": "Driver B",
      "description": "Second driver's race number."
    },
    "session_key": {
      "type": "integer",
      "title": "Session Key",
      "description": "OpenF1 session identifier."
    }
  }
}
f1_head_to_head_pace output schema
{
  "type": "object",
  "title": "Envelope",
  "properties": {
    "data": {
      "anyOf": [
        {
          "type": "object",
          "additionalProperties": true
        },
        {
          "type": "null"
        }
      ],
      "title": "Data",
      "default": null
    },
    "meta": {
      "anyOf": [
        {
          "type": "object",
          "additionalProperties": true
        },
        {
          "type": "null"
        }
      ],
      "title": "Meta",
      "default": null
    },
    "error": {
      "anyOf": [
        {
          "type": "object",
          "additionalProperties": true
        },
        {
          "type": "null"
        }
      ],
      "title": "Error",
      "default": null
    }
  }
}
f1_head_to_head_pace annotations
{
  "readOnlyHint": true,
  "openWorldHint": true,
  "idempotentHint": true,
  "destructiveHint": false
}
f1_weather_strategy_impact
Advertised by the server during the last successful anonymous check.
Advertised read-onlyOpen-world

Analyse weather data and recommend compound or pit-window adjustments. Args: session_key: OpenF1 session identifier. Returns: data: {has_rain, avg_track_temp_c, compound_recommendation, recommendation}. meta.estimated: true.

f1_weather_strategy_impact input schema
{
  "type": "object",
  "title": "f1_weather_strategy_impactArguments",
  "required": [
    "session_key"
  ],
  "properties": {
    "session_key": {
      "type": "integer",
      "title": "Session Key",
      "description": "OpenF1 session identifier."
    }
  }
}
f1_weather_strategy_impact output schema
{
  "type": "object",
  "title": "Envelope",
  "properties": {
    "data": {
      "anyOf": [
        {
          "type": "object",
          "additionalProperties": true
        },
        {
          "type": "null"
        }
      ],
      "title": "Data",
      "default": null
    },
    "meta": {
      "anyOf": [
        {
          "type": "object",
          "additionalProperties": true
        },
        {
          "type": "null"
        }
      ],
      "title": "Meta",
      "default": null
    },
    "error": {
      "anyOf": [
        {
          "type": "object",
          "additionalProperties": true
        },
        {
          "type": "null"
        }
      ],
      "title": "Error",
      "default": null
    }
  }
}
f1_weather_strategy_impact annotations
{
  "readOnlyHint": true,
  "openWorldHint": true,
  "idempotentHint": true,
  "destructiveHint": false
}
f1_predict_pit_strategy
Advertised by the server during the last successful anonymous check.
Advertised read-onlyOpen-world

Predict the optimal pit-stop strategy for a driver in an F1 race session. Args: session_key: OpenF1 session identifier for a recorded race. driver_number: Driver's race number (driver numbers change by season; use f1_get_drivers). current_lap: Current lap to project from (default 1 = full race ahead). total_laps: Total race laps. If omitted, estimated from the regulation minimum race distance (305 km; Monaco 260 km) over the circuit's lap length; INVALID_INPUT when the circuit is unknown. An explicit value always wins. Returns: data.stop_laps: recommended pit laps. data.compound_sequence: tyre compounds for each stint. data.expected_finish_position: currently always None (not modelled). data.confidence: 0.0-1.0 model confidence. data.net_saving_s: stay-out time minus the best one-stop time (seconds). data.current_tyre_age: laps on the current tyre set at current_lap. meta.total_laps: race length used. meta.total_laps_source: "explicit" or "regulation_estimate". meta.estimated: true. Example: f1_predict_pit_strategy(session_key=11353, driver_number=1, total_laps=72) f1_predict_pit_strategy(session_key=11353, driver_number=1, current_lap=20)

f1_predict_pit_strategy input schema
{
  "type": "object",
  "title": "f1_predict_pit_strategyArguments",
  "required": [
    "session_key",
    "driver_number"
  ],
  "properties": {
    "total_laps": {
      "anyOf": [
        {
          "type": "integer"
        },
        {
          "type": "null"
        }
      ],
      "title": "Total Laps",
      "default": null,
      "description": "Total race laps. If omitted, estimated from the regulation minimum race distance (305 km; Monaco 260 km) over the circuit's lap length; INVALID_INPUT when the circuit is unknown. An explicit value always wins."
    },
    "current_lap": {
      "type": "integer",
      "title": "Current Lap",
      "default": 1,
      "description": "Current lap to project from (default 1 = full race ahead)."
    },
    "session_key": {
      "type": "integer",
      "title": "Session Key",
      "description": "OpenF1 session identifier for a recorded race."
    },
    "driver_number": {
      "type": "integer",
      "title": "Driver Number",
      "description": "Driver's race number (driver numbers change by season; use f1_get_drivers)."
    }
  }
}
f1_predict_pit_strategy output schema
{
  "type": "object",
  "title": "Envelope",
  "properties": {
    "data": {
      "anyOf": [
        {
          "type": "object",
          "additionalProperties": true
        },
        {
          "type": "null"
        }
      ],
      "title": "Data",
      "default": null
    },
    "meta": {
      "anyOf": [
        {
          "type": "object",
          "additionalProperties": true
        },
        {
          "type": "null"
        }
      ],
      "title": "Meta",
      "default": null
    },
    "error": {
      "anyOf": [
        {
          "type": "object",
          "additionalProperties": true
        },
        {
          "type": "null"
        }
      ],
      "title": "Error",
      "default": null
    }
  }
}
f1_predict_pit_strategy annotations
{
  "readOnlyHint": true,
  "openWorldHint": true,
  "idempotentHint": true,
  "destructiveHint": false
}
f1_simulate_championship
Advertised by the server during the last successful anonymous check.
Advertised read-onlyOpen-world

Estimate each driver's F1 drivers' title probability for the rest of a season. Monte Carlo over the remaining races and sprints (Plackett-Luce finishing orders weighted by each driver's season points rate), plus exact elimination maths: a driver who cannot catch the leader's current points even by winning every remaining race and sprint has title_prob 0.0. This is not a cricket or football tool. Args: year: Championship season (2018-2030, default 2026). iterations: Monte Carlo iterations, clamped to 1000-20000 (default 10000). seed: Optional RNG seed for reproducible probabilities. Returns: data.drivers: [{code, points_now, title_prob, expected_points, eliminated, max_possible}] sorted by title_prob. data.max_remaining_points: most points one driver can still score. data.rounds_remaining: races left after the last completed round. meta.estimated: true. meta.model: "plackett-luce-points-rate". meta.is_stale: true if standings or schedule came from stale cache.

f1_simulate_championship input schema
{
  "type": "object",
  "title": "f1_simulate_championshipArguments",
  "properties": {
    "seed": {
      "anyOf": [
        {
          "type": "integer"
        },
        {
          "type": "null"
        }
      ],
      "title": "Seed",
      "default": null,
      "description": "Optional RNG seed for reproducible probabilities."
    },
    "year": {
      "type": "integer",
      "title": "Year",
      "default": 2026,
      "description": "Championship season (2018-2030, default 2026)."
    },
    "iterations": {
      "type": "integer",
      "title": "Iterations",
      "default": 10000,
      "description": "Monte Carlo iterations, clamped to 1000-20000 (default 10000)."
    }
  }
}
f1_simulate_championship output schema
{
  "type": "object",
  "title": "Envelope",
  "properties": {
    "data": {
      "anyOf": [
        {
          "type": "object",
          "additionalProperties": true
        },
        {
          "type": "null"
        }
      ],
      "title": "Data",
      "default": null
    },
    "meta": {
      "anyOf": [
        {
          "type": "object",
          "additionalProperties": true
        },
        {
          "type": "null"
        }
      ],
      "title": "Meta",
      "default": null
    },
    "error": {
      "anyOf": [
        {
          "type": "object",
          "additionalProperties": true
        },
        {
          "type": "null"
        }
      ],
      "title": "Error",
      "default": null
    }
  }
}
f1_simulate_championship annotations
{
  "readOnlyHint": true,
  "openWorldHint": true,
  "idempotentHint": true,
  "destructiveHint": false
}
f1_qualifying_analysis
Advertised by the server during the last successful anonymous check.
Advertised read-onlyOpen-world

Analyse a qualifying session: best lap per driver, gap to pole, projected grid. Args: session_key: OpenF1 session identifier for a Qualifying session. Returns: data.grid: [{position, driver_number, full_name, team_name, best_lap_gap_s}]. data.pole_time_s: pole lap duration in seconds. data.drivers_analysed: count of drivers with valid laps. meta.estimated: true — grid derived from session laps, not official timing.

f1_qualifying_analysis input schema
{
  "type": "object",
  "title": "f1_qualifying_analysisArguments",
  "required": [
    "session_key"
  ],
  "properties": {
    "session_key": {
      "type": "integer",
      "title": "Session Key",
      "description": "OpenF1 session identifier for a Qualifying session."
    }
  }
}
f1_qualifying_analysis output schema
{
  "type": "object",
  "title": "Envelope",
  "properties": {
    "data": {
      "anyOf": [
        {
          "type": "object",
          "additionalProperties": true
        },
        {
          "type": "null"
        }
      ],
      "title": "Data",
      "default": null
    },
    "meta": {
      "anyOf": [
        {
          "type": "object",
          "additionalProperties": true
        },
        {
          "type": "null"
        }
      ],
      "title": "Meta",
      "default": null
    },
    "error": {
      "anyOf": [
        {
          "type": "object",
          "additionalProperties": true
        },
        {
          "type": "null"
        }
      ],
      "title": "Error",
      "default": null
    }
  }
}
f1_qualifying_analysis annotations
{
  "readOnlyHint": true,
  "openWorldHint": true,
  "idempotentHint": true,
  "destructiveHint": false
}
f1_race_pace_compare
Advertised by the server during the last successful anonymous check.
Advertised read-onlyOpen-world

Compare race-pace and tyre degradation between two F1 drivers in a session. Args: session_key: OpenF1 session identifier. driver_a: First driver's race number. driver_b: Second driver's race number. Returns: data: {by_compound, overall_faster, compounds_compared}. meta.estimated: true — degradation model fit, not official timing.

f1_race_pace_compare input schema
{
  "type": "object",
  "title": "f1_race_pace_compareArguments",
  "required": [
    "session_key",
    "driver_a",
    "driver_b"
  ],
  "properties": {
    "driver_a": {
      "type": "integer",
      "title": "Driver A",
      "description": "First driver's race number."
    },
    "driver_b": {
      "type": "integer",
      "title": "Driver B",
      "description": "Second driver's race number."
    },
    "session_key": {
      "type": "integer",
      "title": "Session Key",
      "description": "OpenF1 session identifier."
    }
  }
}
f1_race_pace_compare output schema
{
  "type": "object",
  "title": "Envelope",
  "properties": {
    "data": {
      "anyOf": [
        {
          "type": "object",
          "additionalProperties": true
        },
        {
          "type": "null"
        }
      ],
      "title": "Data",
      "default": null
    },
    "meta": {
      "anyOf": [
        {
          "type": "object",
          "additionalProperties": true
        },
        {
          "type": "null"
        }
      ],
      "title": "Meta",
      "default": null
    },
    "error": {
      "anyOf": [
        {
          "type": "object",
          "additionalProperties": true
        },
        {
          "type": "null"
        }
      ],
      "title": "Error",
      "default": null
    }
  }
}
f1_race_pace_compare annotations
{
  "readOnlyHint": true,
  "openWorldHint": true,
  "idempotentHint": true,
  "destructiveHint": false
}
cricket_get_live_matches
Advertised by the server during the last successful anonymous check.
Advertised read-onlyOpen-world

Return all currently live cricket matches across all series. Returns: data.matches: list of live match objects (team names, score, status). meta.source: which adapter served the response. meta.is_stale: true if data is from stale cache.

cricket_get_live_matches input schema
{
  "type": "object",
  "title": "cricket_get_live_matchesArguments",
  "properties": {}
}
cricket_get_live_matches output schema
{
  "type": "object",
  "title": "Envelope",
  "properties": {
    "data": {
      "anyOf": [
        {
          "type": "object",
          "additionalProperties": true
        },
        {
          "type": "null"
        }
      ],
      "title": "Data",
      "default": null
    },
    "meta": {
      "anyOf": [
        {
          "type": "object",
          "additionalProperties": true
        },
        {
          "type": "null"
        }
      ],
      "title": "Meta",
      "default": null
    },
    "error": {
      "anyOf": [
        {
          "type": "object",
          "additionalProperties": true
        },
        {
          "type": "null"
        }
      ],
      "title": "Error",
      "default": null
    }
  }
}
cricket_get_live_matches annotations
{
  "readOnlyHint": true,
  "openWorldHint": true,
  "idempotentHint": true,
  "destructiveHint": false
}
cricket_get_scorecard
Advertised by the server during the last successful anonymous check.
Advertised read-onlyOpen-world

Return the full scorecard for a specific match. Args: match_id: The match identifier (e.g. from cricket_get_live_matches). Returns: data: full scorecard with innings, partnerships, bowling figures. meta.source: adapter that served the data.

cricket_get_scorecard input schema
{
  "type": "object",
  "title": "cricket_get_scorecardArguments",
  "required": [
    "match_id"
  ],
  "properties": {
    "match_id": {
      "type": "string",
      "title": "Match Id",
      "description": "The match identifier (e.g. from cricket_get_live_matches)."
    }
  }
}
cricket_get_scorecard output schema
{
  "type": "object",
  "title": "Envelope",
  "properties": {
    "data": {
      "anyOf": [
        {
          "type": "object",
          "additionalProperties": true
        },
        {
          "type": "null"
        }
      ],
      "title": "Data",
      "default": null
    },
    "meta": {
      "anyOf": [
        {
          "type": "object",
          "additionalProperties": true
        },
        {
          "type": "null"
        }
      ],
      "title": "Meta",
      "default": null
    },
    "error": {
      "anyOf": [
        {
          "type": "object",
          "additionalProperties": true
        },
        {
          "type": "null"
        }
      ],
      "title": "Error",
      "default": null
    }
  }
}
cricket_get_scorecard annotations
{
  "readOnlyHint": true,
  "openWorldHint": true,
  "idempotentHint": true,
  "destructiveHint": false
}
cricket_get_points_table
Advertised by the server during the last successful anonymous check.
Advertised read-onlyOpen-world

Return the points table / standings for a cricket series. Args: series_id: The series identifier (e.g. IPL 2026 series ID from CricAPI). Returns: data: points table rows with team, P, W, L, NRR, Points. meta.source: adapter that served the data.

cricket_get_points_table input schema
{
  "type": "object",
  "title": "cricket_get_points_tableArguments",
  "required": [
    "series_id"
  ],
  "properties": {
    "series_id": {
      "type": "string",
      "title": "Series Id",
      "description": "The series identifier (e.g. IPL 2026 series ID from CricAPI)."
    }
  }
}
cricket_get_points_table output schema
{
  "type": "object",
  "title": "Envelope",
  "properties": {
    "data": {
      "anyOf": [
        {
          "type": "object",
          "additionalProperties": true
        },
        {
          "type": "null"
        }
      ],
      "title": "Data",
      "default": null
    },
    "meta": {
      "anyOf": [
        {
          "type": "object",
          "additionalProperties": true
        },
        {
          "type": "null"
        }
      ],
      "title": "Meta",
      "default": null
    },
    "error": {
      "anyOf": [
        {
          "type": "object",
          "additionalProperties": true
        },
        {
          "type": "null"
        }
      ],
      "title": "Error",
      "default": null
    }
  }
}
cricket_get_points_table annotations
{
  "readOnlyHint": true,
  "openWorldHint": true,
  "idempotentHint": true,
  "destructiveHint": false
}
cricket_get_schedule
Advertised by the server during the last successful anonymous check.
Advertised read-onlyOpen-world

Return the upcoming match schedule, optionally filtered by series. Args: series_id: Optional. Filter to a specific series. If omitted, returns all upcoming fixtures across all active series. limit: Max matches to return, 1..200 (default 50). offset: Number of matches to skip for paging (default 0). Returns: data.matches: page of matches dated today (UTC) or later, with teams, date, venue; filtered to ``series_id`` when the source labels series. data.pagination: {total, count, offset, limit, has_more, next_offset}. meta.source: adapter that served the data.

cricket_get_schedule input schema
{
  "type": "object",
  "title": "cricket_get_scheduleArguments",
  "properties": {
    "limit": {
      "type": "integer",
      "title": "Limit",
      "default": 50,
      "description": "Max matches to return, 1..200 (default 50)."
    },
    "offset": {
      "type": "integer",
      "title": "Offset",
      "default": 0,
      "description": "Number of matches to skip for paging (default 0)."
    },
    "series_id": {
      "anyOf": [
        {
          "type": "string"
        },
        {
          "type": "null"
        }
      ],
      "title": "Series Id",
      "default": null,
      "description": "Optional. Filter to a specific series. If omitted, returns all upcoming fixtures across all active series."
    }
  }
}
cricket_get_schedule output schema
{
  "type": "object",
  "title": "Envelope",
  "properties": {
    "data": {
      "anyOf": [
        {
          "type": "object",
          "additionalProperties": true
        },
        {
          "type": "null"
        }
      ],
      "title": "Data",
      "default": null
    },
    "meta": {
      "anyOf": [
        {
          "type": "object",
          "additionalProperties": true
        },
        {
          "type": "null"
        }
      ],
      "title": "Meta",
      "default": null
    },
    "error": {
      "anyOf": [
        {
          "type": "object",
          "additionalProperties": true
        },
        {
          "type": "null"
        }
      ],
      "title": "Error",
      "default": null
    }
  }
}
cricket_get_schedule annotations
{
  "readOnlyHint": true,
  "openWorldHint": true,
  "idempotentHint": true,
  "destructiveHint": false
}
cricket_get_squad
Advertised by the server during the last successful anonymous check.
Advertised read-onlyOpen-world

Return the squad roster for a cricket team, optionally for a specific series. Args: team: Team code or name (e.g. "MI", "CSK", "IND", "AUS"). series_id: Optional. Series ID to pull the tournament-specific squad. If omitted, falls back to static seed data. Returns: data.players: list of players with name, role, and credits. meta.source: adapter that served the data (cricapi / static_seed).

cricket_get_squad input schema
{
  "type": "object",
  "title": "cricket_get_squadArguments",
  "required": [
    "team"
  ],
  "properties": {
    "team": {
      "type": "string",
      "title": "Team",
      "description": "Team code or name (e.g. \"MI\", \"CSK\", \"IND\", \"AUS\")."
    },
    "series_id": {
      "anyOf": [
        {
          "type": "string"
        },
        {
          "type": "null"
        }
      ],
      "title": "Series Id",
      "default": null,
      "description": "Optional. Series ID to pull the tournament-specific squad. If omitted, falls back to static seed data."
    }
  }
}
cricket_get_squad output schema
{
  "type": "object",
  "title": "Envelope",
  "properties": {
    "data": {
      "anyOf": [
        {
          "type": "object",
          "additionalProperties": true
        },
        {
          "type": "null"
        }
      ],
      "title": "Data",
      "default": null
    },
    "meta": {
      "anyOf": [
        {
          "type": "object",
          "additionalProperties": true
        },
        {
          "type": "null"
        }
      ],
      "title": "Meta",
      "default": null
    },
    "error": {
      "anyOf": [
        {
          "type": "object",
          "additionalProperties": true
        },
        {
          "type": "null"
        }
      ],
      "title": "Error",
      "default": null
    }
  }
}
cricket_get_squad annotations
{
  "readOnlyHint": true,
  "openWorldHint": true,
  "idempotentHint": true,
  "destructiveHint": false
}
cricket_get_live_odds
Advertised by the server during the last successful anonymous check.
Advertised read-onlyOpen-world

Return live market head-to-head odds for upcoming/live IPL matches. IPL only (~March-May). An empty ``events`` list outside that window is a successful empty market, not an outage. Not international/Test/other T20 leagues. For World Cup 2026 football odds use ``football_get_odds``. Sourced from The Odds API (requires THEODDS_KEY). Without a key the call returns a clean ALL_SOURCES_FAILED envelope rather than crashing. Args: team: Optional team name to filter events (case-insensitive substring, matched against both sides). Omit to return every IPL event. The Odds API uses its own opaque event ids, so a CricAPI match_id cannot be resolved to an event yet — filtering is by team name. Returns: data.events: list of {event_id, home, away, commence_time, bookmakers: [{name, home, away}]} with decimal h2h prices per bookmaker. Empty when no IPL events are listed (typical off-season). meta.source: adapter that served the data (theodds / cache:stale).

cricket_get_live_odds input schema
{
  "type": "object",
  "title": "cricket_get_live_oddsArguments",
  "properties": {
    "team": {
      "anyOf": [
        {
          "type": "string"
        },
        {
          "type": "null"
        }
      ],
      "title": "Team",
      "default": null,
      "description": "Optional team name to filter events (case-insensitive substring, matched against both sides). Omit to return every IPL event. The Odds API uses its own opaque event ids, so a CricAPI match_id cannot be resolved to an event yet — filtering is by team name."
    }
  }
}
cricket_get_live_odds output schema
{
  "type": "object",
  "title": "Envelope",
  "properties": {
    "data": {
      "anyOf": [
        {
          "type": "object",
          "additionalProperties": true
        },
        {
          "type": "null"
        }
      ],
      "title": "Data",
      "default": null
    },
    "meta": {
      "anyOf": [
        {
          "type": "object",
          "additionalProperties": true
        },
        {
          "type": "null"
        }
      ],
      "title": "Meta",
      "default": null
    },
    "error": {
      "anyOf": [
        {
          "type": "object",
          "additionalProperties": true
        },
        {
          "type": "null"
        }
      ],
      "title": "Error",
      "default": null
    }
  }
}
cricket_get_live_odds annotations
{
  "readOnlyHint": true,
  "openWorldHint": true,
  "idempotentHint": true,
  "destructiveHint": false
}
cricket_build_dream11_team
Advertised by the server during the last successful anonymous check.
Advertised read-onlyOpen-world

Recommend an optimal fantasy XI + captain + vice-captain for one fixture. Args: match_id: CricAPI match identifier; resolves team_a/team_b/venue automatically. team_a: First team code/name (e.g. ``MI``). Required if match_id is absent. team_b: Second team code/name (e.g. ``CSK``). Required if match_id is absent. venue: Venue key/name (e.g. ``wankhede``). Required if match_id is absent. strategy: ``"balanced"`` only in Phase 2; future variants reserved. Returns: data.players: 11 picked players with name/role/credits/team/projected_points. data.captain: name of the chosen captain. data.vice_captain: name of the chosen VC. data.total_credits: sum of credits used (<= 100). data.total_projected_points: fantasy points including C x2 and VC x1.5 boosts. meta.estimated: true — projections are model output, not a fantasy oracle. meta.form_source: "default_neutral" (role-based projections; see meta.note). meta.scoring_profile: the Dream11 T20 points profile id. meta.excluded_missing_credits: players dropped for having no contest credits. Example: cricket_build_dream11_team(team_a="MI", team_b="CSK", venue="wankhede") cricket_build_dream11_team(match_id="abc123")

cricket_build_dream11_team input schema
{
  "type": "object",
  "title": "cricket_build_dream11_teamArguments",
  "properties": {
    "venue": {
      "anyOf": [
        {
          "type": "string"
        },
        {
          "type": "null"
        }
      ],
      "title": "Venue",
      "default": null,
      "description": "Venue key/name (e.g. ``wankhede``). Required if match_id is absent."
    },
    "team_a": {
      "anyOf": [
        {
          "type": "string"
        },
        {
          "type": "null"
        }
      ],
      "title": "Team A",
      "default": null,
      "description": "First team code/name (e.g. ``MI``). Required if match_id is absent."
    },
    "team_b": {
      "anyOf": [
        {
          "type": "string"
        },
        {
          "type": "null"
        }
      ],
      "title": "Team B",
      "default": null,
      "description": "Second team code/name (e.g. ``CSK``). Required if match_id is absent."
    },
    "match_id": {
      "anyOf": [
        {
          "type": "string"
        },
        {
          "type": "null"
        }
      ],
      "title": "Match Id",
      "default": null,
      "description": "CricAPI match identifier; resolves team_a/team_b/venue automatically."
    },
    "strategy": {
      "type": "string",
      "title": "Strategy",
      "default": "balanced",
      "description": "``\"balanced\"`` only in Phase 2; future variants reserved."
    }
  }
}
cricket_build_dream11_team output schema
{
  "type": "object",
  "title": "Envelope",
  "properties": {
    "data": {
      "anyOf": [
        {
          "type": "object",
          "additionalProperties": true
        },
        {
          "type": "null"
        }
      ],
      "title": "Data",
      "default": null
    },
    "meta": {
      "anyOf": [
        {
          "type": "object",
          "additionalProperties": true
        },
        {
          "type": "null"
        }
      ],
      "title": "Meta",
      "default": null
    },
    "error": {
      "anyOf": [
        {
          "type": "object",
          "additionalProperties": true
        },
        {
          "type": "null"
        }
      ],
      "title": "Error",
      "default": null
    }
  }
}
cricket_build_dream11_team annotations
{
  "readOnlyHint": true,
  "openWorldHint": true,
  "idempotentHint": true,
  "destructiveHint": false
}
cricket_captain_recommendation
Advertised by the server during the last successful anonymous check.
Advertised read-onlyOpen-world

Return the top-3 captain candidates ranked by projected points. IPL venues only (pitch seed is IPL grounds). Test/international matches and unknown venues fail rather than inventing a ranking. Same-role players often tie: projections use default form 55 and default opposition 0.5, not per-player history. Args: match_id: CricAPI match identifier; resolves team_a/team_b/venue automatically. team_a: First team code/name. Required if match_id is absent. team_b: Second team code/name. Required if match_id is absent. venue: Venue key/name (IPL ground, e.g. ``wankhede``). Required if match_id is absent. Returns: data.candidates: list of 3 dicts with name/role/team/projected_points. meta.source: model:captain_score. meta.estimated: true. meta.form_source: "default_neutral".

cricket_captain_recommendation input schema
{
  "type": "object",
  "title": "cricket_captain_recommendationArguments",
  "properties": {
    "venue": {
      "anyOf": [
        {
          "type": "string"
        },
        {
          "type": "null"
        }
      ],
      "title": "Venue",
      "default": null,
      "description": "Venue key/name (IPL ground, e.g. ``wankhede``). Required if match_id is absent."
    },
    "team_a": {
      "anyOf": [
        {
          "type": "string"
        },
        {
          "type": "null"
        }
      ],
      "title": "Team A",
      "default": null,
      "description": "First team code/name. Required if match_id is absent."
    },
    "team_b": {
      "anyOf": [
        {
          "type": "string"
        },
        {
          "type": "null"
        }
      ],
      "title": "Team B",
      "default": null,
      "description": "Second team code/name. Required if match_id is absent."
    },
    "match_id": {
      "anyOf": [
        {
          "type": "string"
        },
        {
          "type": "null"
        }
      ],
      "title": "Match Id",
      "default": null,
      "description": "CricAPI match identifier; resolves team_a/team_b/venue automatically."
    }
  }
}
cricket_captain_recommendation output schema
{
  "type": "object",
  "title": "Envelope",
  "properties": {
    "data": {
      "anyOf": [
        {
          "type": "object",
          "additionalProperties": true
        },
        {
          "type": "null"
        }
      ],
      "title": "Data",
      "default": null
    },
    "meta": {
      "anyOf": [
        {
          "type": "object",
          "additionalProperties": true
        },
        {
          "type": "null"
        }
      ],
      "title": "Meta",
      "default": null
    },
    "error": {
      "anyOf": [
        {
          "type": "object",
          "additionalProperties": true
        },
        {
          "type": "null"
        }
      ],
      "title": "Error",
      "default": null
    }
  }
}
cricket_captain_recommendation annotations
{
  "readOnlyHint": true,
  "openWorldHint": true,
  "idempotentHint": true,
  "destructiveHint": false
}
cricket_differential_picks
Advertised by the server during the last successful anonymous check.
Advertised read-onlyOpen-world

Suggest low-ownership picks with positive projected upside. Ownership is *estimated* — proxied by credit weight (lower-credit players tend to have lower ownership), not real ownership data. Flagged ``estimated: true`` in the response. Args: match_id: CricAPI match identifier; resolves team_a/team_b/venue automatically. team_a: First team code/name. Required if match_id is absent. team_b: Second team code/name. Required if match_id is absent. venue: Venue key/name. Required if match_id is absent. ownership_threshold: percent ownership cap; affects estimated label. Returns: data.picks: list of {name, role, team, credits, projected_points, estimated_ownership_pct, ownership_pct_estimated}. meta.source: model:captain_score (filtered). meta.estimated: true. meta.ownership_source: "heuristic_from_credits". meta.form_source: "default_neutral".

cricket_differential_picks input schema
{
  "type": "object",
  "title": "cricket_differential_picksArguments",
  "properties": {
    "venue": {
      "anyOf": [
        {
          "type": "string"
        },
        {
          "type": "null"
        }
      ],
      "title": "Venue",
      "default": null,
      "description": "Venue key/name. Required if match_id is absent."
    },
    "team_a": {
      "anyOf": [
        {
          "type": "string"
        },
        {
          "type": "null"
        }
      ],
      "title": "Team A",
      "default": null,
      "description": "First team code/name. Required if match_id is absent."
    },
    "team_b": {
      "anyOf": [
        {
          "type": "string"
        },
        {
          "type": "null"
        }
      ],
      "title": "Team B",
      "default": null,
      "description": "Second team code/name. Required if match_id is absent."
    },
    "match_id": {
      "anyOf": [
        {
          "type": "string"
        },
        {
          "type": "null"
        }
      ],
      "title": "Match Id",
      "default": null,
      "description": "CricAPI match identifier; resolves team_a/team_b/venue automatically."
    },
    "ownership_threshold": {
      "type": "integer",
      "title": "Ownership Threshold",
      "default": 20,
      "description": "percent ownership cap; affects estimated label."
    }
  }
}
cricket_differential_picks output schema
{
  "type": "object",
  "title": "Envelope",
  "properties": {
    "data": {
      "anyOf": [
        {
          "type": "object",
          "additionalProperties": true
        },
        {
          "type": "null"
        }
      ],
      "title": "Data",
      "default": null
    },
    "meta": {
      "anyOf": [
        {
          "type": "object",
          "additionalProperties": true
        },
        {
          "type": "null"
        }
      ],
      "title": "Meta",
      "default": null
    },
    "error": {
      "anyOf": [
        {
          "type": "object",
          "additionalProperties": true
        },
        {
          "type": "null"
        }
      ],
      "title": "Error",
      "default": null
    }
  }
}
cricket_differential_picks annotations
{
  "readOnlyHint": true,
  "openWorldHint": true,
  "idempotentHint": true,
  "destructiveHint": false
}
cricket_player_form_index
Advertised by the server during the last successful anonymous check.
Advertised read-onlyOpen-world

Report a 0-100 form score for a player using the player_stats chain. Args: player_id: Upstream player identifier (CricAPI/Cricbuzz id). Returns: data.form_score: 0..100 indicator. data.trend: "rising" / "stable" / "falling". data.samples: how many recent innings were available. meta.source: which adapter served the underlying stats. meta.estimated: true.

cricket_player_form_index input schema
{
  "type": "object",
  "title": "cricket_player_form_indexArguments",
  "required": [
    "player_id"
  ],
  "properties": {
    "player_id": {
      "type": "string",
      "title": "Player Id",
      "description": "Upstream player identifier (CricAPI/Cricbuzz id)."
    }
  }
}
cricket_player_form_index output schema
{
  "type": "object",
  "title": "Envelope",
  "properties": {
    "data": {
      "anyOf": [
        {
          "type": "object",
          "additionalProperties": true
        },
        {
          "type": "null"
        }
      ],
      "title": "Data",
      "default": null
    },
    "meta": {
      "anyOf": [
        {
          "type": "object",
          "additionalProperties": true
        },
        {
          "type": "null"
        }
      ],
      "title": "Meta",
      "default": null
    },
    "error": {
      "anyOf": [
        {
          "type": "object",
          "additionalProperties": true
        },
        {
          "type": "null"
        }
      ],
      "title": "Error",
      "default": null
    }
  }
}
cricket_player_form_index annotations
{
  "readOnlyHint": true,
  "openWorldHint": true,
  "idempotentHint": true,
  "destructiveHint": false
}
cricket_get_pitch_report
Advertised by the server during the last successful anonymous check.
Advertised read-onlyOpen-world

Summarise pitch characteristics for a venue. Args: venue: Venue key (e.g. ``wankhede``), official name, or city. Returns: data: {batting_friendly 0..1, expected_first_inn, recommendation, venue, pitch_type}. meta.source: which adapter served the venue record.

cricket_get_pitch_report input schema
{
  "type": "object",
  "title": "cricket_get_pitch_reportArguments",
  "required": [
    "venue"
  ],
  "properties": {
    "venue": {
      "type": "string",
      "title": "Venue",
      "description": "Venue key (e.g. ``wankhede``), official name, or city."
    }
  }
}
cricket_get_pitch_report output schema
{
  "type": "object",
  "title": "Envelope",
  "properties": {
    "data": {
      "anyOf": [
        {
          "type": "object",
          "additionalProperties": true
        },
        {
          "type": "null"
        }
      ],
      "title": "Data",
      "default": null
    },
    "meta": {
      "anyOf": [
        {
          "type": "object",
          "additionalProperties": true
        },
        {
          "type": "null"
        }
      ],
      "title": "Meta",
      "default": null
    },
    "error": {
      "anyOf": [
        {
          "type": "object",
          "additionalProperties": true
        },
        {
          "type": "null"
        }
      ],
      "title": "Error",
      "default": null
    }
  }
}
cricket_get_pitch_report annotations
{
  "readOnlyHint": true,
  "openWorldHint": true,
  "idempotentHint": true,
  "destructiveHint": false
}
cricket_find_value_bets
Advertised by the server during the last successful anonymous check.
Advertised read-onlyOpen-world

Compare model probabilities against market-implied IPL odds. Requires THEODDS_KEY. NOTE: cricket has no calibrated team-strength model wired yet (unlike the football Elo/Poisson path), so this tool currently returns an EMPTY ``value_bets`` list — scoring an edge against a neutral 50/50 prior would flag every market underdog, which would be misleading. It still reports how many events were screened so callers know odds were available. For raw de-vigged prices use ``cricket_get_live_odds``. Real edge detection lands when a cricket win model is wired (see cricket_head_to_head); it will flag outcomes where the model beats the de-vigged market by ``min_edge`` **and** the offered price has positive expected value. Args: team: Optional team name to filter events (case-insensitive substring). Omit to scan every IPL odds event. min_edge: Minimum edge (model_prob - devigged_market_prob), 0..1. Default 0.05. Currently informational only (no bets emitted). Returns: data.value_bets: always ``[]`` until a cricket model is wired. data.events_analysed: count of not-yet-started events screened (both teams present). data.model: ``"neutral_baseline"``. data.note: why no bets are emitted. meta.estimated: true.

cricket_find_value_bets input schema
{
  "type": "object",
  "title": "cricket_find_value_betsArguments",
  "properties": {
    "team": {
      "anyOf": [
        {
          "type": "string"
        },
        {
          "type": "null"
        }
      ],
      "title": "Team",
      "default": null,
      "description": "Optional team name to filter events (case-insensitive substring). Omit to scan every IPL odds event."
    },
    "min_edge": {
      "type": "number",
      "title": "Min Edge",
      "default": 0.05,
      "description": "Minimum edge (model_prob - devigged_market_prob), 0..1. Default 0.05. Currently informational only (no bets emitted)."
    }
  }
}
cricket_find_value_bets output schema
{
  "type": "object",
  "title": "Envelope",
  "properties": {
    "data": {
      "anyOf": [
        {
          "type": "object",
          "additionalProperties": true
        },
        {
          "type": "null"
        }
      ],
      "title": "Data",
      "default": null
    },
    "meta": {
      "anyOf": [
        {
          "type": "object",
          "additionalProperties": true
        },
        {
          "type": "null"
        }
      ],
      "title": "Meta",
      "default": null
    },
    "error": {
      "anyOf": [
        {
          "type": "object",
          "additionalProperties": true
        },
        {
          "type": "null"
        }
      ],
      "title": "Error",
      "default": null
    }
  }
}
cricket_find_value_bets annotations
{
  "readOnlyHint": true,
  "openWorldHint": true,
  "idempotentHint": true,
  "destructiveHint": false
}
cricket_head_to_head
Advertised by the server during the last successful anonymous check.
Advertised read-onlyOpen-world

Compare two cricket teams head-to-head using squad form and player stats. Args: team_a: First team code or name (e.g. "MI", "India"). team_b: Second team code or name (e.g. "CSK", "Australia"). Returns: data: {team_a, team_b, team_a_edge_count, team_b_edge_count, key_players_a, key_players_b, h2h_win_rate_a, h2h_win_rate_b, win_prob_a, win_prob_b}. meta.estimated: true. meta.estimate_quality: "uninformative" when no player stats were available (both sides at default form), else "player_stats".

cricket_head_to_head input schema
{
  "type": "object",
  "title": "cricket_head_to_headArguments",
  "required": [
    "team_a",
    "team_b"
  ],
  "properties": {
    "team_a": {
      "type": "string",
      "title": "Team A",
      "description": "First team code or name (e.g. \"MI\", \"India\")."
    },
    "team_b": {
      "type": "string",
      "title": "Team B",
      "description": "Second team code or name (e.g. \"CSK\", \"Australia\")."
    }
  }
}
cricket_head_to_head output schema
{
  "type": "object",
  "title": "Envelope",
  "properties": {
    "data": {
      "anyOf": [
        {
          "type": "object",
          "additionalProperties": true
        },
        {
          "type": "null"
        }
      ],
      "title": "Data",
      "default": null
    },
    "meta": {
      "anyOf": [
        {
          "type": "object",
          "additionalProperties": true
        },
        {
          "type": "null"
        }
      ],
      "title": "Meta",
      "default": null
    },
    "error": {
      "anyOf": [
        {
          "type": "object",
          "additionalProperties": true
        },
        {
          "type": "null"
        }
      ],
      "title": "Error",
      "default": null
    }
  }
}
cricket_head_to_head annotations
{
  "readOnlyHint": true,
  "openWorldHint": true,
  "idempotentHint": true,
  "destructiveHint": false
}
cricket_player_matchup
Advertised by the server during the last successful anonymous check.
Advertised read-onlyOpen-world

Analyse the head-to-head matchup between two cricket players based on role and career stats. Args: player_a: CricAPI player ID for the first player (names are not resolved). player_b: CricAPI player ID for the second player (names are not resolved). Returns: data: {matchup_type, edge_holder, edge_reason, signals, role_a, role_b}. meta.estimated: true — heuristic model, not ball-by-ball H2H data.

cricket_player_matchup input schema
{
  "type": "object",
  "title": "cricket_player_matchupArguments",
  "required": [
    "player_a",
    "player_b"
  ],
  "properties": {
    "player_a": {
      "type": "string",
      "title": "Player A",
      "description": "CricAPI player ID for the first player (names are not resolved)."
    },
    "player_b": {
      "type": "string",
      "title": "Player B",
      "description": "CricAPI player ID for the second player (names are not resolved)."
    }
  }
}
cricket_player_matchup output schema
{
  "type": "object",
  "title": "Envelope",
  "properties": {
    "data": {
      "anyOf": [
        {
          "type": "object",
          "additionalProperties": true
        },
        {
          "type": "null"
        }
      ],
      "title": "Data",
      "default": null
    },
    "meta": {
      "anyOf": [
        {
          "type": "object",
          "additionalProperties": true
        },
        {
          "type": "null"
        }
      ],
      "title": "Meta",
      "default": null
    },
    "error": {
      "anyOf": [
        {
          "type": "object",
          "additionalProperties": true
        },
        {
          "type": "null"
        }
      ],
      "title": "Error",
      "default": null
    }
  }
}
cricket_player_matchup annotations
{
  "readOnlyHint": true,
  "openWorldHint": true,
  "idempotentHint": true,
  "destructiveHint": false
}
cross_sport_build_accumulator
Advertised by the server during the last successful anonymous check.
Advertised read-onlyOpen-world

Model the joint probability of multiple outcomes across football and cricket. Args: legs: Total legs across both sports (2-8). Default 3. min_edge: Minimum edge per leg. Default 0.05. Returns: data: same shape as football_build_accumulator, with sport field per leg. meta.estimated: true.

cross_sport_build_accumulator input schema
{
  "type": "object",
  "title": "cross_sport_build_accumulatorArguments",
  "properties": {
    "legs": {
      "type": "integer",
      "title": "Legs",
      "default": 3,
      "description": "Total legs across both sports (2-8). Default 3."
    },
    "min_edge": {
      "type": "number",
      "title": "Min Edge",
      "default": 0.05,
      "description": "Minimum edge per leg. Default 0.05."
    }
  }
}
cross_sport_build_accumulator output schema
{
  "type": "object",
  "title": "Envelope",
  "properties": {
    "data": {
      "anyOf": [
        {
          "type": "object",
          "additionalProperties": true
        },
        {
          "type": "null"
        }
      ],
      "title": "Data",
      "default": null
    },
    "meta": {
      "anyOf": [
        {
          "type": "object",
          "additionalProperties": true
        },
        {
          "type": "null"
        }
      ],
      "title": "Meta",
      "default": null
    },
    "error": {
      "anyOf": [
        {
          "type": "object",
          "additionalProperties": true
        },
        {
          "type": "null"
        }
      ],
      "title": "Error",
      "default": null
    }
  }
}
cross_sport_build_accumulator annotations
{
  "readOnlyHint": true,
  "openWorldHint": true,
  "idempotentHint": true,
  "destructiveHint": false
}

Prompts

10 advertised

dream11_team_builder — Fantasy XI Builder

Advertised by the server during the last successful anonymous check.

Build an optimal fantasy XI for an IPL match.

team_a
No description (required)
team_b
No description (required)
venue
No description (required)
f1_race_strategy — F1 Pit Strategy

Advertised by the server during the last successful anonymous check.

Predict pit strategy for a driver at a specific Grand Prix.

year
No description (required)
country
No description (required)
driver_number
No description (required)
world_cup_2026_retrospective — World Cup 2026 Retrospective

Advertised by the server during the last successful anonymous check.

Review the completed FIFA World Cup 2026 against the model's simulation.

No arguments advertised.

cricket_value_bets — Cricket Probability Edge

Advertised by the server during the last successful anonymous check.

Compare model probabilities against the market across IPL matches.

No arguments advertised.

f1_driver_comparison — F1 Driver Comparison

Advertised by the server during the last successful anonymous check.

Compare two F1 drivers' pace at a Grand Prix.

year
No description (required)
country
No description (required)
driver_a
No description (required)
driver_b
No description (required)
cricket_captain_pick — IPL Captain Pick

Advertised by the server during the last successful anonymous check.

Recommend a captain for tonight's live IPL match.

No arguments advertised.

predict_match — Predict a Match

Advertised by the server during the last successful anonymous check.

Predict the scoreline and outcome of one World Cup 2026 match.

home_team
No description (required)
away_team
No description (required)
build_accumulator — Multi-Match Model

Advertised by the server during the last successful anonymous check.

Model the joint probability of multiple outcomes across sports.

legs
No description
server_health — Server Health

Advertised by the server during the last successful anonymous check.

Report cache backend, adapter status, and remaining API quota.

No arguments advertised.

wc_group_situation — World Cup Group Situation

Advertised by the server during the last successful anonymous check.

Show the World Cup 2026 group draw and advancement format.

No arguments advertised.

Resources

7 advertised

sportiq-instructions — SportIQ AI Operating Guide

Advertised by the server during the last successful anonymous check.

Read once at session start: tool catalogue, min-call recipes, envelope format, staleness rules, and error recovery for all 44 tools.

sportiq-instructions URI
sportiq://instructions

MIME type: text/markdown

football-wc2026-draw — FIFA World Cup 2026 draw

Advertised by the server during the last successful anonymous check.

WC 2026 format and the 12 groups of team codes.

football-wc2026-draw URI
sportiq://football/wc2026/draw

MIME type: application/json

football-team-codes — Football team codes

Advertised by the server during the last successful anonymous check.

WC 2026 team code → name and accepted name aliases.

football-team-codes URI
sportiq://football/team-codes

MIME type: application/json

f1-circuits — F1 circuit profiles

Advertised by the server during the last successful anonymous check.

Measured circuit profiles (pit loss, lap length) keyed by circuit key.

f1-circuits URI
sportiq://f1/circuits

MIME type: application/json

cricket-venues — Cricket venues

Advertised by the server during the last successful anonymous check.

Venue keys accepted by the cricket tools, with names and cities.

cricket-venues URI
sportiq://cricket/venues

MIME type: application/json

cricket-teams — IPL team codes

Advertised by the server during the last successful anonymous check.

IPL franchise code → official name.

cricket-teams URI
sportiq://cricket/teams

MIME type: application/json

cricket-scoring-profile — Dream11 T20 scoring profile

Advertised by the server during the last successful anonymous check.

The versioned Dream11 T20 points table the fantasy tools score with.

cricket-scoring-profile URI
sportiq://cricket/scoring-profile

MIME type: application/json

90-day uptime

A lightweight connection check about every six hours, sampled on hosts with many listings. It shows the server answered, not that its tools work.

Too few checks for a percentage yet (1 of 1 answered).

  1. 2026-11-07: 1 of 1 checks answered

30-day availability

Aggregated from read-only remote checks; this is not a tool-execution or security guarantee.

Successful checks
1 of 1 (100%)
Average latency
2482 ms
95th percentile latency
2482 ms

Maintenance history

Public check and source-refresh events. Editorial and ownership records remain private.

  • · probe · passed · 2482 ms · metadata changed · 46 tool(s), 7 resource(s), 0 resource template(s), 10 prompt(s)

Connect from your client

Each snippet registers the same endpoint; pick the client you use.

This server is operated by the named third party. Listing and endpoint checks are not an endorsement or a security audit. Review the operator's permissions, terms, and data handling before connecting. How listings are checked and corrected.

Claude Code

Run this once in a terminal. It registers the remote server. Use --scope project to write .mcp.json for the repo.
Claude Code configuration
claude mcp add --transport http sportiq-mcp-utkarshgupta https://sportiq.utkarshgupta.org/mcp

Codex

Run this once. Codex stores MCP servers in ~/.codex/config.toml (or .codex/config.toml in a trusted project).
Codex configuration
codex mcp add sportiq-mcp-utkarshgupta --url https://sportiq.utkarshgupta.org/mcp

Cursor

Merge this server into .cursor/mcp.json in your project, then enable sportiq-mcp-utkarshgupta in your MCP settings.
Cursor configuration
{
  "mcpServers": {
    "sportiq-mcp-utkarshgupta": {
      "url": "https://sportiq.utkarshgupta.org/mcp"
    }
  }
}

Cline

Merge this into cline_mcp_settings.json (Cline → MCP Servers → Configure).
Cline configuration
{
  "mcpServers": {
    "sportiq-mcp-utkarshgupta": {
      "type": "streamableHttp",
      "url": "https://sportiq.utkarshgupta.org/mcp",
      "disabled": false
    }
  }
}

VS Code

Merge this server into .vscode/mcp.json. Use MCP: List Servers to start sportiq-mcp-utkarshgupta and inspect its tools.
VS Code configuration
{
  "servers": {
    "sportiq-mcp-utkarshgupta": {
      "type": "http",
      "url": "https://sportiq.utkarshgupta.org/mcp"
    }
  }
}

Gemini CLI

Run this once. It writes .gemini/settings.json in the current project; pass --scope user for ~/.gemini/settings.json.
Gemini CLI configuration
gemini mcp add --transport http sportiq-mcp-utkarshgupta https://sportiq.utkarshgupta.org/mcp

Claude Desktop

Open Claude Settings > Connectors > Add custom connector, enter this server URL and enable it for the conversation. This is a manual remote-connector handoff, not a desktop JSON configuration.
Claude Desktop configuration
https://sportiq.utkarshgupta.org/mcp

Windsurf

Merge this into ~/.codeium/windsurf/mcp_config.json, then refresh MCP in Cascade. Windsurf remote servers use serverUrl, not url.
Windsurf configuration
{
  "mcpServers": {
    "sportiq-mcp-utkarshgupta": {
      "serverUrl": "https://sportiq.utkarshgupta.org/mcp"
    }
  }
}

Let your agent find its tools

Find servers like SportIQ MCP from your agent. Add Koskamo once to search the index for endpoints, access requirements, and client setup. Public discovery needs no key.