cleaned up track visualization by removing the driver and automatically picking the fastest lap for the race. Now both speed and gear have a nice legend that is under the image

README.md

@@ -8,7 +8,7 @@ sdk_version: 5.32.0
 app_file: app.py
 pinned: true
 license: apache-2.0
-short_description: 'Historical & real-time F1 data and strategy'
+short_description: 'Historical & real-time F1 data retrieval with agentic race strategy capabilities'
 video_url: TBD
 tags:
   - 'mcp-server-track'

api_playground.ipynb

@@ -32,6 +32,118 @@
     "# FastF1"
    ]
   },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "2a205292",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "core           INFO \tLoading data for Australian Grand Prix - Race [v3.5.3]\n",
+      "req            INFO \tUsing cached data for session_info\n",
+      "req            INFO \tUsing cached data for driver_info\n",
+      "req            INFO \tUsing cached data for session_status_data\n",
+      "req            INFO \tUsing cached data for lap_count\n",
+      "req            INFO \tUsing cached data for track_status_data\n",
+      "req            INFO \tUsing cached data for _extended_timing_data\n",
+      "req            INFO \tUsing cached data for timing_app_data\n",
+      "core           INFO \tProcessing timing data...\n",
+      "req            INFO \tUsing cached data for car_data\n",
+      "req            INFO \tUsing cached data for position_data\n",
+      "req            INFO \tUsing cached data for weather_data\n",
+      "req            INFO \tUsing cached data for race_control_messages\n",
+      "core        WARNING \tDriver 4 completed the race distance 00:00.022000 before the recorded end of the session.\n",
+      "core           INFO \tFinished loading data for 20 drivers: ['4', '1', '63', '12', '23', '18', '27', '16', '81', '44', '10', '22', '31', '87', '30', '5', '14', '55', '7', '6']\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Index(['Time', 'Driver', 'DriverNumber', 'LapTime', 'LapNumber', 'Stint',\n",
+      "       'PitOutTime', 'PitInTime', 'Sector1Time', 'Sector2Time', 'Sector3Time',\n",
+      "       'Sector1SessionTime', 'Sector2SessionTime', 'Sector3SessionTime',\n",
+      "       'SpeedI1', 'SpeedI2', 'SpeedFL', 'SpeedST', 'IsPersonalBest',\n",
+      "       'Compound', 'TyreLife', 'FreshTyre', 'Team', 'LapStartTime',\n",
+      "       'LapStartDate', 'TrackStatus', 'Position', 'Deleted', 'DeletedReason',\n",
+      "       'FastF1Generated', 'IsAccurate'],\n",
+      "      dtype='object')\n",
+      "    Driver DriverNumber             Team\n",
+      "0      VER            1  Red Bull Racing\n",
+      "1      VER            1  Red Bull Racing\n",
+      "2      VER            1  Red Bull Racing\n",
+      "3      VER            1  Red Bull Racing\n",
+      "4      VER            1  Red Bull Racing\n",
+      "..     ...          ...              ...\n",
+      "922    BEA           87     Haas F1 Team\n",
+      "923    BEA           87     Haas F1 Team\n",
+      "924    BEA           87     Haas F1 Team\n",
+      "925    BEA           87     Haas F1 Team\n",
+      "926    BEA           87     Haas F1 Team\n",
+      "\n",
+      "[927 rows x 3 columns]\n"
+     ]
+    }
+   ],
+   "source": [
+    "session = fastf1.get_session(2025, 1, \"race\")\n",
+    "session.load()\n",
+    "print(session.laps.columns)\n",
+    "print(session.laps[[\"Driver\", \"DriverNumber\", \"Team\"]])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "44f7516f",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Time                      0 days 02:28:03.586000\n",
+      "Driver                                       NOR\n",
+      "DriverNumber                                   4\n",
+      "LapTime                   0 days 00:01:22.167000\n",
+      "LapNumber                                   43.0\n",
+      "Stint                                        5.0\n",
+      "PitOutTime                                   NaT\n",
+      "PitInTime                                    NaT\n",
+      "Sector1Time               0 days 00:00:28.553000\n",
+      "Sector2Time               0 days 00:00:18.537000\n",
+      "Sector3Time               0 days 00:00:35.077000\n",
+      "Sector1SessionTime        0 days 02:27:10.030000\n",
+      "Sector2SessionTime        0 days 02:27:28.567000\n",
+      "Sector3SessionTime        0 days 02:28:03.644000\n",
+      "SpeedI1                                    271.0\n",
+      "SpeedI2                                    290.0\n",
+      "SpeedFL                                    292.0\n",
+      "SpeedST                                    300.0\n",
+      "IsPersonalBest                              True\n",
+      "Compound                                    HARD\n",
+      "TyreLife                                    10.0\n",
+      "FreshTyre                                  False\n",
+      "Team                                     McLaren\n",
+      "LapStartTime              0 days 02:26:41.419000\n",
+      "LapStartDate          2025-03-16 05:34:04.038000\n",
+      "TrackStatus                                    1\n",
+      "Position                                     1.0\n",
+      "Deleted                                    False\n",
+      "DeletedReason                                   \n",
+      "FastF1Generated                            False\n",
+      "IsAccurate                                  True\n",
+      "Name: 635, dtype: object\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(session.laps.pick_fastest())"
+   ]
+  },
   {
    "cell_type": "code",
    "execution_count": 2,

app.py

@@ -91,11 +91,10 @@ iface_track_visualization = gr.Interface(
         gr.Number(label="Calendar year", value=CURRENT_YEAR, minimum=1950, maximum=CURRENT_YEAR),
         gr.Textbox(label="Grand Prix", placeholder="Ex: Monaco", info="The name of the GP/country/location (Fuzzy matching supported) or round number"),
         gr.Radio(["speed", "corners", "gear"], label="Visualization type", value="speed", info="What type of track visualization to generate"),
-        gr.Dropdown(label="Driver", choices=DRIVER_NAMES, info="Only applied for speed visualization. gear uses fastest lap during race.")
     ],
     outputs="image",
     title="Track Visualizations",
-    description="Get the track visualization for the given Grand Prix. Example: (2025,Monaco,speed,Leclerc)"
+    description="Get the track visualization (speed/corners/gear) for the given Grand Prix race. Example: (2025,Monaco,speed)"
 )
 
 iface_session_results = gr.Interface(
@@ -121,7 +120,7 @@ iface_driver_info = gr.Interface(
     ],
     outputs="text",
     title="Driver Info",
-    description="Get background information about a specific driver"
+    description="Get background information about a specific driver from the 2025 Formula 1 season"
 )
 
 iface_constructor_info = gr.Interface(
@@ -131,7 +130,7 @@ iface_constructor_info = gr.Interface(
     ],
     outputs="text",
     title="Constructor Info",
-    description="Get background information about a specific constructor"
+    description="Get background information about a specific constructor from the 2025 Formula 1 season"
 )
 
 

fastf1_tools.py

@@ -155,14 +155,13 @@ def constructor_championship_standings(year: int, constructor_name: str) -> str:
     standings_string = f"{constructor_name} {are_were} {constructor_standing['position'].iloc[0]}{suffix} with {constructor_standing['points'].iloc[0]} points and {constructor_standing['wins'].iloc[0]} wins"
     return standings_string
 
-def track_visualization(year: int, round: gp, visualization_type: str, driver_name: str) -> Image.Image:
+def track_visualization(year: int, round: gp, visualization_type: str) -> Image.Image:
     """Generate a visualization of the track with specified data.
     
     Args:
         year (int): The season year
         round (str | int): The race round number or name
         visualization_type (str): Type of visualization ('speed', 'corners', or 'gear')
-        driver_name (str): Name of the driver for driver-specific visualizations
         
     Returns:
         Image.Image: A PIL Image object containing the visualization
@@ -174,7 +173,7 @@ def track_visualization(year: int, round: gp, visualization_type: str, driver_na
     session.load()
 
     if visualization_type == "speed":
-        return track_utils.create_track_speed_visualization(session, driver_name)
+        return track_utils.create_track_speed_visualization(session)
     elif visualization_type == "corners":
         return track_utils.create_track_corners_visualization(session)
     elif visualization_type == "gear":

utils/constants.py

@@ -118,26 +118,35 @@ The implemented functions make it possible to:
 - Apply filters to an API string - `apply_filters(api_string, *filters)`
 - Send a request to the OpenF1 API - `send_request(api_string)`
 
+The inputs are strings while the output is a JSON object. The examples are listed in an order that would be expected to be used in a real-life scenario. Some example API strings are listed below in the last tool `send_request(api_string)`.
+
 """
 
+
 MARKDOWN_OPENF1_EXAMPLES = """
 
 ' Retrieve data about car number 55 with session_key 9159 where the speed was greater than 315 '
+
 ```https://api.openf1.org/v1/car_data?driver_number=55&session_key=9159&speed>=315```
 
 ' Retrieve data about driver number 1 with session_key 9158 '
+
 ```https://api.openf1.org/v1/drivers?driver_number=1&session_key=9158```
 
 ' Retrieve data about intervals with session_key 9165 where the interval was less than 0.005s'
+
 ```https://api.openf1.org/v1/intervals?session_key=9165&interval<0.005```
 
 ' Retrieve data about laps with session_key 9161 for driver number 63 on lap number 8'
+
 ```https://api.openf1.org/v1/laps?session_key=9161&driver_number=63&lap_number=8```
 
 ' Retrieve data about meetings in 2023 for Singapore'
+
 ```https://api.openf1.org/v1/meetings?year=2023&country_name=Singapore```
 
 ' Retrieve data about pit stops with session_key 9158 where the pit duration was less than 31s'
+
 ```https://api.openf1.org/v1/pit?session_key=9158&pit_duration<31```
 
 """

utils/track_utils.py

@@ -2,11 +2,11 @@ import matplotlib as mpl
 import numpy as np
 from matplotlib import pyplot as plt
 from matplotlib.collections import LineCollection
-import fastf1 as ff1
 from PIL import Image
 from io import BytesIO
 from typing import Union
 import json
+from fastf1.core import Session
 
 # Custom types
 gp = Union[str, int]
@@ -19,15 +19,10 @@ def rotate(xy, *, angle):
     return np.matmul(xy, rot_mat)
 
 
-
-def create_track_speed_visualization(session, driver_name: str) -> Image:
+def create_track_speed_visualization(session: Session) -> Image:
 
     weekend = session.event
-    session.load()
-    with open("assets/driver_abbreviations.json") as f:
-        driver_abbreviations = json.load(f)
-        driver_abbreviation = driver_abbreviations[driver_name]
-    lap = session.laps.pick_drivers(driver_abbreviation).pick_fastest()
+    lap = session.laps.pick_fastest()
 
     # Get telemetry data
     x = lap.telemetry['X']              # values for x-axis
@@ -40,7 +35,7 @@ def create_track_speed_visualization(session, driver_name: str) -> Image:
 
     # We create a plot with title and adjust some setting to make it look good.
     fig, ax = plt.subplots(sharex=True, sharey=True, figsize=(12, 6.75))
-    fig.suptitle(f'{weekend["EventName"]} - {driver_name} ', size=24, y=0.97)
+    fig.suptitle(f'[Speed] {weekend["EventName"]} - {lap["Driver"]} #{lap["DriverNumber"]} ', size=24, y=0.97)
 
     # Adjust margins and turn of axis
     plt.subplots_adjust(left=0.1, right=0.9, top=0.9, bottom=0.12)
@@ -67,6 +62,7 @@ def create_track_speed_visualization(session, driver_name: str) -> Image:
     normlegend = mpl.colors.Normalize(vmin=color.min(), vmax=color.max())
     legend = mpl.colorbar.ColorbarBase(cbaxes, norm=normlegend, cmap=mpl.colormaps['viridis'],
                                     orientation="horizontal")
+    legend.set_label("Speed [km/h]")
 
     # Create a PIL image from the plot
     fig = plt.gcf()
@@ -86,7 +82,7 @@ def create_track_speed_visualization(session, driver_name: str) -> Image:
     return img
 
 
-def create_track_corners_visualization(session) -> Image:
+def create_track_corners_visualization(session: Session) -> Image:
     
     lap = session.laps.pick_fastest()
     pos = lap.get_pos_data()
@@ -162,8 +158,8 @@ def create_track_corners_visualization(session) -> Image:
     return img
 
 
-def create_track_gear_visualization(session) -> Image:
-
+def create_track_gear_visualization(session: Session) -> Image:
+    weekend = session.event
     lap = session.laps.pick_fastest()
     tel = lap.get_telemetry()
 
@@ -174,39 +170,47 @@ def create_track_gear_visualization(session) -> Image:
     segments = np.concatenate([points[:-1], points[1:]], axis=1)
     gear = tel['nGear'].to_numpy().astype(float)
 
-    cmap = plt.cm.get_cmap('viridis', 8)
-    norm = plt.Normalize(1, 8)
-    lc_comp = LineCollection(segments, norm=norm, cmap=cmap)
+    fig, ax = plt.subplots(sharex=True, sharey=True, figsize=(12, 6.75))
+    fig.suptitle(f'[Gear] {weekend["EventName"]} - {lap["Driver"]} #{lap["DriverNumber"]}', size=24, x=0.5, ha='center', y=0.97)
+
+    plt.subplots_adjust(left=0.1, right=0.9, top=0.9, bottom=0.12)
+    ax.axis('off')
+
+    # Plot a background track line (black, thick) for context
+    ax.plot(lap.telemetry['X'], lap.telemetry['Y'],
+            color='black', linestyle='-', linewidth=16, zorder=0)
+
+    # Draw the colored segments
+    lc_comp = LineCollection(segments, norm=plt.Normalize(gear.min(), gear.max()), cmap=plt.cm.get_cmap('viridis', 8))
     lc_comp.set_array(gear)
     lc_comp.set_linewidth(4)
+    ax.add_collection(lc_comp)
 
-    plt.gca().add_collection(lc_comp)
-    plt.axis('equal')
-    plt.tick_params(labelleft=False, left=False, labelbottom=False, bottom=False)
+    # Set axis limits to the data range with padding to avoid clipping
+    x_pad = (x.max() - x.min()) * 0.03
+    y_pad = (y.max() - y.min()) * 0.03
+    ax.set_xlim(x.min() - x_pad, x.max() + x_pad)
+    ax.set_ylim(y.min() - y_pad, y.max() + y_pad)
 
-    plt.suptitle(
-        f"Fastest Lap Gear Shift Visualization\n"
-        f"{lap['Driver']} - {session.event['EventName']}"
-    )
+    # Set axis equal for correct aspect
+    ax.set_aspect('equal', adjustable='datalim')
 
-    cbar = plt.colorbar(mappable=lc_comp, label="Gear")
-    cbar.set_ticks(np.arange(1, 9))  # Set ticks at integer positions
-    cbar.set_ticklabels(np.arange(1, 9))  # Labels from 1 to 8
+    # Add colorbar at the bottom
+    cbaxes = fig.add_axes([0.25, 0.05, 0.5, 0.05])
+    normlegend = plt.Normalize(1, 8)
+    legend = mpl.colorbar.ColorbarBase(cbaxes, norm=normlegend, cmap=plt.cm.get_cmap('viridis', 8),
+                                       orientation="horizontal")
+    legend.set_ticks(np.arange(1, 9))
+    legend.set_ticklabels(np.arange(1, 9))
+    legend.set_label("Gear")
 
     # Create a PIL image from the plot
-    fig = plt.gcf()
-    
-    # Save the figure to a BytesIO buffer and convert to bytes
     buf = BytesIO()
     fig.savefig(buf, format='png', dpi=150, bbox_inches='tight')
     buf.seek(0)
-    
-    # Create PIL image from buffer bytes and close the figure
     img_data = buf.getvalue()
     plt.close(fig)
     buf.close()
-    
-    # Create new image from the raw bytes
     img = Image.open(BytesIO(img_data))
     return img