Setup Monte Carlo MCP Server with Git LFS

.gitattributes

@@ -33,3 +33,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+*.csv filter=lfs diff=lfs merge=lfs -text

Dockerfile

@@ -0,0 +1,34 @@
+# Use the official Python image
+FROM python:3.10-slim
+
+# Set up a new user named "user" with user ID 1000
+RUN useradd -m -u 1000 user
+
+# Switch to the "user" user
+USER user
+
+# Set home to the user's home directory
+ENV HOME=/home/user \
+    PATH=/home/user/.local/bin:$PATH
+
+# Set the working directory to the user's home directory
+WORKDIR $HOME/app
+
+# Copy the current directory contents into the container at $HOME/app setting the owner to the user
+COPY --chown=user . $HOME/app
+
+# Install requirements
+RUN pip install --no-cache-dir --upgrade -r requirements.txt
+
+# Expose port 7860
+EXPOSE 7860
+
+# Set environment variables
+ENV PORT=7860
+ENV PYTHONUNBUFFERED=1
+
+# Run the application
+# We run main.py which uses FastMCP. 
+# We need to make sure it listens on 0.0.0.0 and the correct port.
+# The main.py reads PORT env var.
+CMD ["python", "mcp_server/main.py"]

README.md

@@ -1,10 +1,17 @@
 ---
 title: Monte Carlo Sim
-emoji: 📈
-colorFrom: gray
-colorTo: purple
+emoji: 🏎️
+colorFrom: red
+colorTo: black
 sdk: docker
 pinned: false
+app_port: 7860
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# Monte Carlo Simulation MCP Server
+
+This is a FastMCP server for Monte Carlo simulations of racing data.
+
+## Deployment
+
+Deployed on Hugging Face Spaces using Docker.

mcp_server/README.md

@@ -0,0 +1,71 @@
+# MCP Server: Monte Carlo Simulation with a TFX Pipeline
+
+This directory contains the `mcp_server`, a tool for running Monte Carlo simulations for race strategy, now enhanced with a production-grade MLOps workflow using TensorFlow Extended (TFX).
+
+## Overview
+
+The server provides race strategy insights by running simulations based on models for tire degradation, fuel consumption, and race pace. The ML models are now managed by a TFX pipeline that automates the process of data preparation, training, evaluation, and deployment.
+
+## Environment Setup
+
+**IMPORTANT:** This project uses the `tfx` library, which currently requires **Python 3.11 or lower**. Please ensure you are using a compatible Python version to run the pipeline and tests.
+
+1.  **Create a Virtual Environment:**
+    ```bash
+    python3.11 -m venv venv
+    source venv/bin/activate
+    ```
+
+2.  **Install Dependencies:**
+    First, install TFX, Apache Beam, and other core dependencies:
+    ```bash
+    pip install "tfx>=1.15.0" "apache-beam[interactive]>=2.46.0" pytest
+    ```
+    Then, install the project-specific dependencies:
+    ```bash
+    pip install -e .
+    ```
+
+## MLOps Workflow
+
+The ML model lifecycle is managed by a series of scripts that should be run in order.
+
+### 1. Prepare Data
+
+This script downloads the raw race data, processes it into a unified CSV file, and places it in the correct directory for the TFX pipeline to use.
+
+```bash
+python3 mcp_server/prepare_data.py
+```
+
+### 2. Run the TFX Pipeline
+
+This script orchestrates the end-to-end ML workflow. It will ingest the prepared data, train the models, evaluate their performance, and (if they pass a quality threshold) deploy them to the serving directory.
+
+```bash
+python3 mcp_server/pipeline/pipeline.py
+```
+
+### 3. Visualize Model Performance
+
+After the pipeline has run, you can generate a visual report of the model performance metrics. This script reads the latest `evaluation_metrics.json` and creates a bar chart saved as `evaluation_results.png` in the latest model's directory.
+
+```bash
+python3 mcp_server/visualize_metrics.py
+```
+
+### 4. Start the Server
+
+Once the pipeline has successfully run and a model has been deployed, you can start the MCP server. The server will automatically load the latest blessed model from the pipeline.
+
+```bash
+python3 mcp_server/main.py
+```
+
+## Testing
+
+To verify the correctness of the pipeline components, run the unit tests using `pytest`. Make sure you are in the compatible Python 3.11 environment with all dependencies installed.
+
+```bash
+pytest mcp_server/tests/
+```

mcp_server/data_handling/data_downloader.py

@@ -0,0 +1,34 @@
+import requests
+import os
+
+def download_and_move_files(data_dir="data"):
+    """
+    Downloads and moves files to the specified directory.
+    """
+    # Create the directory if it doesn't exist
+    if not os.path.exists(data_dir):
+        os.makedirs(data_dir)
+
+    # List of file URLs to download
+    urls = [
+        "https://trddev.com/hackathon-2025/barber-motorsports-park.zip",
+        "https://trddev.com/hackathon-2025/circuit-of-the-americas.zip",
+        "https://trddev.com/hackathon-2025/indianapolis.zip",
+        "https://trddev.com/hackathon-2025/road-america.zip",
+        "https://trddev.com/hackathon-2025/sebring.zip",
+        "https://trddev.com/hackathon-2025/sonoma.zip",
+        "https://trddev.com/hackathon-2025/virginia-international-raceway.zip"
+    ]
+
+    # Download each file and save it to the specified directory
+    for url in urls:
+        filename = os.path.join(data_dir, os.path.basename(url))
+        with requests.get(url, stream=True) as r:
+            r.raise_for_status()
+            with open(filename, 'wb') as f:
+                for chunk in r.iter_content(chunk_size=8192):
+                    f.write(chunk)
+        print(f"Downloaded {filename}")
+
+if __name__ == '__main__':
+    download_and_move_files()

mcp_server/data_handling/data_loader.py

@@ -0,0 +1,28 @@
+import os
+import zipfile
+
+def unzip_data(data_dir="data", output_dir="unzipped_data"):
+    """
+    Unzips all .zip files in the data_dir to the output_dir.
+
+    Args:
+        data_dir (str): The directory containing the .zip files.
+        output_dir (str): The directory to extract the files to.
+    """
+    if not os.path.exists(output_dir):
+        os.makedirs(output_dir)
+
+    for filename in os.listdir(data_dir):
+        if filename.endswith(".zip"):
+            zip_path = os.path.join(data_dir, filename)
+            with zipfile.ZipFile(zip_path, 'r') as zip_ref:
+                # Create a directory with the name of the zip file
+                extract_path = os.path.join(output_dir, filename[:-4])
+                if not os.path.exists(extract_path):
+                    os.makedirs(extract_path)
+                print(f"Extracting {filename} to {extract_path}...")
+                zip_ref.extractall(extract_path)
+                print(f"Extracted {filename} successfully.")
+
+if __name__ == "__main__":
+    unzip_data()

mcp_server/data_handling/data_stream_simulator.py

@@ -0,0 +1,44 @@
+import pandas as pd
+import time
+import os
+from pilot.data_handling.telemetry_parser import parse_telemetry
+
+def stream_simulator(race_data_dir, delay_multiplier=1.0):
+    """
+    Simulates a real-time data stream from a telemetry CSV file.
+
+    Args:
+        race_data_dir (str): The path to the directory containing the race data.
+        delay_multiplier (float): A factor to speed up or slow down the simulation.
+
+    Yields:
+        dict: A dictionary representing a single row of telemetry data.
+    """
+    # Find the main telemetry file (assuming it's the largest CSV)
+    csv_files = [f for f in os.listdir(race_data_dir) if f.endswith('.csv')]
+    if not csv_files:
+        print(f"No CSV files found in {race_data_dir}")
+        return
+
+    main_telemetry_file = max(csv_files, key=lambda f: os.path.getsize(os.path.join(race_data_dir, f)))
+    file_path = os.path.join(race_data_dir, main_telemetry_file)
+
+    print(f"Streaming data from {file_path}...")
+    df = parse_telemetry(file_path)
+
+    if df is None:
+        return
+
+    # Assuming 'timestamp' is in milliseconds and represents the ECU time.
+    # We calculate the time difference between consecutive timestamps to simulate the delay.
+    if 'timestamp' in df.columns:
+        df = df.sort_values(by='timestamp').reset_index(drop=True)
+        df['time_diff'] = df['timestamp'].diff().fillna(0) / 1000.0  # Convert to seconds
+    else:
+        # If no timestamp, use a fixed delay
+        df['time_diff'] = 0.1
+
+    for index, row in df.iterrows():
+        delay = row['time_diff'] * delay_multiplier
+        time.sleep(delay)
+        yield row.to_dict()

mcp_server/data_handling/telemetry_parser.py

@@ -0,0 +1,81 @@
+import pandas as pd
+import os
+
+def parse_telemetry(race_data_dir):
+    """
+    Parses telemetry data and merges it with lap times and other features.
+
+    Args:
+        race_data_dir (str): The path to the directory containing the race data.
+
+    Returns:
+        pandas.DataFrame: A cleaned and merged DataFrame with telemetry data.
+    """
+    try:
+        # Find the main telemetry file (assuming it's the largest CSV)
+        csv_files = [f for f in os.listdir(race_data_dir) if f.lower().endswith('.csv')]
+        if not csv_files:
+            print(f"No CSV files found in {race_data_dir}")
+            return None
+
+        main_telemetry_file = max(csv_files, key=lambda f: os.path.getsize(os.path.join(race_data_dir, f)))
+        telemetry_file_path = os.path.join(race_data_dir, main_telemetry_file)
+
+        # Find the analysis file
+        analysis_file = [f for f in csv_files if 'Analysis' in f]
+        if not analysis_file:
+            print(f"Analysis file not found in {race_data_dir}")
+            return None
+        analysis_file_path = os.path.join(race_data_dir, analysis_file[0])
+
+        # Read the analysis data
+        df_analysis = pd.read_csv(analysis_file_path, delimiter=';')
+        df_analysis.columns = df_analysis.columns.str.strip()
+
+        # Rename columns in analysis data for merging
+        df_analysis = df_analysis.rename(columns={'LAP_NUMBER': 'lap', 'DRIVER_NUMBER': 'driver_number', 'LAP_TIME': 'lap_time'})
+
+        # Convert lap_time to seconds
+        df_analysis['lap_time'] = df_analysis['lap_time'].apply(lambda x: sum(float(t) * 60**i for i, t in enumerate(reversed(str(x).split(':')))))
+
+        # Create a lap time mapping
+        lap_time_map = df_analysis.set_index('lap')['lap_time'].to_dict()
+
+        # Process telemetry data in chunks
+        df_telemetry_chunks = pd.read_csv(telemetry_file_path, chunksize=100000)
+
+        processed_chunks = []
+        for chunk in df_telemetry_chunks:
+            # Handle the erroneous lap count in telemetry data
+            if 'lap' in chunk.columns:
+                chunk['lap'] = chunk['lap'].replace(32768, pd.NA).ffill()
+
+            # Pivot the dataframe
+            chunk = chunk.pivot_table(index=['timestamp', 'lap', 'vehicle_id'], columns='telemetry_name', values='telemetry_value').reset_index()
+
+            # Map lap times
+            chunk['lap_time'] = chunk['lap'].map(lap_time_map)
+            processed_chunks.append(chunk)
+
+        df_merged = pd.concat(processed_chunks)
+
+        # Feature Engineering: Fuel Consumption Proxy
+        # Normalize aps and nmot to a 0-1 scale
+        df_merged['aps_norm'] = df_merged['aps'] / 100.0
+        df_merged['nmot_norm'] = df_merged['nmot'] / df_merged['nmot'].max()
+        df_merged['fuel_consumption'] = (0.7 * df_merged['aps_norm']) + (0.3 * df_merged['nmot_norm'])
+
+        # Feature Engineering: Relative Pace
+        fastest_laps = df_merged.groupby('lap')['lap_time'].min().reset_index()
+        fastest_laps.rename(columns={'lap_time': 'fastest_lap'}, inplace=True)
+        df_merged = pd.merge(df_merged, fastest_laps, on='lap', how='left')
+        df_merged['relative_pace'] = df_merged['lap_time'] - df_merged['fastest_lap']
+
+        return df_merged
+
+    except FileNotFoundError:
+        print(f"Error: A file was not found in {race_data_dir}")
+        return None
+    except Exception as e:
+        print(f"An error occurred: {e}")
+        return None

mcp_server/gcs_utils.py

@@ -0,0 +1,44 @@
+import os
+from google.cloud import storage
+import sys
+
+def download_blob(bucket_name, source_blob_name, destination_file_name):
+    """Downloads a blob from the bucket."""
+    try:
+        storage_client = storage.Client()
+        bucket = storage_client.bucket(bucket_name)
+        blob = bucket.blob(source_blob_name)
+        blob.download_to_filename(destination_file_name)
+        print(f"Downloaded storage object {source_blob_name} from bucket {bucket_name} to local file {destination_file_name}.", file=sys.stderr)
+    except Exception as e:
+        print(f"Failed to download {source_blob_name} from {bucket_name}: {e}", file=sys.stderr)
+        raise
+
+def download_directory(bucket_name, prefix, local_dir):
+    """Downloads a directory from the bucket."""
+    try:
+        storage_client = storage.Client()
+        bucket = storage_client.bucket(bucket_name)
+        blobs = bucket.list_blobs(prefix=prefix)
+        
+        if not os.path.exists(local_dir):
+            os.makedirs(local_dir)
+
+        for blob in blobs:
+            if blob.name.endswith("/"):
+                continue
+            
+            # Remove the prefix from the local path to keep the structure relative
+            relative_path = os.path.relpath(blob.name, prefix)
+            local_path = os.path.join(local_dir, relative_path)
+            
+            local_dir_path = os.path.dirname(local_path)
+            if not os.path.exists(local_dir_path):
+                os.makedirs(local_dir_path)
+                
+            blob.download_to_filename(local_path)
+            print(f"Downloaded {blob.name} to {local_path}", file=sys.stderr)
+            
+    except Exception as e:
+        print(f"Failed to download directory {prefix} from {bucket_name}: {e}", file=sys.stderr)
+        raise

mcp_server/main.py

@@ -0,0 +1,103 @@
+import os
+import sys
+import asyncio
+import logging
+from fastmcp import FastMCP
+
+# Add the current directory to sys.path to ensure modules can be imported
+sys.path.append(os.path.dirname(os.path.abspath(__file__)))
+
+from monte_carlo_simulation import MonteCarloSimulation
+from data_handling.telemetry_parser import parse_telemetry
+from gcs_utils import download_directory
+
+# Configure logging
+logging.basicConfig(format="[%(levelname)s]: %(message)s", level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+# Initialize FastMCP
+mcp = FastMCP("Monte Carlo MCP Server 🏎️")
+
+# Constants
+PIPELINE_NAME = "mcp-server-pipeline"
+SERVING_MODEL_DIR = os.path.join("mcp_server", "serving_model", PIPELINE_NAME)
+
+# Global simulation instance
+mc_simulation = None
+
+def initialize_simulation():
+    """Initializes the Monte Carlo simulation with models and data."""
+    global mc_simulation
+    
+    # Check for GCS configuration
+    gcs_bucket = os.environ.get("GCS_BUCKET_NAME")
+    
+    if gcs_bucket:
+        logger.info(f"GCS_BUCKET_NAME found: {gcs_bucket}. Downloading assets from GCS...")
+        try:
+            # Define local paths for downloads
+            local_assets_dir = os.path.join(os.getcwd(), "downloaded_assets")
+            local_model_dir = os.path.join(local_assets_dir, "trained_models")
+            local_data_dir = os.path.join(local_assets_dir, "data", "barber")
+
+            # Download models
+            logger.info("Downloading models...")
+            download_directory(gcs_bucket, "trained_models", local_model_dir)
+            
+            # Download race data
+            logger.info("Downloading race data...")
+            download_directory(gcs_bucket, "data/barber", local_data_dir)
+
+            # Update paths to point to downloaded assets
+            model_dir_to_use = local_model_dir
+            race_data_dir = local_data_dir
+            
+        except Exception as e:
+            logger.error(f"Failed to download assets from GCS: {e}")
+            return False
+    else:
+        logger.info("GCS_BUCKET_NAME not set. Using local assets.")
+        script_dir = os.path.dirname(os.path.abspath(__file__))
+        model_dir_to_use = os.path.join(script_dir, "trained_models")
+        race_data_dir = os.path.join(script_dir, 'unzipped_data', 'barber-motorsports-park', 'barber')
+
+    logger.info(f"Loading models from: {model_dir_to_use}")
+    
+    # Load race data
+    race_data = parse_telemetry(race_data_dir)
+    if race_data is None:
+        logger.error("Failed to load race data.")
+        return False
+
+    # Initialize Simulation
+    try:
+        mc_simulation = MonteCarloSimulation(race_data, model_dir=model_dir_to_use)
+        logger.info("Monte Carlo Simulation initialized successfully.")
+        return True
+    except Exception as e:
+        logger.error(f"Failed to initialize simulation: {e}")
+        return False
+
+# Initialize on startup
+if not initialize_simulation():
+    logger.warning("Simulation failed to initialize. Tools may not work.")
+
+@mcp.tool()
+def find_optimal_pit_window() -> str:
+    """
+    Uses Monte Carlo simulation to find the optimal pit stop strategy.
+    Returns a string describing the best strategy and its average time.
+    """
+    if mc_simulation is None:
+        return "Error: Simulation not initialized."
+    
+    return mc_simulation.find_optimal_pit_window()
+
+if __name__ == "__main__":
+    # Cloud Run sets PORT environment variable
+    port = int(os.getenv("PORT", 8080))
+    logger.info(f"🚀 MCP server starting on port {port}")
+    
+    # Run the server
+    # FastMCP handles the HTTP server loop
+    mcp.run(transport="sse", port=port, host="0.0.0.0")

mcp_server/mcp_server.egg-info/PKG-INFO

@@ -0,0 +1,13 @@
+Metadata-Version: 2.4
+Name: mcp-server
+Version: 0.1.0
+Summary: MCP Server for the Hack the Track Monte Carlo Simulation
+Requires-Python: <3.13,>=3.11
+Requires-Dist: google-adk>=1.18.0
+Requires-Dist: numpy
+Requires-Dist: pandas
+Requires-Dist: scikit-learn>=1.7.2
+Requires-Dist: joblib
+Requires-Dist: requests
+Provides-Extra: test
+Requires-Dist: pytest>=8.4.2; extra == "test"

mcp_server/mcp_server.egg-info/SOURCES.txt

@@ -0,0 +1,18 @@
+main.py
+monte_carlo_simulation.py
+pyproject.toml
+data_handling/data_downloader.py
+data_handling/data_loader.py
+data_handling/data_stream_simulator.py
+data_handling/telemetry_parser.py
+mcp_server.egg-info/PKG-INFO
+mcp_server.egg-info/SOURCES.txt
+mcp_server.egg-info/dependency_links.txt
+mcp_server.egg-info/requires.txt
+mcp_server.egg-info/top_level.txt
+models/fuel_consumption_model.py
+models/pace_prediction_model.py
+models/tire_degradation_model.py
+models/train_models.py
+tests/test_prepare_data.py
+tests/test_trainer_module.py

mcp_server/mcp_server.egg-info/requires.txt

@@ -0,0 +1,9 @@
+google-adk>=1.18.0
+numpy
+pandas
+scikit-learn>=1.7.2
+joblib
+requests
+
+[test]
+pytest>=8.4.2

mcp_server/mcp_server.egg-info/top_level.txt

@@ -0,0 +1,4 @@
+data_handling
+main
+models
+monte_carlo_simulation

mcp_server/mock_request.py

@@ -0,0 +1,57 @@
+import subprocess
+import sys
+import time
+import requests
+import os
+import signal
+
+def run_mock_request():
+    # Path to the local server runner
+    server_script = "mcp_server/main.py"
+    
+    # Set environment variables
+    env = os.environ.copy()
+    env["GCS_BUCKET_NAME"] = "monte-carlo-mcp-assets"
+    env["PORT"] = "8080"
+    
+    # Start the server process
+    print("Starting server process...")
+    process = subprocess.Popen(
+        [sys.executable, server_script],
+        env=env,
+        stdout=sys.stdout,
+        stderr=sys.stderr,
+        text=True
+    )
+
+    # Wait for server to start
+    print("Waiting for server to start...")
+    server_url = "http://localhost:8080/sse"
+    max_retries = 30
+    
+    try:
+        for i in range(max_retries):
+            try:
+                response = requests.get(server_url, stream=True, timeout=1)
+                if response.status_code == 200:
+                    print("Server is up and running! (SSE endpoint accessible)")
+                    break
+            except requests.exceptions.ConnectionError:
+                time.sleep(2)
+                print(f"Waiting... ({i+1}/{max_retries})")
+        else:
+            print("Server failed to start within timeout.")
+            return
+
+        print("Test passed: Server started and is listening on port 8080.")
+        
+    except Exception as e:
+        print(f"An error occurred: {e}")
+    finally:
+        print("Terminating server process...")
+        os.kill(process.pid, signal.SIGTERM)
+        process.wait()
+        print("Server process terminated.")
+
+if __name__ == "__main__":
+    run_mock_request()

mcp_server/models/fuel_consumption_model.py

@@ -0,0 +1,48 @@
+import pandas as pd
+from sklearn.model_selection import train_test_split
+from sklearn.linear_model import LinearRegression
+from sklearn.metrics import mean_squared_error
+import numpy as np
+
+def train_fuel_consumption_model(data):
+    """
+    Trains a model to predict fuel consumption per lap.
+
+    Args:
+        data (pd.DataFrame): DataFrame containing telemetry data.
+                             It must include 'nmot', 'ath', and 'fuel_consumption'.
+
+    Returns:
+        A trained machine learning model.
+    """
+    # Feature Engineering
+    features = ['nmot', 'aps']
+    target = 'fuel_consumption' # Assuming 'fuel_consumption' is the target variable
+
+    X = data[features]
+    y = data[target]
+
+    X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
+
+    model = LinearRegression()
+    model.fit(X_train, y_train)
+
+    # Evaluate the model
+    predictions = model.predict(X_test)
+    mse = mean_squared_error(y_test, predictions)
+    print(f"Fuel Consumption Model MSE: {mse}")
+
+    return model
+
+def predict_fuel_consumption(model, live_data):
+    """
+    Predicts the fuel consumption for a given lap.
+
+    Args:
+        model: The trained fuel consumption model.
+        live_data (pd.DataFrame): A DataFrame with the live telemetry data.
+
+    Returns:
+        float: The predicted fuel consumption.
+    """
+    return model.predict(live_data)[0]

mcp_server/models/pace_prediction_model.py

@@ -0,0 +1,51 @@
+import pandas as pd
+from sklearn.model_selection import train_test_split
+from sklearn.ensemble import RandomForestRegressor
+from sklearn.metrics import mean_squared_error
+import numpy as np
+
+def train_pace_prediction_model(data):
+    """
+    Trains a model to predict the car's pace relative to competitors.
+
+    Args:
+        data (pd.DataFrame): DataFrame containing telemetry data. It must include
+                             'Speed', 'Gear', 'nmot', 'ath', 'pbrake_f', 'pbrake_r',
+                             'accx_can', 'accy_can', 'Steering_Angle', 'traffic',
+                             and 'relative_pace'.
+
+    Returns:
+        A trained machine learning model.
+    """
+    # Feature Engineering
+    features = ['speed', 'gear', 'nmot', 'aps', 'pbrake_f', 'pbrake_r',
+                'accx_can', 'accy_can', 'Steering_Angle', 'traffic']
+    target = 'relative_pace' # Assuming 'relative_pace' is the target variable
+
+    X = data[features]
+    y = data[target]
+
+    X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
+
+    model = RandomForestRegressor(n_estimators=100, random_state=42)
+    model.fit(X_train, y_train)
+
+    # Evaluate the model
+    predictions = model.predict(X_test)
+    mse = mean_squared_error(y_test, predictions)
+    print(f"Pace Prediction Model MSE: {mse}")
+
+    return model
+
+def predict_pace(model, live_data):
+    """
+    Predicts the car's pace based on live data.
+
+    Args:
+        model: The trained pace prediction model.
+        live_data (pd.DataFrame): A DataFrame with the live telemetry data.
+
+    Returns:
+        float: The predicted pace.
+    """
+    return model.predict(live_data)[0]

mcp_server/models/tire_degradation_model.py

@@ -0,0 +1,49 @@
+import pandas as pd
+from sklearn.model_selection import train_test_split
+from sklearn.linear_model import LinearRegression
+from sklearn.metrics import mean_squared_error
+import numpy as np
+
+def train_tire_degradation_model(data):
+    """
+    Trains a model to predict tire degradation (lap time drop-off).
+
+    Args:
+        data (pd.DataFrame): DataFrame containing telemetry data.
+                             It must include 'lap', 'accx_can', 'accy_can',
+                             'Steering_Angle', and 'lap_time'.
+
+    Returns:
+        A trained machine learning model.
+    """
+    # Feature Engineering (simple example)
+    features = ['lap', 'accx_can', 'accy_can', 'Steering_Angle']
+    target = 'lap_time' # Assuming 'lap_time' is the target variable
+
+    X = data[features]
+    y = data[target]
+
+    X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
+
+    model = LinearRegression()
+    model.fit(X_train, y_train)
+
+    # Evaluate the model
+    predictions = model.predict(X_test)
+    mse = mean_squared_error(y_test, predictions)
+    print(f"Tire Degradation Model MSE: {mse}")
+
+    return model
+
+def predict_lap_time_dropoff(model, live_data):
+    """
+    Predicts the lap time drop-off based on live data.
+
+    Args:
+        model: The trained tire degradation model.
+        live_data (pd.DataFrame): A DataFrame with the live telemetry data.
+
+    Returns:
+        float: The predicted lap time drop-off.
+    """
+    return model.predict(live_data)[0]

mcp_server/models/train_models.py

@@ -0,0 +1,48 @@
+import pandas as pd
+import os
+import joblib
+from pilot.data_handling.telemetry_parser import parse_telemetry
+from pilot.models.tire_degradation_model import train_tire_degradation_model
+from pilot.models.fuel_consumption_model import train_fuel_consumption_model
+from pilot.models.pace_prediction_model import train_pace_prediction_model
+
+def train_and_save_models(race_data_dir, model_dir="trained_models"):
+    """
+    Trains all the predictive models and saves them to disk.
+
+    Args:
+        race_data_dir (str): The path to the directory containing the race data.
+        model_dir (str): The directory to save the trained models to.
+    """
+    if not os.path.exists(model_dir):
+        os.makedirs(model_dir)
+
+    # Parse the data
+    data = parse_telemetry(race_data_dir)
+    if data is None:
+        print("Failed to parse data. Aborting training.")
+        return
+
+    # Drop rows with missing values
+    data.dropna(inplace=True)
+
+    # Train and save the tire degradation model
+    print("Training Tire Degradation Model...")
+    tire_model = train_tire_degradation_model(data)
+    joblib.dump(tire_model, os.path.join(model_dir, "tire_degradation_model.pkl"))
+    print("Tire Degradation Model saved.")
+
+    # Train and save the fuel consumption model
+    print("\nTraining Fuel Consumption Model...")
+    fuel_model = train_fuel_consumption_model(data)
+    joblib.dump(fuel_model, os.path.join(model_dir, "fuel_consumption_model.pkl"))
+    print("Fuel Consumption Model saved.")
+
+    # Train and save the pace prediction model
+    print("\nTraining Pace Prediction Model...")
+    # 'traffic' column might not exist, so we create a dummy one if it doesn't
+    if 'traffic' not in data.columns:
+        data['traffic'] = 0
+    pace_model = train_pace_prediction_model(data)
+    joblib.dump(pace_model, os.path.join(model_dir, "pace_prediction_model.pkl"))
+    print("Pace Prediction Model saved.")

mcp_server/monte_carlo_simulation.py

@@ -0,0 +1,187 @@
+import numpy as np
+import pandas as pd
+import joblib
+import os
+import sys
+
+from models.tire_degradation_model import predict_lap_time_dropoff
+from models.fuel_consumption_model import predict_fuel_consumption
+from models.pace_prediction_model import predict_pace
+
+SAFETY_CAR_TIME_LOSS_SECONDS = 30
+
+class MonteCarloSimulation:
+    def __init__(self, race_data, model_dir, num_simulations=1000):
+        self.race_data = race_data
+        self.num_simulations = num_simulations
+        self.tire_model = joblib.load(os.path.join(model_dir, "tire_degradation_model.pkl"))
+        self.fuel_model = joblib.load(os.path.join(model_dir, "fuel_consumption_model.pkl"))
+        self.pace_model = joblib.load(os.path.join(model_dir, "pace_prediction_model.pkl"))
+
+        # Calculate average driver inputs
+        self.avg_driver_inputs = {
+            'accx_can': self.race_data['accx_can'].mean(),
+            'accy_can': self.race_data['accy_can'].mean(),
+            'Steering_Angle': self.race_data['Steering_Angle'].mean(),
+            'nmot': self.race_data['nmot'].mean(),
+            'aps': self.race_data['aps'].mean(),
+            'pbrake_f': self.race_data['pbrake_f'].mean(),
+            'pbrake_r': self.race_data['pbrake_r'].mean(),
+            'speed': self.race_data['speed'].mean(),
+            'gear': self.race_data['gear'].mean(),
+        }
+
+
+    def simulate_lap(self, live_data):
+        """Simulates a single lap of the race."""
+
+        tire_features = ['lap', 'accx_can', 'accy_can', 'Steering_Angle']
+        fuel_features = ['nmot', 'aps']
+        pace_features = ['speed', 'gear', 'nmot', 'aps', 'pbrake_f', 'pbrake_r',
+                         'accx_can', 'accy_can', 'Steering_Angle', 'traffic']
+
+        lap_time = predict_lap_time_dropoff(self.tire_model, live_data[tire_features])
+        fuel_consumed = predict_fuel_consumption(self.fuel_model, live_data[fuel_features])
+
+        return lap_time, fuel_consumed
+
+    def run_strategy_simulation(self, strategy, safety_car_lap=None):
+        """
+        Runs a full race simulation for a given pit stop strategy.
+
+        Args:
+            strategy (list): A list of lap numbers for pit stops.
+            safety_car_lap (int): The lap on which a safety car is deployed.
+
+        Returns:
+            float: The total race time for the simulated strategy.
+        """
+        total_race_time = 0
+        tire_wear = 0
+        fuel_level = 100 # start with a full tank
+
+        total_laps = self.race_data['total_laps'].iloc[0] if 'total_laps' in self.race_data else 60
+        pit_stop_time = 25 # seconds
+
+        for lap in range(1, total_laps + 1):
+            if lap in strategy:
+                # Pit stop
+                total_race_time += pit_stop_time
+                tire_wear = 0 # Fresh tires
+                fuel_level = 100 # Refuel
+
+            live_data = pd.DataFrame({
+                'lap': [tire_wear], # Use tire_wear as the feature for the model
+                'accx_can': [self.avg_driver_inputs['accx_can']],
+                'accy_can': [self.avg_driver_inputs['accy_can']],
+                'Steering_Angle': [self.avg_driver_inputs['Steering_Angle']],
+                'nmot': [self.avg_driver_inputs['nmot']],
+                'aps': [self.avg_driver_inputs['aps']],
+                'pbrake_f': [self.avg_driver_inputs['pbrake_f']],
+                'pbrake_r': [self.avg_driver_inputs['pbrake_r']],
+                'speed': [self.avg_driver_inputs['speed']],
+                'gear': [self.avg_driver_inputs['gear']],
+                'traffic': [0] # Placeholder for traffic data
+            })
+
+            lap_time, fuel_consumed = self.simulate_lap(live_data)
+
+            total_race_time += lap_time
+            if safety_car_lap and lap == safety_car_lap and lap not in strategy:
+                total_race_time += SAFETY_CAR_TIME_LOSS_SECONDS
+
+            tire_wear += 1
+            fuel_level -= fuel_consumed
+
+            if fuel_level <= 0:
+                # Ran out of fuel, this strategy is invalid
+                return float('inf')
+
+        return total_race_time
+
+    def find_optimal_pit_window(self) -> str:
+        """
+        Uses Monte Carlo simulation to find the optimal pit stop strategy.
+        """
+        # For simplicity, we'll test a few pre-defined strategies.
+        # A more advanced implementation would generate these dynamically.
+        strategies = {
+            "1-stop": [[28]],
+            "2-stop": [[20, 40]],
+            "3-stop": [[15, 30, 45]]
+        }
+
+        best_strategy = None
+        best_time = float('inf')
+
+        for name, pit_stops in strategies.items():
+            simulation_times = []
+            for _ in range(self.num_simulations):
+                total_time = self.run_strategy_simulation(pit_stops[0])
+                simulation_times.append(total_time)
+
+            avg_time = np.mean(simulation_times)
+
+            print(f"Strategy: {name}, Avg. Time: {avg_time:.2f}s")
+
+            if avg_time < best_time:
+                best_time = avg_time
+                best_strategy = name
+
+        return f"Best Strategy: {best_strategy}, Time: {best_time:.2f}s"
+
+    def analyze_undercut_overcut(self, competitor_pit_lap):
+        """
+        Analyzes the outcome of undercutting or overcutting a competitor.
+        """
+        print("\n--- Undercut/Overcut Analysis ---")
+        # Simulate pitting 1 lap before, on the same lap, and 1 lap after
+        undercut_strategy = [competitor_pit_lap - 1]
+        match_strategy = [competitor_pit_lap]
+        overcut_strategy = [competitor_pit_lap + 1]
+
+        undercut_time = np.mean([self.run_strategy_simulation(undercut_strategy) for _ in range(self.num_simulations)])
+        match_time = np.mean([self.run_strategy_simulation(match_strategy) for _ in range(self.num_simulations)])
+        overcut_time = np.mean([self.run_strategy_simulation(overcut_strategy) for _ in range(self.num_simulations)])
+
+        print(f"Undercut (pit at lap {competitor_pit_lap - 1}): {undercut_time:.2f}s")
+        print(f"Match (pit at lap {competitor_pit_lap}): {match_time:.2f}s")
+        print(f"Overcut (pit at lap {competitor_pit_lap + 1}): {overcut_time:.2f}s")
+
+        # Return the time difference compared to matching the competitor
+        return {
+            "undercut_diff": undercut_time - match_time,
+            "overcut_diff": overcut_time - match_time
+        }
+
+    def react_to_safety_car(self, current_lap):
+        """
+        Simulates the outcome of pitting during a safety car period.
+        """
+        print(f"\n--- Safety Car at Lap {current_lap} ---")
+
+        # Scenario 1: Pit now
+        pit_now_strategy = [current_lap]
+
+        # Scenario 2: Stay out (assume a 1-stop strategy, pitting later)
+        stay_out_strategy = [35]
+
+        # Simulate with adjusted lap times for the safety car period
+        # (This is a simplified assumption)
+
+        # Scenario 1: Pit now
+        pit_now_time = np.mean([self.run_strategy_simulation(pit_now_strategy, safety_car_lap=current_lap) for _ in range(self.num_simulations)])
+
+
+        # Scenario 2: Stay out
+        stay_out_time = np.mean([self.run_strategy_simulation(stay_out_strategy, safety_car_lap=current_lap) for _ in range(self.num_simulations)])
+
+        print(f"Pit Now: {pit_now_time:.2f}s")
+        print(f"Stay Out: {stay_out_time:.2f}s")
+
+        if pit_now_time < stay_out_time:
+            print("Recommendation: PIT NOW")
+        else:
+            print("Recommendation: STAY OUT")
+
+        return pit_now_time, stay_out_time

mcp_server/pipeline/evaluator.py

@@ -0,0 +1,49 @@
+import os
+import json
+from tfx.dsl.component.experimental.decorators import component
+from tfx.dsl.component.experimental.annotations import InputArtifact, OutputArtifact
+from tfx.types.standard_artifacts import Model, ModelBlessing
+
+# Define the path to the metrics file produced by the Trainer
+METRICS_FILE = "evaluation_metrics.json"
+
+# Define the quality threshold for the model
+# In a real-world scenario, this would be more sophisticated.
+MSE_THRESHOLD = 5.0 # Example threshold
+
+@component
+def CustomEvaluator(
+    model: InputArtifact[Model],
+    blessing: OutputArtifact[ModelBlessing]
+):
+    """
+    A custom TFX component that evaluates the trained models and blesses them
+    if they meet the quality threshold.
+    """
+    model_dir = model.uri
+    metrics_path = os.path.join(model_dir, METRICS_FILE)
+
+    if not os.path.exists(metrics_path):
+        raise FileNotFoundError(f"Metrics file not found at {metrics_path}")
+
+    with open(metrics_path, 'r') as f:
+        metrics = json.load(f)
+
+    # For this example, we'll check if the average MSE is below the threshold.
+    avg_mse = sum(metrics.values()) / len(metrics)
+    print(f"Average MSE: {avg_mse}")
+
+    if avg_mse < MSE_THRESHOLD:
+        print("Model passed quality threshold. Blessing model.")
+        blessing.uri = os.path.join(model.uri, "blessed")
+        blessing.set_int_custom_property("blessed", 1)
+        # Create an empty file to signify the blessing
+        with open(blessing.uri, "w") as f:
+            f.write("")
+    else:
+        print("Model did not pass quality threshold. Not blessing model.")
+        blessing.uri = os.path.join(model.uri, "not_blessed")
+        blessing.set_int_custom_property("blessed", 0)
+        # Create an empty file to signify the rejection
+        with open(blessing.uri, "w") as f:
+            f.write("")

mcp_server/pipeline/module.py

@@ -0,0 +1,127 @@
+import os
+import json
+import joblib
+import pandas as pd
+from typing import List, Text
+
+from sklearn.ensemble import RandomForestRegressor
+from sklearn.linear_model import LinearRegression
+from sklearn.metrics import mean_squared_error
+
+import tensorflow as tf
+from tensorflow_transform.tf_metadata import schema_utils
+
+from tfx import v1 as tfx
+from tfx_bsl.public import tfxio
+
+# --- Feature and Target Definitions ---
+
+TIRE_FEATURES = ['lap', 'accx_can', 'accy_can', 'Steering_Angle']
+FUEL_FEATURES = ['nmot', 'aps']
+PACE_FEATURES = ['speed', 'gear', 'nmot', 'aps', 'pbrake_f', 'pbrake_r',
+                 'accx_can', 'accy_can', 'Steering_Angle', 'traffic']
+
+TIRE_TARGET = 'lap_time'
+FUEL_TARGET = 'fuel_consumption'
+PACE_TARGET = 'relative_pace'
+
+ALL_FEATURES = list(set(TIRE_FEATURES + FUEL_FEATURES + PACE_FEATURES))
+ALL_TARGETS = [TIRE_TARGET, FUEL_TARGET, PACE_TARGET]
+
+METRICS_FILE = "evaluation_metrics.json"
+
+# --- Data Loading and Conversion ---
+
+def _input_fn(file_pattern: List[Text],
+              data_accessor: tfx.components.DataAccessor,
+              schema: tfx.proto.Schema,
+              batch_size: int = 200) -> tf.data.Dataset:
+    """Generates a dataset from TFX IO."""
+    return data_accessor.tf_dataset_factory(
+        file_pattern,
+        tfxio.TensorFlowDatasetOptions(batch_size=batch_size, label_key=PACE_TARGET),
+        schema=schema).repeat()
+
+def _get_raw_feature_spec(schema):
+    """Generates a raw feature spec from the schema."""
+    return schema_utils.schema_as_feature_spec(schema).feature_spec
+
+def _dataset_to_pandas(dataset: tf.data.Dataset, schema: tfx.proto.Schema) -> pd.DataFrame:
+    """Converts a tf.data.Dataset to a pandas DataFrame."""
+    raw_feature_spec = _get_raw_feature_spec(schema)
+    parsed_features = []
+    # Take a finite number of records for conversion
+    for tf_example_record in dataset.take(1000):
+        parsed_record = tf.io.parse_example(tf_example_record, raw_feature_spec)
+        parsed_features.append({
+            key: val.numpy().squeeze()
+            for key, val in parsed_record.items()
+        })
+    return pd.DataFrame(parsed_features)
+
+# --- Model Training and Evaluation Logic ---
+
+def _train_and_evaluate_model(model, train_df: pd.DataFrame, eval_df: pd.DataFrame,
+                              features: List[Text], target: Text, model_path: Text):
+    """Helper function to train, evaluate, and save a scikit-learn model."""
+    X_train = train_df[features]
+    y_train = train_df[target]
+    X_eval = eval_df[features]
+    y_eval = eval_df[target]
+
+    model.fit(X_train, y_train)
+    predictions = model.predict(X_eval)
+    mse = mean_squared_error(y_eval, predictions)
+    print(f"Model for '{target}' MSE: {mse}")
+
+    joblib.dump(model, model_path)
+    print(f"Model for '{target}' saved to {model_path}")
+    return mse
+
+# --- TFX Trainer run_fn ---
+
+def run_fn(fn_args: tfx.components.FnArgs):
+    """Train the three models and evaluate them."""
+    schema = tfx.utils.parse_pbtxt_file(fn_args.schema_path, tfx.proto.Schema())
+
+    # 1. Load and convert train and eval data
+    train_dataset = _input_fn(fn_args.train_files, fn_args.data_accessor, schema)
+    eval_dataset = _input_fn(fn_args.eval_files, fn_args.data_accessor, schema)
+
+    train_df = _dataset_to_pandas(train_dataset, schema)
+    eval_df = _dataset_to_pandas(eval_dataset, schema)
+
+    # Simple data imputation
+    for col in ALL_FEATURES + ALL_TARGETS:
+        if col not in train_df.columns:
+            train_df[col] = 0.0
+        if col not in eval_df.columns:
+            eval_df[col] = 0.0
+    train_df.fillna(0, inplace=True)
+    eval_df.fillna(0, inplace=True)
+
+    # 2. Define models
+    tire_model = LinearRegression()
+    fuel_model = LinearRegression()
+    pace_model = RandomForestRegressor(n_estimators=100, random_state=42)
+
+    # 3. Define paths for saved models
+    tire_model_path = os.path.join(fn_args.serving_model_dir, "tire_degradation_model.pkl")
+    fuel_model_path = os.path.join(fn_args.serving_model_dir, "fuel_consumption_model.pkl")
+    pace_model_path = os.path.join(fn_args.serving_model_dir, "pace_prediction_model.pkl")
+
+    # 4. Train and evaluate each model
+    tire_mse = _train_and_evaluate_model(tire_model, train_df, eval_df, TIRE_FEATURES, TIRE_TARGET, tire_model_path)
+    fuel_mse = _train_and_evaluate_model(fuel_model, train_df, eval_df, FUEL_FEATURES, FUEL_TARGET, fuel_model_path)
+    pace_mse = _train_and_evaluate_model(pace_model, train_df, eval_df, PACE_FEATURES, PACE_TARGET, pace_model_path)
+
+    # 5. Save evaluation metrics
+    metrics = {
+        'tire_degradation_model_mse': tire_mse,
+        'fuel_consumption_model_mse': fuel_mse,
+        'pace_prediction_model_mse': pace_mse
+    }
+    metrics_path = os.path.join(fn_args.serving_model_dir, METRICS_FILE)
+    with open(metrics_path, 'w') as f:
+        json.dump(metrics, f)
+    print(f"Evaluation metrics saved to {metrics_path}")

mcp_server/pipeline/pipeline.py

@@ -0,0 +1,112 @@
+import os
+from typing import Text
+from absl import logging
+
+from tfx import v1 as tfx
+from tfx.orchestration import pipeline
+from tfx.orchestration.beam.beam_dag_runner import BeamDagRunner
+
+from mcp_server.pipeline.evaluator import CustomEvaluator
+
+# --- Pipeline Configuration ---
+
+PIPELINE_NAME = "mcp-server-pipeline"
+PIPELINE_ROOT = os.path.join('mcp_server', 'pipelines', PIPELINE_NAME)
+DATA_ROOT = os.path.join('mcp_server', 'unzipped_data', 'barber-motorsports-park', 'barber')
+MODULE_FILE = os.path.join('mcp_server', 'pipeline', 'module.py')
+SERVING_MODEL_DIR = os.path.join('mcp_server', 'serving_model', PIPELINE_NAME)
+
+METADATA_PATH = os.path.join('mcp_server', 'metadata', PIPELINE_NAME, 'metadata.db')
+
+# --- Pipeline Definition ---
+
+def create_pipeline(
+    pipeline_name: Text,
+    pipeline_root: Text,
+    data_root: Text,
+    module_file: Text,
+    serving_model_dir: Text,
+    metadata_path: Text,
+) -> pipeline.Pipeline:
+    """Creates a TFX pipeline."""
+
+    # 1. Data Ingestion (ExampleGen)
+    output_config = tfx.proto.Output(
+        split_config=tfx.proto.SplitConfig(splits=[
+            tfx.proto.SplitConfig.Split(name='train', hash_buckets=4),
+            tfx.proto.SplitConfig.Split(name='eval', hash_buckets=1)
+        ])
+    )
+    example_gen = tfx.components.CsvExampleGen(
+        input_base=data_root,
+        output_config=output_config
+    )
+
+    # 2. Data Validation (StatisticsGen, SchemaGen)
+    statistics_gen = tfx.components.StatisticsGen(
+        examples=example_gen.outputs['examples']
+    )
+
+    schema_gen = tfx.components.SchemaGen(
+        statistics=statistics_gen.outputs['statistics'],
+        infer_feature_shape=False
+    )
+
+    # 3. Model Training (Trainer)
+    trainer = tfx.components.Trainer(
+        module_file=module_file,
+        examples=example_gen.outputs['examples'],
+        schema=schema_gen.outputs['schema'],
+        custom_executor_spec=tfx.extensions.google_cloud_ai_platform.ExecutorSpec(
+            python_executor=tfx.components.trainer.executor.GenericExecutor
+        )
+    )
+
+    # 4. Model Evaluation (CustomEvaluator)
+    evaluator = CustomEvaluator(
+        model=trainer.outputs['model']
+    )
+
+    # 5. Model Pushing (Pusher) - Conditional on Blessing
+    pusher = tfx.components.Pusher(
+        model=trainer.outputs['model'],
+        model_blessing=evaluator.outputs['blessing'], # This is the critical connection
+        push_destination=tfx.proto.PushDestination(
+            filesystem=tfx.proto.PushDestination.Filesystem(
+                base_directory=serving_model_dir
+            )
+        )
+    )
+
+    components = [
+        example_gen,
+        statistics_gen,
+        schema_gen,
+        trainer,
+        evaluator,
+        pusher,
+    ]
+
+    return pipeline.Pipeline(
+        pipeline_name=pipeline_name,
+        pipeline_root=pipeline_root,
+        components=components,
+        metadata_connection_config=tfx.orchestration.metadata.sqlite_metadata_connection_config(metadata_path),
+        enable_cache=True,
+    )
+
+if __name__ == '__main__':
+    logging.set_verbosity(logging.INFO)
+
+    # To run this pipeline, you would typically use a TFX orchestrator like
+    # Kubeflow or a local runner. The BeamDagRunner is for local execution.
+    # We are including this to make the pipeline runnable directly.
+    pipeline = create_pipeline(
+        pipeline_name=PIPELINE_NAME,
+        pipeline_root=PIPELINE_ROOT,
+        data_root=DATA_ROOT,
+        module_file=MODULE_FILE,
+        serving_model_dir=SERVING_MODEL_DIR,
+        metadata_path=METADATA_PATH,
+    )
+    BeamDagRunner().run(pipeline)

mcp_server/prepare_data.py

@@ -0,0 +1,45 @@
+import os
+import pandas as pd
+
+from data_handling.data_downloader import download_and_move_files
+from data_handling.data_loader import unzip_data
+from data_handling.telemetry_parser import parse_telemetry
+
+def main():
+    """
+    Prepares the data for the TFX pipeline by downloading, unzipping,
+    parsing, and saving it as a CSV file.
+    """
+    script_dir = os.path.dirname(os.path.abspath(__file__))
+    data_dir = os.path.join(script_dir, 'data')
+    unzipped_data_dir = os.path.join(script_dir, 'unzipped_data')
+    csv_output_dir = os.path.join(unzipped_data_dir, 'barber-motorsports-park', 'barber')
+
+    # 1. Download and unzip data if not already present
+    if not os.path.exists(data_dir):
+        print("Downloading data...")
+        download_and_move_files(data_dir)
+    else:
+        print("Data directory already exists.")
+
+    if not os.path.exists(unzipped_data_dir):
+        print("Unzipping data...")
+        unzip_data(data_dir, unzipped_data_dir)
+    else:
+        print("Unzipped data directory already exists.")
+
+    # 2. Parse the race data
+    print("Parsing telemetry data...")
+    race_data = parse_telemetry(csv_output_dir)
+
+    if race_data is not None:
+        # 3. Save the parsed data to a CSV file
+        csv_output_path = os.path.join(csv_output_dir, 'data.csv')
+        print(f"Saving parsed data to {csv_output_path}...")
+        race_data.to_csv(csv_output_path, index=False)
+        print("Data preparation complete.")
+    else:
+        print("Failed to parse race data. Data preparation failed.")
+
+if __name__ == "__main__":
+    main()

mcp_server/pyproject.toml

@@ -0,0 +1,27 @@
+[project]
+name = "mcp-server"
+version = "0.1.0"
+description = "MCP Server for the Hack the Track Monte Carlo Simulation"
+requires-python = ">=3.11,<3.13"
+dependencies = [
+    "google-adk>=1.18.0",
+    "numpy",
+    "pandas",
+    "scikit-learn>=1.7.2",
+    "joblib",
+    "requests"
+]
+
+[project.optional-dependencies]
+test = [
+    "pytest>=8.4.2",
+]
+dev = [
+    "matplotlib>=3.8.0",
+]
+
+[tool.setuptools]
+py-modules = ["main", "monte_carlo_simulation"]
+
+[tool.setuptools.packages.find]
+include = ["data_handling*", "models*"]

mcp_server/requirements.txt

@@ -0,0 +1,7 @@
+pandas
+numpy
+scikit-learn
+joblib
+requests
+fastmcp==2.12.4
+google-cloud-storage

mcp_server/run_server_local.py

@@ -0,0 +1,106 @@
+import asyncio
+import os
+import sys
+
+# Add the current directory to sys.path so we can import modules
+sys.path.append(os.path.join(os.path.dirname(__file__), '..'))
+
+from mcp import types as mcp_types
+from mcp.server.lowlevel import Server
+from mcp.server.models import InitializationOptions
+import mcp.server.stdio as mcp_stdio
+
+from google.adk.tools.function_tool import FunctionTool
+from google.adk.tools.mcp_tool import adk_to_mcp_tool_type
+
+from mcp_server.data_handling.telemetry_parser import parse_telemetry
+from mcp_server.monte_carlo_simulation import MonteCarloSimulation
+
+# --- Globals ---
+app = Server(name="MonteCarloServer")
+adk_tool_to_expose = None
+mc_simulation = None
+
+# --- MCP Server Handlers ---
+@app.list_tools()
+async def list_mcp_tools() -> list[mcp_types.Tool]:
+    """MCP handler to list tools this server exposes."""
+    # print("MCP Server: Received list_tools request.", file=sys.stderr)
+    if adk_tool_to_expose:
+        mcp_tool_schema = adk_to_mcp_tool_type(adk_tool_to_expose)
+        # print(f"MCP Server: Advertising tool: {mcp_tool_schema.name}", file=sys.stderr)
+        return [mcp_tool_schema]
+    return []
+
+@app.call_tool()
+async def call_mcp_tool(
+    name: str, arguments: dict
+) -> list[mcp_types.Content]:
+    """MCP handler to execute a tool call requested by an MCP client."""
+    print(f"MCP Server: Received call_tool request for '{name}' with args: {arguments}", file=sys.stderr)
+    if adk_tool_to_expose and name == adk_tool_to_expose.name:
+        # We are not passing any arguments to the function, so we can just call it.
+        result = adk_tool_to_expose.func()
+        return [mcp_types.Content(text=f"Tool {name} completed with result: {result}")]
+    return [mcp_types.Content(text=f"Tool {name} not found.")]
+
+
+# --- Server Initialization ---
+async def run_mcp_stdio_server():
+    """Runs the MCP server as a stdio server."""
+    async with mcp_stdio.stdio_server() as (read_stream, write_stream):
+        init_options = InitializationOptions(
+            server_name="MonteCarloServer",
+            server_version="0.1.0",
+            capabilities={},
+        )
+        await app.run(read_stream, write_stream, init_options)
+
+
+def main():
+    """Initializes and runs the MCP server locally."""
+    global adk_tool_to_expose, mc_simulation
+
+    script_dir = os.path.dirname(os.path.abspath(__file__))
+    
+    # 1. Use local trained models
+    model_dir = os.path.join(script_dir, 'trained_models')
+    if not os.path.exists(model_dir):
+        print(f"Model directory not found: {model_dir}", file=sys.stderr)
+        return
+
+    print(f"Loading models from: {model_dir}", file=sys.stderr)
+
+    # 2. Load the race data
+    race_data_dir = os.path.join(script_dir, 'unzipped_data', 'barber-motorsports-park', 'barber')
+    if not os.path.exists(race_data_dir):
+         print(f"Race data directory not found: {race_data_dir}. Please run prepare_data.py first.", file=sys.stderr)
+         return
+
+    race_data = parse_telemetry(race_data_dir) 
+    
+    if race_data is None:
+        print("Failed to load race data. Exiting.", file=sys.stderr)
+        return
+
+    # 3. Initialize the Monte Carlo simulation
+    mc_simulation = MonteCarloSimulation(race_data, model_dir=model_dir)
+
+    # 4. Create the ADK tool to expose
+    adk_tool_to_expose = FunctionTool(
+        func=mc_simulation.find_optimal_pit_window,
+    )
+
+    # 5. Run the MCP server
+    print("Starting MCP Server...", file=sys.stderr)
+    try:
+        asyncio.run(run_mcp_stdio_server())
+    except KeyboardInterrupt:
+        print("\nMCP Server (stdio) stopped by user.", file=sys.stderr)
+    except Exception as e:
+        print(f"MCP Server (stdio) encountered an error: \n{e}", file=sys.stderr)
+
+    print("MCP Server (stdio) process exiting.", file=sys.stderr)
+
+if __name__ == "__main__":
+    main()

mcp_server/tests/test_prepare_data.py

@@ -0,0 +1,66 @@
+import os
+import pandas as pd
+import pytest
+from unittest.mock import patch, MagicMock
+
+# Since the prepare_data script is not in a package, we need to add its directory to the path
+import sys
+sys.path.append(os.path.abspath(os.path.join(os.path.dirname(__file__), '..')))
+
+from prepare_data import main as prepare_data_main
+
+@pytest.fixture
+def temp_data_dir(tmp_path):
+    """Creates a temporary data directory structure for testing."""
+    mcp_server_dir = tmp_path / "mcp_server"
+    data_dir = mcp_server_dir / "data"
+    unzipped_dir = mcp_server_dir / "unzipped_data" / "barber-motorsports-park" / "barber"
+    unzipped_dir.mkdir(parents=True, exist_ok=True)
+    data_dir.mkdir(parents=True, exist_ok=True)
+
+    # Create a dummy analysis and telemetry file
+    analysis_data = {
+        'LAP_NUMBER': [1], 'LAP_TIME': ['1:30.5'], 'DRIVER_NUMBER': [1]
+    }
+    telemetry_data = {
+        'timestamp': [100], 'lap': [1], 'vehicle_id': [1],
+        'telemetry_name': ['speed'], 'telemetry_value': [150]
+    }
+    pd.DataFrame(analysis_data).to_csv(unzipped_dir / "Test_Analysis.csv", index=False, sep=';')
+    pd.DataFrame(telemetry_data).to_csv(unzipped_dir / "Test_Telemetry.csv", index=False)
+
+    return mcp_server_dir
+
+
+@patch('prepare_data.download_and_move_files')
+@patch('prepare_data.unzip_data')
+@patch('prepare_data.parse_telemetry')
+def test_prepare_data_main(mock_parse_telemetry, mock_unzip_data, mock_download_files, temp_data_dir):
+    """Tests the main data preparation script."""
+    # Mock the functions that download and unzip data
+    mock_download_files.return_value = None
+    mock_unzip_data.return_value = None
+
+    # Mock the telemetry parser to return a simple DataFrame
+    mock_parsed_df = pd.DataFrame({'lap': [1], 'speed': [150]})
+    mock_parse_telemetry.return_value = mock_parsed_df
+
+    # We need to change the working directory so the script can find the data
+    original_cwd = os.getcwd()
+    os.chdir(temp_data_dir)
+
+    # Run the script
+    with patch('prepare_data.script_dir', '.'):
+         prepare_data_main()
+
+
+    # Check that the output CSV was created
+    output_csv_path = "unzipped_data/barber-motorsports-park/barber/data.csv"
+    assert os.path.exists(output_csv_path)
+
+    # Check the content of the CSV
+    result_df = pd.read_csv(output_csv_path)
+    pd.testing.assert_frame_equal(result_df, mock_parsed_df)
+
+    # Clean up
+    os.chdir(original_cwd)

mcp_server/tests/test_trainer_module.py

@@ -0,0 +1,79 @@
+import os
+import json
+import joblib
+import pytest
+import tempfile
+import pandas as pd
+from unittest.mock import MagicMock
+
+# Add the pipeline directory to the path to import the module
+import sys
+sys.path.append(os.path.abspath(os.path.join(os.path.dirname(__file__), '..', 'pipeline')))
+
+from module import run_fn
+
+# --- Mock Objects to replace TFX dependencies ---
+
+class MockFnArgs:
+    """A mock class to simulate TFX's FnArgs."""
+    def __init__(self, train_files, eval_files, schema_path, serving_model_dir, data_accessor):
+        self.train_files = train_files
+        self.eval_files = eval_files
+        self.schema_path = schema_path
+        self.serving_model_dir = serving_model_dir
+        self.data_accessor = data_accessor
+
+class MockDataAccessor:
+    """A mock class to simulate the TFX DataAccessor."""
+    def tf_dataset_factory(self, file_pattern, tfxio_options, schema):
+        return []
+
+# --- Test Fixtures ---
+
+@pytest.fixture
+def fn_args():
+    """Creates a mock FnArgs object for testing the Trainer's run_fn."""
+    with tempfile.TemporaryDirectory() as temp_dir:
+        serving_model_dir = os.path.join(temp_dir, 'serving_model')
+        os.makedirs(serving_model_dir, exist_ok=True)
+        schema_path = os.path.join(temp_dir, 'schema.pbtxt')
+        with open(schema_path, 'w') as f:
+            f.write('')
+
+        args = MockFnArgs(
+            train_files=['train_dir'],
+            eval_files=['eval_dir'],
+            schema_path=schema_path,
+            serving_model_dir=serving_model_dir,
+            data_accessor=MockDataAccessor(),
+        )
+        yield args
+
+# --- Tests ---
+
+def test_run_fn_creates_models_and_metrics(fn_args, monkeypatch):
+    """Tests that the run_fn trains and saves all models and the metrics file."""
+    dummy_data = {
+        'lap': [1, 2, 3], 'accx_can': [0.1, 0.2, 0.3], 'accy_can': [0.1, 0.2, 0.3],
+        'Steering_Angle': [10, 15, 20], 'lap_time': [90, 91, 92],
+        'nmot': [8000, 8100, 8200], 'aps': [50, 55, 60], 'fuel_consumption': [0.5, 0.55, 0.6],
+        'speed': [150, 151, 152], 'gear': [4, 4, 5], 'pbrake_f': [0, 0, 1], 'pbrake_r': [0, 0, 0],
+        'traffic': [0, 1, 0], 'relative_pace': [1.0, 1.1, 1.2]
+    }
+    dummy_df = pd.DataFrame(dummy_data)
+    monkeypatch.setattr('module._dataset_to_pandas', lambda a, b: dummy_df)
+
+    run_fn(fn_args)
+
+    assert os.path.exists(os.path.join(fn_args.serving_model_dir, "tire_degradation_model.pkl"))
+    assert os.path.exists(os.path.join(fn_args.serving_model_dir, "fuel_consumption_model.pkl"))
+    assert os.path.exists(os.path.join(fn_args.serving_model_dir, "pace_prediction_model.pkl"))
+
+    metrics_path = os.path.join(fn_args.serving_model_dir, "evaluation_metrics.json")
+    assert os.path.exists(metrics_path)
+
+    with open(metrics_path, 'r') as f:
+        metrics = json.load(f)
+    assert 'tire_degradation_model_mse' in metrics
+    assert 'fuel_consumption_model_mse' in metrics
+    assert 'pace_prediction_model_mse' in metrics

mcp_server/trained_models/fuel_consumption_model.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:9589f7bdd46e0053d08b8ded1a25d94946de384a8e5e86c67302e3245bcd006b
+size 857

mcp_server/trained_models/pace_prediction_model.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a9102c6190fe6a55461b35f760943cd0397602ad2b1177ac268c0bc9b114bcce
+size 40065

mcp_server/trained_models/tire_degradation_model.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:8d1c10157ac28bdb6c9993ed234c98009289866a3d9fe45c5df5178411e1a712
+size 921

mcp_server/unzipped_data/barber-motorsports-park/barber/03_Provisional Results_Race 1_Anonymized.CSV

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:5278b828d7c88bb505b9c727f442140488a077451089d49594e02cbaab45068d
+size 2462

mcp_server/unzipped_data/barber-motorsports-park/barber/03_Provisional Results_Race 2_Anonymized.CSV

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:038a61038a8b2377561a3b0afd66fb385684a4d1be81e7705c06554d651462b3
+size 2455

mcp_server/unzipped_data/barber-motorsports-park/barber/03_Results GR Cup Race 2 Official_Anonymized.CSV

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:038a61038a8b2377561a3b0afd66fb385684a4d1be81e7705c06554d651462b3
+size 2455

mcp_server/unzipped_data/barber-motorsports-park/barber/05_Results by Class GR Cup Race 1 Official_Anonymized.CSV

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b02f2186e58956c26a6c793436ddb2a0657efdb083d43a3143106c0ad0b37385
+size 1611

mcp_server/unzipped_data/barber-motorsports-park/barber/23_AnalysisEnduranceWithSections_Race 1_Anonymized.CSV

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:11abe9a38bfee35412ae8243cbf9a852ca120c680b161a892b1f4d8fda81f566
+size 142657

mcp_server/unzipped_data/barber-motorsports-park/barber/99_Best 10 Laps By Driver_Race 1_Anonymized.CSV

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:4132edff314583f21bfd7deda0b693b4476a66a6215bb389ff934164d4d94ab4
+size 3547