f1verse MCP Server
Use this read-only MCP server to fetch and analyze F1 race, season, championship, driver, and circuit data from 1950 to today, with explicit coverage, quality, and uncertainty labels.
Discover race weekends and sessions, then retrieve results for any session (race, qualifying, sprint, practice).
Get a complete race story in one call, plus plain-English race briefs, event timelines, turning points, pace changes, running order, battles, deleted laps, and highlight windows.
Check data quality: source access status, completeness, freshness, provisional status, corrections, cross-source agreement, and publishability.
Analyze tyre degradation and stint wear with raw trends and optional fuel-model scenarios; assess retirement survival across races.
Explore championships and standings, driver career totals, season shape, closest title finishes, and title probabilities with mathematical elimination status.
Retrieve archive races from 1996-2022 with explicit coverage blocks for what each era recorded.
Explore circuits via directory, historical winners and pole conversion, layout/profile, pit-loss economics, and telemetry-derived survey data.
Control inputs by year, round, optional session, optional fuel model, top-N, rounds, and simulation runs; tools are read-only and idempotent.
Provides OpenAI function-calling tool schemas for F1 data tools, enabling OpenAI LLM pipelines to discover and call race, session, championship, and circuit functions.
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@f1verse MCP Server Tell me the story of the 2026 British Grand Prix"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
f1verse
Documentation · MCP server · Agent skill · llms.txt · Changelog · Contributing · Security · License
Methods and evidence explains which answers are observations, model scenarios or retrospective evaluations, and how to reproduce their checks.
The story layer for Formula 1 data. Data libraries fetch and tidy — f1verse tells you what happened: lead changes, laps led, event timelines, stint strategy, race pace — and what happens next: title probabilities from a season simulation that ships with its own backtest.
Zero dependencies. Standard library only. Full live-timing coverage from 2023; lap-by-lap racing back to 1996, pit stops to 2011, and results, qualifying and standings to 1950 — each answer stating which era it came from and what that era does not hold.
pip install f1verseimport f1verse
race = f1verse.load(2026, 12) # year, round — no other library needed
race.laps_led() # {'ANT': 32, 'NOR': 31, 'HAM': 9}
race.leader_runs() # [{'abbr': 'NOR', 'from': 1, 'to': 4}, ...]
race.results()[7] # {'abbr': 'HUL', 'gap': '+1 LAP', ...}
race.race_pace() # median pace — pit/SC/VSC laps excluded by default
race.story() # one call, whole story, plain JSON
race.championship_prediction() # per-lap "if it ended now" title projection
race.team_radio() # timestamped clip URLs (nothing downloaded)
f1verse.championship_projection(2026) # who wins the title, 20,000 seasons
f1verse.title_scenarios(2026) # and who is mathematically outGive it to an AI agent
f1verse provides both an agent skill (analysis instructions) and an MCP server (callable data tools). They can be used together or separately.
The f1verse skill teaches event discovery,
source checks, strategy interpretation and statistical limits. Codex discovers
it in this checkout under .agents/skills/f1verse; invoke it with $f1verse.
To use it in other projects, install that directory with a GitHub skill
installer or copy it to ~/.agents/skills/f1verse. It works with the Python
package or a connected MCP server. Installing the skill does not connect MCP.
For MCP, configure your client with:
{"mcpServers": {"f1verse": {"command": "uvx", "args": ["--from", "f1verse", "f1verse-mcp"]}}}The uvx launcher installs the package on demand; the server itself has no
runtime dependencies. Discover tools with tools/list, analysis instructions
with resources/list, and the race-brief and strategy-review templates
with prompts/list. Resources and prompts do not fetch race data. The tool
catalogue includes input/output schemas and read-only hints; call
f1verse.tools() for the current list.
The server manifest is server.json, and its official registry
name is io.github.jinsim/f1verse.
An MCP registry listing and a GitHub agent skill are separate distribution
paths; publishing one does not publish the other. A clone runs local changes
with python -m f1verse.mcp after pip install -e .; uvx runs the latest
published PyPI version, which may differ from this checkout.
For any other LLM pipeline, the library describes itself:
f1verse.tools() # MCP-dialect JSON schemas
f1verse.tools("openai") # function-calling dialect
f1verse.call_tool("f1_race_story", {"year": 2026, "round": 12})Errors are written for the caller that has to fix them without reading this page:
f1verse.call_tool("f1_race_summary", {})
# LookupError: unknown tool 'f1_race_summary' — available: f1_race_story, ...
f1verse.load_session(2026, 12, "Qualy")
# LookupError: ... listing the sessions that weekend actually hadThe whole weekend, not just the race
f1verse.sessions(2026, 12)
# Practice 1 · Sprint Qualifying · Sprint · Qualifying · Race
q = f1verse.load_session(2026, 12, "Qualifying")
q.results()[0]
# {'abbr': 'NOR', 'q1': 72.695, 'q1_gap': 0.085, 'q3': 71.163, 'q3_gap': 0.0,
# 'best': 71.163, 'eliminated_in': None, ...}
q.segments()["q1"]
# {'fastest': 'PIA', 'advanced': [...16 codes...], 'eliminated': [...],
# 'cut_margin': 0.022}Each kind gets the classification it actually has. Qualifying gaps are to
the fastest lap of that segment — the pole-sitter above was 0.085 s
off in Q1 — because a single "gap to leader" column would misreport the
session. A sprint loads as a Race; practice is a best-lap table.
Is this data safe to publish?
race.quality_report()
# {'state': 'final', # provisional → settled → final, or corrected
# 'coverage': {'overall': 0.9955, 'sectors': 0.9824, 'compound': 1.0},
# 'missing': ['STR.lap_46.lap_duration', ...],
# 'source_age_seconds': 312,
# 'revisions': [], # source rewrites this install has observed
# 'crosscheck': {...},
# 'publishable': True}crosscheck answers do independent sources agree. quality_report adds
the three things that verdict is silent about: how complete the data is,
how old the copy is, and whether the classification is still provisional.
The chequered flag is not the final classification — scrutineering disqualifications and penalties land hours later and rewrite rows in place. So the rows the stewards can change are not cached forever until the session is final, and any change that is seen is recorded:
before = race.snapshot() # hashed, comparable, JSON — you persist it
...
f1verse.diff(before, race.refresh().snapshot())
# {'changed': True,
# 'changes': [{'abbr': 'HAM', 'field': 'position', 'before': 4, 'after': None},
# {'abbr': 'HAM', 'field': 'gap', 'before': '+8.1s', 'after': 'DSQ'}]}
f1verse.revisions() # every source rewrite observed, with the
f1verse.vintage(rec) # superseded body when it was small enoughThere is deliberately no as_of= time travel: f1verse can tell you what
it sees now and when it saw a value change, not reconstruct a value
nobody here ever fetched.
How the race actually unfolded
race = f1verse.load(2025, 24)
race.running_order()[30]
# ['PIA', 'VER', 'NOR', 'LEC', 'RUS', ...] who was where, lap by lap
race.position_changes()[1]
# {'lap': 2, 'moves': 18, 'biggest': {'abbr': 'PIA', 'gained': 17,
# 'from': 19, 'to': 2}}
race.battles()[0]
# {'ahead': 'HAD', 'behind': 'OCO', 'from': 2, 'to': 14, 'laps': 13,
# 'closest': 0.529} <- a thirteen-lap fight the results table hidesbattles finds pairs that held consecutive positions within 1.5 s for at
least three laps. A scrap for eighth that ran a third of the race never
shows up in a classification; it is often the best part of the afternoon.
Races from before the live feeds
old = f1verse.load_archive(2008, 18) # Brazil, the last-corner title
old.coverage
# {'lap_times': True, 'pit_stops': False, 'stints': False,
# 'note': 'lap times only'}
old.leader_runs()
# [{'abbr': 'MAS', 'from': 1, 'to': 9}, {'abbr': 'TRU', 'from': 10, 'to': 11},
# {'abbr': 'MAS', 'from': 12, 'to': 38}, ...]
old.laps_led() # {'MAS': 64, 'TRU': 2, 'ALO': 2, 'RAI': 3}The coverage block is not decoration. 2008 has no stint data anywhere, so
ArchiveRace has no stints() — rather than returning an empty dict that
reads like "no pit stops happened". What the era recorded, you get; what it
did not, it says.
Seasons against each other
f1verse.season_shape(2025)
# {'rounds': 24, 'final_margin': 2.0,
# 'lead_changes': [{'round': 5, 'from': 'NOR', 'to': 'PIA'},
# {'round': 20, 'from': 'PIA', 'to': 'NOR'}], ...}
f1verse.title_margins(top=5)
# 2025 NOR 423.0 vs VER 421.0 margin 2.0 (0.08 of a win)
# 2008 HAM 98.0 vs MAS 97.0 margin 1.0 (0.10 of a win)
# 2012 VET 281.0 vs ALO 278.0 margin 3.0 (0.12 of a win)Points systems changed repeatedly, so a raw margin cannot compare eras — one point in 1958 was most of a win. Every row also carries the gap measured in wins, which is the comparison that survives the rule changes.
Where the passing happened
f1verse.overtake_hotspots(race)[0]
# {'from_s': 3510.0, 'to_s': 3540.0, 'signals': 69, 'drivers': [...]}The timing feed publishes an OvertakeState per car that almost never
changes — about a hundred transitions in nineteen thousand records. That
sparsity is the value: the transitions are a free index of the moments worth
looking at, from the same feed that times the race. Read it as "something
happened here", then confirm against running_order.
Beyond a single race
f1verse.career("max_verstappen")
# {'starts': 245, 'wins': 71, 'podiums': 131, 'poles': 48, ...} 1950-present
f1verse.milestones("max_verstappen")
# [{'stat': 'poles', 'current': 48, 'target': 50, 'remaining': 2}]
f1verse.circuit_profile(2026, 13)
# corners, marshal sectors, track outline, and pit loss split by track state
# {'normal': 25.43, 'sc': 16.11, 'vsc': 18.4} <- what an undercut costs here
# plus historic record: 75 races held, pole-to-win rate 0.30
# Geometry is also interpreted, but never overclaimed: every corner carries
# its lap position, preceding-run share and local heading deflection; mini-
# and marshal-sector boundaries carry lap percentages.
profile = f1verse.circuit_profile(2026, 13)
profile["layout"]["corners"][0]
# {'number': 1, 'progress_pct': 8.412, 'local_deflection_deg': 72.6, ...}
# What a map cannot say, the cars can. This measures the circuit from the
# session's own telemetry: the height profile, where overtakes actually
# happen, how much of the lap is flat out and where it is braked, and every
# numbered corner as the car experienced it.
f1verse.circuit_survey(2026, 13)["corners"]["corners"][0]
# {'corner': 1, 'apex_speed_kph': 103, 'radius_m': 40.0,
# 'lateral_load_g': 2.09, 'gear_at_apex': 2, 'severity': 'medium'}
# Published specifications are stored rather than derived, and the
# measurement audits them rather than replacing them.
f1verse.circuit_profile(2026, 13, measure=True)["audit"]
# {'verdict': 'agrees', 'checked_age_days': 0,
# 'checks': [{'field': 'length_m', 'published': 4259, 'measured': 4274.4,
# 'off_by_percent': 0.36, 'state': 'agrees'}, ...]}
# The published facts and the audit are reachable on their own, so a caller
# can ask what is claimed without paying for a telemetry survey.
f1verse.circuit_facts("Austin")
# {'length_m': 5513, 'race_laps': 56, 'race_distance_km': 308.405,
# 'provenance': {'length_m': 'curated', ...},
# 'source': 'formula1.com official circuit page, 2026 united-states',
# 'checked': '2026-09-01'}
# None for a circuit nobody has curated yet - it does not invent a length
f1verse.circuit_audit(2026, 13)
# the same verdict as profile(measure=True)["audit"], on its own
f1verse.circuit_directory()
# every venue recorded in F1 results, with stable id, city, country and
# coordinates; unlike a current map, it does not pretend an old layout has
# today's geometry
f1verse.circuit_history("monza")
# every F1 event at the venue, recent winners and starting positions,
# pole-to-win conversion, and the drivers with the most wins
f1verse.head_to_head(2026)
# teammate quali/race scores per constructor
f1verse.standings(2026)Tyre life, and what the stewards struck out
Fuel load is not observed. For 2026 onward, stint_degradation returns a raw
clean-lap trend and declines fuel-corrected wear unless you supply an explicit
fuel_model scenario. Earlier seasons retain labelled legacy assumptions.
tyre_outlook is a constant-trend scenario, not measured physical tyre life.
stints = f1verse.stint_degradation(race)
# Each row includes raw_trend_s_per_lap, fuel_model, evidence and sample size.
f1verse.circuit_abrasion(race)
# 2026+ without a fuel scenario: factor=None, verdict='unknown', with a reason.
f1verse.tyre_outlook(race) # projected to the cliffA car's fuel burn can mask tyre wear. Corrected rates use a declared fuel
scenario and clean laps only. Assumptions and sensitivity accompany the
number. A stint with too few laps returns
{'degradation_s_per_lap': None, 'reason': 'too few clean laps'} rather
than a number fitted to noise.
f1verse.lap_deletions(session.race_control)
# [{'car_number': 55, 'lap_time': '1:25.773', 'stands': True,
# 'reason': 'TRACK LIMITS AT TURN 3 LAP 3', ...}]A reinstated lap keeps the reversal visible instead of being quietly dropped. Check this before treating a fastest lap or a qualifying position as settled.
Live timing, straight off the wire
from f1verse.sources import liveclient
with liveclient.LiveFeed() as feed:
for topic, patch, stamp in feed.messages():
...
liveclient.run("session-{n}.jsonl") # record, rotate on turnover, reconnectThe official SignalR feed over a WebSocket written in the standard library — no websocket package, no SignalR client. Connecting takes three undocumented courtesies (an affinity cookie only handed to a pre-flight request, the official application's user agent, an invocation id on the subscription); they live in one place so no caller rediscovers them.
Recorded frames carry a millisecond arrival stamp — the difference
between an archive and a screenshot — so replay() runs a session back at
true speed. The stream is not a lap table, so
f1verse.sources.timing.laps_from_stream rebuilds one: arrival order
lies, sector times land after the next lap has begun, and qualifying
carries phantom lap times that are really the gap between two runs. Every
rebuilt lap row carries its provenance.
Running this on a schedule
f1verse.status(2026)
# {'latest_race': {'round': 12, 'meeting': 'Dutch Grand Prix'},
# 'next': {'round': 13, 'session': 'Practice 1'}, 'next_in_hours': 125.7}
f1verse.due(2026, processed=[...session keys you already handled...])
# sessions finished, settled (45 min past the flag) and not yet processed —
# nothing published twice, nothing missed after downtimeCaching is policy-driven, not blanket: lap and telemetry data is immutable
and cached forever, schedules expire every few hours — a calendar cached
for a season would hide a cancelled round for the rest of the year — and
rows the stewards can still rewrite expire until the session is final.
f1verse.cache_info() and f1verse.clear_cache(older_than=...) are there
for operators; clear_cache never drops the revision journal.
Telemetry, track position, conditions
f1verse.lap_telemetry(race, "NOR", 40)
# per-sample speed, throttle, brake, gear, RPM and DRS state for one lap
f1verse.lap_trace(race, "NOR", 40) # x/y/z coordinates of that lap
f1verse.top_speeds(race) # fastest reading per driver
f1verse.weather_summary(race)
# {'track_c': {'min': 25.8, 'max': 38.2}, 'rain': True, 'samples': 191}Telemetry is high-frequency, so these take a bounded window and filter server-side rather than downloading a session and trimming it locally.
Grounded narration
facts = f1verse.race_facts(race) # all numbers computed and formatted here
f1verse.brief(race) # deterministic text, no model required
result = f1verse.narrate(
race,
generate=lambda prompt: my_model(prompt),
cache_dir=".cache/narration",
)
# {'text': '...', 'source': 'generated' | 'cache' | 'template', ...}narrate accepts any text-generation callback; f1verse has no model SDK
dependency. The callback selects IDs from fact_catalog(facts) by returning
JSON such as {"fact_ids": ["result.winner", "led.NOR"]}. Python renders the
selected facts. A limited grammar of exact fact-bound phrases is also accepted;
arbitrary free prose is not verified. Generation is retried at most twice,
and a deterministic summary is returned if verification still fails. The
optional cache is exact-match only and stores verified text.
Who wins the championship — and who still can
Two different questions, and mixing them is how a projection ends up implying somebody is out when the arithmetic says otherwise.
f1verse.title_scenarios(2026)
# arithmetic, not a forecast — maximum points left is a fixed number
# {'rounds_left': 11, 'sprints_left': 1, 'max_points_available': 283,
# 'drivers': [{'driver': 'RUS', 'gap_to_leader': 59.0,
# 'still_possible': True, 'needs_avg_per_round': 5.4}, ...],
# 'still_alive': 23}
f1verse.championship_projection(2026)
# the rest of the season, played out 20,000 times
# {'drivers': [{'driver': 'ANT', 'title_probability': 0.954,
# 'points_now': 242.0, 'projected_points_median': 446,
# 'projected_points_p10': 390, 'projected_points_p90': 490,
# 'races_in_sample': 11, 'measured_dnf_rate': 0.08}, ...],
# 'assumptions': {'ignores': ['car development', 'weather', ...], ...}}A simulated finish is resampled from the positions that driver has
actually finished in, not drawn from a curve around their average. The
distinction decides championships: alternating wins and retirements is a
different proposition from finishing fourth every weekend, and the mean
is the same for both. Retirement uncertainty uses a declared Beta prior;
sprints draw their own outcomes and score on their own table. The model's
countback and other limitations are listed in assumptions.
Every run also re-draws the driver's own level first, bootstrapping their results before playing the season against that version of them — twelve races is a small sample, and treating it as settled truth is how a forecast becomes more confident than anyone should be.
report = f1verse.backtest_projection(checkpoints=[4, 8, 12])
report["scores"] # multiclass Brier, log loss and calibration
report["uniform_baseline"] # same cases and field
report["points_interval"] # coverage, width and central 80% interval score
report["excluded"] # failed or incomplete cases remain visibleThese are replays using today's corrected data and calendar, not a record of predictions issued at the time. Multiple checkpoints in one season are dependent; the effective sample is seasons, not the number of driver probabilities.
Evidence-linked changes
race.events() # stable IDs, revisions and source references
race.turning_points(limit=5) # retrospective candidates; explicit heuristic
f1verse.pace_changes(race) # persistent shifts; no inferred cause
f1verse.retirement_risk([race]) # descriptive survival; finishers censored
f1verse.source_status() # last observed access state, no network probepace_changes compares adjacent clean-lap windows without crossing excluded or
missing laps. It uses future laps, so it is not a live detector. Neither a gap
change nor a pace shift identifies a causal effect. Survival uses completed-lap
exposure and all-cause DNF flags; it does not identify physical tyre life.
championship_prediction(infeeds) is a different thing — F1's own live "if it ended now" table.championship_projectionis this model. One reports, the other forecasts.
Predictions, pit-stop verdicts, official documents
f1verse.win_probabilities({"NOR": 1, "ANT": 2, "RUS": 3},
year=2026, upto_round=12, circuit_id="monza")
# every probability ships with its own evidence:
# grid base rate measured over 233 real races (pole wins 54.1%)
# blended with that circuit's pole-to-win conversion (Monza: 0.30)
# scaled by recent form (average finish over the last 5 rounds)
f1verse.pit_exchanges(race, pit_loss_s=22.74)
# [{'lap': 17, 'driver': 'RUS', 'rival': 'PIA', 'verdict': 'worked',
# 'gain_s': 3.54}, ...]
# neutralised laps (red flag / SC / VSC) and same-lap covering stops are
# excluded — calling those undercuts would be wrong
f1verse.fia_documents(2026) # stewards' decisions, classified
f1verse.power_unit_documents(2026) # "who changed which engine part"Why this exists
Raw timing data needs a lot of domain knowledge before it means anything:
Classified gaps are not comparable across lapped cars. A car one lap down can show a smaller number than one that finished ahead on the lead lap. →
format_gapapplies the broadcast convention (+1 LAP)."Who led the race" has to be derived. Lead changes, laps led and the moments they happened are not published as such. →
leader_runs,laps_led,timeline.Race pace needs rules, not just a threshold: in/out laps and laps run under SC/VSC have to go, or the number is meaningless. →
race_paceapplies them by default.Web and video pipelines need plain JSON. Every f1verse output is JSON-safe Python, ready to serialise.
Data quality should be checkable in code, not read from logs. →
crosscheckandquality_reportreturn structured verdicts.Results change after the flag. A cache that treats a classification as immutable makes a stewards' decision invisible. → revisable rows expire until the session is final; changes are recorded.
Related MCP server: f1-mcp-server
Additional live-timing feeds
The official live-timing archive publishes several feeds that are rarely surfaced. f1verse parses three of them, with the same caching and rate-limit etiquette as the rest of the library:
f1verse.championship_prediction(session)
# per-lap "if the race ended now" projection of both championships,
# including the moments the projected champion changed
f1verse.team_radio(session)
# timestamped team-radio clips: [{'t', 'utc', 'driver_number', 'url'}]
# URLs only — nothing is downloaded or redistributed
f1verse.timing_stats(session)
# personal bests, best sectors, speed-trap figuresRunning continuously
See OPERATIONS.md for caching policy, rate limits and scheduling.
Tests
pip install -e ".[test]" && pytest -qSources
Layer | What it gives |
Race data | laps, stints, pits, positions, results, overtakes |
Live-timing archive | championship projection, team radio, timing stats |
Historic records | careers, circuit records, standings — 1950 onward |
Circuit geometry | track outline, corners, marshal sectors, pit loss |
All are public endpoints, read at runtime. See src/f1verse/sources/ for
the exact hosts, and NOTICE for how upstream data rights relate to this
project's own license.
Design rules
Zero required dependencies. The native loader reads public REST endpoints and the official live-timing archive directly, with its own on-disk cache and polite pacing.
Everything returned is plain JSON-safe Python.
F1 domain rules are defaults, not options.
Cross-checked where possible — lapped-car gaps, for instance, are computed by convention and confirmed against a second source.
Code only. No timing data, media, or images are bundled or redistributed; data is fetched by the end user.
License
Apache-2.0. See LICENSE and NOTICE.
Use it privately or commercially; read it, change it, redistribute it, and build products or hosted services on it. Preserve the license and notices, state significant changes, and observe the license's patent terms. There is no source-disclosure requirement for software or services that use f1verse.
This license covers f1verse's own source. The Formula 1 data it reads at runtime belongs to its respective rights holders under their own terms.
Roadmap
Broader cross-validation coverage
Deviation detection: expected range, actual, evidence
Localisation packages
Unofficial fan project. Not affiliated with, endorsed by, or associated with Formula 1, FIA, FOM, or any F1 team. F1, FORMULA 1 and related marks are trademarks of Formula One Licensing BV. This library contains code only — no timing data, media, or images are included or redistributed; data is fetched by the end user from publicly accessible endpoints, subject to the respective providers' terms.
Available Tools
26 toolsf1_archive_raceA race from 1996-2022, before the live-timing feeds.ARead-onlyIdempotent
A race from 1996-2022, before the live-timing feeds. Results, lap-by-lap running order, lead changes and laps led for the seasons the modern feeds do not cover. Pit stops are included from 2011. The reply carries a 'coverage' block naming exactly what that era does and does not hold, so an absent field is never mistaken for a zero. Use f1_race_story for 2023 onward — it knows strictly more.
Inputs: year (required), round (required). Returns: result
f1_battlesPairs that ran nose-to-tail, and for how long.ARead-onlyIdempotent
Pairs that ran nose-to-tail, and for how long. Every stretch where two cars held consecutive positions within 1.5 seconds for at least three laps, with the closest the gap got. Finds the fights a results table hides — a scrap for eighth that ran twenty laps never shows up in the standings.
Inputs: year (required), round (required). Returns: result
f1_circuit_directoryEvery Formula 1 venue recorded in the historical results.ARead-onlyIdempotent
Every Formula 1 venue recorded in the historical results. A source-labelled directory of circuit ids, names, cities, countries and coordinates from 1950 to today. This is the discovery call for a historic venue; pass its id to f1_circuit_history for results, and use f1_circuit_profile with a year and round when the question needs that event's specific layout.
Inputs: no named parameters. Returns: result
f1_circuit_historyA Formula 1 venue's winners, pole conversion and records.ARead-onlyIdempotent
A Formula 1 venue's winners, pole conversion and records. Historical results at one circuit: every event count, recent winners and their starting positions, pole-to-win conversion, and the most successful drivers. Use f1_circuit_directory first to discover the stable circuit id; this is results history, so it does not assign a modern map to an older layout.
Inputs: circuit_id (required). Returns: result
f1_circuit_profileA circuit's layout, pit-loss economics and historical record.ARead-onlyIdempotent
A circuit's layout, pit-loss economics and historical record. Geometry, corner-by-corner lap position and local heading change, mini-sector and marshal-sector boundaries, pit loss under green/SC/VSC, a reference lap, and historical outcomes in one evidence-labelled profile. Coordinate length is explicitly not presented as surveyed metres; absent elevation, width and DRS geometry are named rather than guessed. Use this for a race-preview track explainer.
Inputs: year (required), round (required). Returns: result
f1_circuit_surveyThe circuit measured from the cars that drove it.ARead-onlyIdempotent
The circuit measured from the cars that drove it. What no public circuit map carries, measured from telemetry instead: the height profile with gradients and total climb; where overtakes actually happen, clustered into zones and merged across the timing line; how much of the lap is spent at full throttle and where the braking zones are, with entry and minimum speeds; the width of road the field used and the camber of it. DRS zones are included for seasons that had DRS and reported as a regulation change, not a weather excuse, for those that do not. Every figure names the laps and drivers behind it and declines rather than guesses when the samples cannot support it. Use for track explainers and previews that need real numbers, not an outline.
Inputs: year (required), round (required). Returns: result
f1_closest_titlesChampionships ranked by how close they finished.ARead-onlyIdempotent
Championships ranked by how close they finished. The smallest title margins in history, measured both in points and relative to what a win was worth that season — the only way seasons decades apart compare honestly, since two points in 1958 is most of a win and two points today is not.
Inputs: top. Returns: result
f1_data_qualityIs this session's data complete, current and safe to publish?ARead-onlyIdempotent
Is this session's data complete, current and safe to publish? Completeness per field, how old the fetched copy is, whether the classification is still provisional (stewards rewrite results hours after the flag), corrections observed so far, agreement between independent sources, and a single 'publishable' verdict. Call this before stating a result as final, especially within a few hours of a session ending.
Inputs: year (required), round (required), session. Returns: result
f1_deleted_lapsLap times the stewards struck out, with reinstatements.ARead-onlyIdempotent
Lap times the stewards struck out, with reinstatements. Every lap-time deletion race control announced in a session, with the car, the time, the stated reason, and whether the deletion still stands — a reinstated lap is reported with the reversal visible rather than silently dropped. Use before treating a fastest lap or a qualifying position as settled.
Inputs: year (required), round (required), session. Returns: result
f1_driver_careerA driver's career totals, 1950 to today.ARead-onlyIdempotent
A driver's career totals, 1950 to today. Starts, wins, podiums, poles and points for one driver across all of F1 history, plus the next round-number milestones they are approaching. Takes an Ergast-style driver id such as 'max_verstappen', 'hamilton' or 'leclerc'.
Inputs: driver_id (required). Returns: result
f1_highlightsThe stretches of a race worth watching.ARead-onlyIdempotent
The stretches of a race worth watching. Windows where the timing feed's own passing signals cluster, ranked by density. An editing index rather than a verdict — it says where cars were changing state, not that a pass completed. 2023 onward.
Inputs: year (required), round (required). Returns: result
f1_pace_changesPersistent retrospective pace shifts within clean stints.CRead-onlyIdempotent
Persistent retrospective pace shifts within clean stints. Adjacent clean-lap windows, with trend removed, detect pace changes. Excluded laps are boundaries; the method does not identify a cause.
Inputs: year (required), round (required). Returns: result
f1_race_briefA short factual race summary in plain English.ARead-onlyIdempotent
A short factual race summary in plain English. A publishable prose summary of a race, built from templates only — every number in it comes from the data, so it is safe to quote verbatim. Use when the user wants a readable recap rather than fields to compute with.
Inputs: year (required), round (required). Returns: result
f1_race_eventsEvidence-linked race and pit-cycle events.ARead-onlyIdempotent
Evidence-linked race and pit-cycle events. Stable event IDs, input lineage and observed gap changes. No causal strategy claim or media download.
Inputs: year (required), round (required). Returns: result
f1_race_storyEverything that happened in one race, as structured JSON.ARead-onlyIdempotent
Everything that happened in one race, as structured JSON. The whole race in one call: final results with broadcast-convention gaps, lead changes, laps led per driver, the event timeline, tyre stints, median race pace (pit/SC/VSC laps excluded), and safety-car interruptions. Use this first for any 'what happened in race X' question — it is one request instead of six.
Inputs: year (required), round (required). Returns: result
f1_retirement_riskObserved retirement survival across selected settled races.ARead-onlyIdempotent
Observed retirement survival across selected settled races. All-cause Kaplan-Meier over completed laps. Finishes are censored. Not a calibrated future reliability forecast; causes are unavailable.
Inputs: year (required), rounds (required). Returns: result
f1_running_orderWho was where at the end of every lap.ARead-onlyIdempotent
Who was where at the end of every lap. The order on track lap by lap, plus how much each lap churned and who made the biggest single gain. This is the data behind any position-change chart; use it for 'how did the race unfold' rather than fetching results and guessing.
Inputs: year (required), round (required). Returns: result
f1_season_shapeHow a championship unfolded, round by round.BRead-onlyIdempotent
How a championship unfolded, round by round. Each contender's running points total, who led after every round, and where the lead changed hands. Two seasons can end on the same margin and look nothing alike; this is what tells a procession from a fight.
Inputs: year (required). Returns: result
f1_season_statusWhere the season stands right now and what is next.ARead-onlyIdempotent
Where the season stands right now and what is next. The latest completed race, sessions that have finished and settled, the next session and how many hours until it starts. Use this to answer 'when is the next race' or to resolve 'the last race' into a concrete round number before calling the other tools.
Inputs: year (required). Returns: result
f1_session_resultsClassification for any session of a weekend.ARead-onlyIdempotent
Classification for any session of a weekend. Results for one session, classified the way that kind of session actually is: races give position and gap (lapped cars as '+1 LAP'), qualifying gives per-segment times with gaps to that segment's fastest and where each driver was eliminated, practice gives a best-lap table.
Inputs: year (required), round (required), session. Returns: result
f1_source_statusLast observed access state for each data source.ARead-onlyIdempotent
Last observed access state for each data source. No network probe. Distinguishes authentication, rate limits, availability and sources not yet checked in this process.
Inputs: no named parameters. Returns: result
f1_standingsChampionship standings after the latest completed round.BRead-onlyIdempotent
Championship standings after the latest completed round. Drivers' or constructors' championship table, with points and wins, as of the most recent round that has been scored.
Inputs: year (required), kind. Returns: result
f1_title_raceChampionship win probability, and who is still mathematically alive.ARead-onlyIdempotent
Championship win probability, and who is still mathematically alive. Two answers to 'who wins the title', kept deliberately apart. First the arithmetic: maximum points still available, and who is therefore out for certain — a fact, not a forecast. Then the projection: the rest of the season simulated thousands of times, resampling each driver from the positions they have actually finished in, with retirements at their measured rate. Every run first re-draws the driver's own level, so a short season widens the answer rather than hiding inside it. Returns the assumptions and sample sizes it stands on; the same seed returns the same numbers.
Inputs: year (required), runs. Returns: result
f1_turning_pointsRanked retrospective race turning-point candidates.ARead-onlyIdempotent
Ranked retrospective race turning-point candidates. Ranks observed events by an explicit fixed event-kind heuristic. Uses future race information; not a live forecast or win-value model.
Inputs: year (required), round (required), limit. Returns: result
f1_tyre_wearHow fast each set of tyres degraded, stint by stint.ARead-onlyIdempotent
How fast each set of tyres degraded, stint by stint. Raw clean-stint lap-time trends and fuel-scenario corrected degradation, with exclusions, sample sizes and sensitivity. 2026+ corrected wear requires an explicit fuel_model; without it only raw trends are available. Earlier default coefficients are illustrative assumptions, not measured fuel. Circuit abrasion is a scenario index, not a measured surface property.
Inputs: year (required), round (required), fuel_model. Returns: result
f1_weekend_sessionsWhich sessions a given round has, in order.ARead-onlyIdempotent
Which sessions a given round has, in order. Lists the sessions of a race weekend with start and end times — the valid inputs for the 'session' argument of the other tools. Call this when unsure whether a round was a sprint weekend.
Inputs: year (required), round (required). Returns: result
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
TDQS
Scored across 26 tools
Descriptions carefully carve out boundaries, but several clusters overlap heavily: f1_race_story aggregates results, running order, timeline and stints that f1_session_results, f1_running_order and f1_race_events also expose. Likewise f1_race_events vs f1_turning_points, and f1_circuit_profile vs f1_circuit_survey vs f1_circuit_history, require reading long descriptions to choose correctly. The guidance is good, but an agent can still reasonably hesitate among multiple 'what happened' or 'circuit' tools.
Every name uses the same f1_ prefix and snake_case, and follows a predictable f1_<domain>_<object> style. The names are mostly noun phrases rather than verb_noun actions, but the convention is consistent throughout with only minor semantic variation (e.g. f1_closest_titles, f1_season_shape).
At 26 tools the surface is heavy, well above the comfortable 3-15 range. The breadth of F1 analysis, history and circuit data justifies many of them, but some analytics variants could be consolidated or exposed as options on fewer tools. It is borderline rather than clearly excessive.
Coverage is unusually broad: live/settled sessions, standings, race narratives, tyre and pace analysis, history, circuits and championship projections are all represented. Minor gaps remain around general driver/team directories, a full season calendar, and some race-control/penalty information beyond deleted laps, but agents can work around these.
Maintenance
Related MCP Connectors
Anonymous read-only Formula 1 tools, resources, prompts, completion, and interactive dashboard.
NFL analytics tools for AI agents: stats, fantasy, injuries, schedules, and advanced analysis.
Live sports stats and pre-computed analysis for AI assistants across NBA, MLB, NFL, and NHL.
Related MCP Servers
- AlicenseNot gradedqualityDmaintenanceEnables Formula 1 data analysis through natural language, providing tools like track dominance, lap time analysis, and team performance comparisons.Apache 2.0
- AlicenseNot gradedqualityDmaintenanceProvides comprehensive Formula 1 data and analytics for Claude Desktop, including race results, telemetry, standings, and strategy insights through 36+ tools.1MIT
- AlicenseNot gradedqualityDmaintenanceEnables AI assistants to query real-time and historical Formula 1 data through the OpenF1 API, providing tools for driver info, lap times, telemetry, race events, and more.MIT
- FlicenseNot gradedqualityDmaintenanceExposes Formula 1 historical data (race results, qualifying, pit stops, and championship standings) as callable tools for LLMs via the Jolpica-F1 API.-