added tools for OpenF1 using tabs and blocks. Alot of examples of the different tools are provided, although the UI is not super user-friendly (expected due to is being pure API strings)

app.py

@@ -1,14 +1,16 @@
 import gradio as gr
-import pandas as pd
 
 # Local modules
 import fastf1_tools
+import openf1_tools
 from utils.constants import (
     DRIVER_NAMES,
     CONSTRUCTOR_NAMES,
     CURRENT_YEAR,
     DROPDOWN_SESSION_TYPES,
-    MARKDOWN_INTRODUCTION
+    MARKDOWN_INTRODUCTION,
+    MARKDOWN_OPENF1_EXAMPLES,
+    OPENF1_TOOL_DESCRIPTION
 )
 
 iface_driver_championship_standings = gr.Interface(
@@ -108,7 +110,74 @@ iface_constructor_info = gr.Interface(
 # Create your markdown-only tab using Blocks
 with gr.Blocks() as markdown_tab:
     gr.Markdown(MARKDOWN_INTRODUCTION)
-    
+
+
+
+# OpenF1 tools tab
+def openf1_tools_tab():
+    with gr.Blocks() as openf1_tools_tab:
+        gr.Markdown(OPENF1_TOOL_DESCRIPTION)
+        with gr.Accordion("get_api_endpoints()", open=False):
+            btn = gr.Button("Get all endpoints")
+            output = gr.JSON()
+            def call():
+                return openf1_tools.get_api_endpoints()
+            btn.click(call, outputs=output)
+        with gr.Accordion("get_api_endpoint(endpoint)", open=False):
+            endpoint_in = gr.Textbox(label="Endpoint", placeholder="e.g. sessions")
+            btn = gr.Button("Get endpoint info")
+            output = gr.JSON()
+            def call(endpoint):
+                return openf1_tools.get_api_endpoint(endpoint)
+            btn.click(call, inputs=endpoint_in, outputs=output)
+        with gr.Accordion("get_endpoint_info(endpoint)", open=False):
+            endpoint_in = gr.Textbox(label="Endpoint", placeholder="e.g. sessions")
+            btn = gr.Button("Get endpoint details")
+            output = gr.JSON()
+            def call(endpoint):
+                return openf1_tools.get_endpoint_info(endpoint)
+            btn.click(call, inputs=endpoint_in, outputs=output)
+        with gr.Accordion("get_filter_info(filter_name)", open=False):
+            filter_in = gr.Textbox(label="Filter name", placeholder="e.g. driver_number")
+            btn = gr.Button("Get filter info")
+            output = gr.JSON()
+            def call(filter_name):
+                return openf1_tools.get_filter_info(filter_name)
+            btn.click(call, inputs=filter_in, outputs=output)
+        with gr.Accordion("get_filter_string(filter_name, filter_value, operator)", open=False):
+            filter_name = gr.Textbox(label="Filter name", placeholder="e.g. driver_number")
+            filter_value = gr.Textbox(label="Filter value", placeholder="e.g. 16")
+            operator = gr.Dropdown(label="Operator", choices=["=", ">", "<", ">=", "<="], value="=")
+            btn = gr.Button("Get filter string")
+            output = gr.Textbox(label="Filter string", info="Example: driver_number=16&")
+            def call(filter_name, filter_value, operator):
+                return openf1_tools.get_filter_string(filter_name, filter_value, operator)
+            btn.click(call, inputs=[filter_name, filter_value, operator], outputs=output)
+        with gr.Accordion("apply_filters(api_string, *filters)", open=False):
+            api_string = gr.Textbox(label="Base API string", placeholder="e.g. https://api.openf1.org/v1/sessions?")
+            filters = gr.Textbox(label="Filters (comma-separated)", placeholder="e.g. driver_number=16&,session_key=123&")
+            btn = gr.Button("Apply filters")
+            output = gr.Textbox(label="Full API string")
+            def call(api_string, filters):
+                # Expect filters as comma-separated
+                filter_list = [f.strip() for f in filters.split(",") if f.strip()]
+                return openf1_tools.apply_filters(api_string, *filter_list)
+            btn.click(call, inputs=[api_string, filters], outputs=output)
+        with gr.Accordion("send_request(api_string)", open=False):
+            with gr.Accordion("Example API requests (copy & paste into text box below)", open=False):
+                gr.Markdown(MARKDOWN_OPENF1_EXAMPLES)
+            api_string = gr.Textbox(label="Full API string", placeholder="e.g. https://api.openf1.org/v1/sessions?driver_number=16")
+            btn = gr.Button("Send API request")
+            output = gr.JSON()
+            def call(api_string):
+                try:
+                    return openf1_tools.send_request(api_string)
+                except Exception as e:
+                    return {"error": str(e)}
+            btn.click(call, inputs=api_string, outputs=output)
+    return openf1_tools_tab
+
+# OpenF1 tabs
 
 named_interfaces = {
     "About": markdown_tab,
@@ -120,6 +189,7 @@ named_interfaces = {
     "Session Results": iface_session_results,
     "Driver Info": iface_driver_info,
     "Constructor Info": iface_constructor_info,
+    "OpenF1 Tools": openf1_tools_tab(),
 }
 
 # Tab names and interfaces

todo.txt

@@ -1,5 +1,4 @@
 - For driver championship standings, make the Driver dropdown depend on the selected season. As it is implemented now one could not use it for older seasons!
     * Solution is to have a static json file that maps drivers for each season/year
 - Same applies for constructor championship standings but instead Constructor dropdown
-    * Similar solution to above
-- Implement a tab for the OpenF1 tools but it might not be that user friendly :/
+    * Similar solution to above

utils/constants.py

@@ -94,3 +94,38 @@ For Claude Desktop, the following configuration can instead be used, but make su
 }
 ```
 """
+
+
+OPENF1_TOOL_DESCRIPTION = """
+## OpenF1 Tools - API Endpoints.
+
+This UI Interface/Tab collects all the MCP tools that are based on the `OpenF1` API, which are a bit more advanced compared to the other UI tabs that are implemented using the FastF1 library.
+In essence, the tools listed below make it possible to access the `OpenF1` API directly within the MCP server, thus allowing a LLM to interact with the `OpenF1` API.
+The **_OpenF1_** API exposes several **_endpoints_** that can be used to access different types of real-time and historical data about Formula 1 races, drivers, and teams.
+Each of these endpoints have different **_filters_** that can be used to filter the data returned by the endpoint. The data passed and returned is entirely in JSON format.
+
+The implemented functions make it possible to:
+- Get all available endpoints - `get_api_endpoints()`
+- Get information about a specific endpoint - `get_api_endpoint(endpoint)`
+- Get information about a specific filter - `get_filter_info(filter_name)`
+- Get a filter string for a specific filter - `get_filter_string(filter_name, filter_value, operator)`
+- Apply filters to an API string - `apply_filters(api_string, *filters)`
+- Send a request to the OpenF1 API - `send_request(api_string)`
+
+"""
+
+MARKDOWN_OPENF1_EXAMPLES = """
+
+```https://api.openf1.org/v1/car_data?driver_number=55&session_key=9159&speed>=315```
+
+```https://api.openf1.org/v1/drivers?driver_number=1&session_key=9158```
+
+```https://api.openf1.org/v1/intervals?session_key=9165&interval<0.005```
+
+```https://api.openf1.org/v1/laps?session_key=9161&driver_number=63&lap_number=8```
+
+```https://api.openf1.org/v1/meetings?year=2023&country_name=Singapore```
+
+```https://api.openf1.org/v1/pit?session_key=9158&pit_duration<31```
+
+"""