get_driver_info

Instructions

Implementation Reference

• src/f1_mcp_server/f1_data.py:234-275 (handler)

  The actual implementation of get_driver_info: loads a session via FastF1, retrieves driver information using session.get_driver(), converts to JSON-serializable dict, and returns it wrapped in a status/data response.

  def get_driver_info(
      year: Any, event_identifier: str, session_name: str, driver_identifier: str
  ) -> dict[str, Any]:
      """
      Get information about a specific Formula One driver.
  
      Args:
          year (int or str): The year of the F1 season
          event_identifier (str): Event name or round number
          session_name (str): Session type (Race, Qualifying, Sprint, etc.)
          driver_identifier (str): Driver number, code, or name
  
      Returns:
          dict: Status and driver information or error information
      """
      try:
          # Validate year
          year_int = validate_year(year)
  
          logger.debug(
              f"Fetching driver info for {year_int}, "
              f"event: {event_identifier}, session: {session_name}, "
              f"driver: {driver_identifier}"
          )
          session = fastf1.get_session(year_int, event_identifier, session_name)
          # Load session without telemetry for faster results
          session.load(telemetry=False)
  
          driver_info = session.get_driver(driver_identifier)
  
          # Convert to JSON serializable format
          driver_dict = driver_info.to_dict()
          clean_dict = {k: json_serial(v) for k, v in driver_dict.items()}
  
          logger.info(f"Successfully retrieved driver info for {driver_identifier}")
          return {"status": "success", "data": clean_dict}
      except Exception as e:
          logger.error(f"Error retrieving driver info: {str(e)}", exc_info=True)
          return {
              "status": "error",
              "message": f"Failed to retrieve driver information: {str(e)}",
          }

• src/f1_mcp_server/server.py:347-384 (schema)

  Input schema/registration for get_driver_info tool: defines 4 required parameters (year, event_identifier, session_name, driver_identifier) and their descriptions and types.

  types.Tool(
      name="get_driver_info",
      description=("Get information about a specific Formula One driver"),
      inputSchema={
          "type": "object",
          "properties": {
              "year": {
                  "type": "number",
                  "description": "Season year (e.g., 2023)",
              },
              "event_identifier": {
                  "type": "string",
                  "description": (
                      "Event name or round number (e.g., 'Monaco' or '7')"
                  ),
              },
              "session_name": {
                  "type": "string",
                  "description": (
                      "Session name (e.g., 'Race', 'Qualifying', "
                      "'Sprint', 'FP1', 'FP2', 'FP3')"
                  ),
              },
              "driver_identifier": {
                  "type": "string",
                  "description": (
                      "Driver identifier (number, code, or name; "
                      "e.g., '44', 'HAM', 'Hamilton')"
                  ),
              },
          },
          "required": [
              "year",
              "event_identifier",
              "session_name",
              "driver_identifier",
          ],
      },

• src/f1_mcp_server/server.py:24-33 (registration)

  Import of get_driver_info from f1_data module into server.py, enabling its use as a registered tool.

  from .f1_data import (
      analyze_driver_performance,
      compare_drivers,
      get_championship_standings,
      get_driver_info,
      get_event_info,
      get_event_schedule,
      get_session_results,
      get_telemetry,
  )

• src/f1_mcp_server/f1_data.py:66-87 (helper)

  The validate_year helper function used by get_driver_info to validate the year parameter.

  def validate_year(year: Any) -> int:
      """
      Validate that the provided year is valid for F1 data.
  
      Args:
          year: Year value to validate
  
      Returns:
          Valid year as integer
  
      Raises:
          ValueError: If year is invalid
      """
      try:
          year_int = int(year)
          # F1 started in 1950 and we don't want future years far ahead
          current_year = datetime.now().year
          if year_int < 1950 or year_int > current_year + 1:
              raise ValueError(f"Year must be between 1950 and {current_year + 1}")
          return year_int
      except (ValueError, TypeError) as e:
          raise ValueError(f"Invalid year format: {year}") from e

• src/f1_mcp_server/f1_data.py:45-63 (helper)

  The json_serial helper function used by get_driver_info to convert non-JSON-serializable objects (datetime, numpy types, NaN) to JSON-compatible values.

  def json_serial(obj: Any) -> str | int | float | None:
      """
      Convert non-JSON serializable objects to strings.
  
      Args:
          obj: Object to be serialized to JSON
  
      Returns:
          JSON serializable representation of the object
      """
      if isinstance(obj, datetime | pd.Timestamp):
          return obj.isoformat()
      if isinstance(obj, np.integer):
          return int(obj)
      if isinstance(obj, np.floating):
          return float(obj)
      if pd.isna(obj) or obj is None:
          return None
      return str(obj)