Update app.py

app.py

@@ -1,3 +1,8 @@
+"""
+FPL Point Predictor with Gradio MCP Support
+Exposes FPL predictions as MCP tools for Claude Desktop
+"""
+
 import pandas as pd
 import numpy as np
 import requests
@@ -7,6 +12,7 @@ import gradio as gr
 from sklearn.linear_model import Ridge
 from sklearn.preprocessing import StandardScaler
 from xgboost import XGBRegressor
+from typing import Optional, List
 import warnings
 
 warnings.filterwarnings('ignore')
@@ -21,7 +27,6 @@ class CachedFPL_API:
             os.makedirs(cache_dir)
 
     def fetch_data(self, endpoint):
-        # Create a safe filename from the endpoint
         filename = endpoint.replace("/", "_").replace("?", "_").replace("&", "_") + ".json"
         filepath = os.path.join(self.cache_dir, filename)
 
@@ -29,7 +34,6 @@ class CachedFPL_API:
             with open(filepath, 'r', encoding='utf-8') as f:
                 return json.load(f)
 
-        # If not cached, fetch from API
         url = f"{self.base_url}{endpoint}"
         print(f"Fetching data from API: {url}")
         try:
@@ -63,31 +67,26 @@ class CachedFPL_API:
 
 def load_and_process_data():
     """Load and process FPL data, train models, and generate predictions"""
-
-    # Initialize API
     FPL = CachedFPL_API()
 
-    # 1. Fetch Basic Data
+    # Fetch Basic Data
     bootstrap_data = FPL.get_bootstrap_static()
     events = bootstrap_data['events']
     teams = bootstrap_data['teams']
     elements = bootstrap_data['elements']
 
-    # Determine Current Gameweek
     current_gameweek = next((event['id'] for event in events if event['is_current']), None)
     if not current_gameweek:
         current_gameweek = next((event['id'] for event in events if event['is_next']), 1) - 1
 
-    # Create Players DataFrame
     all_players = pd.DataFrame(elements)
     all_players['full_name'] = all_players['first_name'] + " " + all_players['second_name']
 
-    # 2. Fetch Player History
+    # Fetch Player History
     player_histories = []
     for index, player in all_players.iterrows():
         player_id = player['id']
         history = FPL.get_player_summary(player_id)
-
         if history and 'history' in history:
             df_history = pd.DataFrame(history['history'])
             df_history['element'] = player_id
@@ -95,7 +94,7 @@ def load_and_process_data():
 
     all_fpl_players_games = pd.concat(player_histories, ignore_index=True)
 
-    # 3. Preprocessing & Feature Engineering
+    # Preprocessing
     cols_to_numeric = ['influence', 'creativity', 'threat', 'ict_index', 'expected_goals',
                        'expected_assists', 'expected_goal_involvements', 'expected_goals_conceded']
     for col in cols_to_numeric:
@@ -112,29 +111,24 @@ def load_and_process_data():
             for fixture in fixtures:
                 if fixture['finished']:
                     team_stats_data.append({
-                        'team_id': fixture['team_h'],
-                        'round': gw,
-                        'goals_scored': fixture['team_h_score'],
-                        'goals_conceded': fixture['team_a_score'],
+                        'team_id': fixture['team_h'], 'round': gw,
+                        'goals_scored': fixture['team_h_score'], 'goals_conceded': fixture['team_a_score'],
                         'was_home': True
                     })
                     team_stats_data.append({
-                        'team_id': fixture['team_a'],
-                        'round': gw,
-                        'goals_scored': fixture['team_a_score'],
-                        'goals_conceded': fixture['team_h_score'],
+                        'team_id': fixture['team_a'], 'round': gw,
+                        'goals_scored': fixture['team_a_score'], 'goals_conceded': fixture['team_h_score'],
                         'was_home': False
                     })
 
     team_stats_df = pd.DataFrame(team_stats_data)
-    window_size = 5
     team_stats_df = team_stats_df.sort_values(by=['team_id', 'round'])
 
     team_stats_df['attack_strength'] = team_stats_df.groupby('team_id')['goals_scored'].transform(
-        lambda x: x.rolling(window_size, min_periods=1).mean().shift(1)
+        lambda x: x.rolling(5, min_periods=1).mean().shift(1)
     )
     team_stats_df['defence_strength'] = team_stats_df.groupby('team_id')['goals_conceded'].transform(
-        lambda x: x.rolling(window_size, min_periods=1).mean().shift(1)
+        lambda x: x.rolling(5, min_periods=1).mean().shift(1)
     )
     team_stats_df.fillna(0, inplace=True)
 
@@ -142,23 +136,15 @@ def load_and_process_data():
         columns={'attack_strength': 'opponent_attack_strength', 'defence_strength': 'opponent_defence_strength'}
     )
 
-    final_df = pd.merge(
-        all_fpl_players_games,
-        opponent_strength,
-        left_on=['opponent_team', 'round'],
-        right_on=['team_id', 'round'],
-        how='left'
-    )
+    final_df = pd.merge(all_fpl_players_games, opponent_strength,
+                       left_on=['opponent_team', 'round'], right_on=['team_id', 'round'], how='left')
     final_df.drop('team_id', axis=1, inplace=True)
 
-    # Add Difficulty Feature
+    # Add Difficulty
     all_fixtures = FPL.get_fixtures()
     fixture_difficulty_map = {}
     for f in all_fixtures:
-        fixture_difficulty_map[f['id']] = {
-            'h': f['team_h_difficulty'],
-            'a': f['team_a_difficulty']
-        }
+        fixture_difficulty_map[f['id']] = {'h': f['team_h_difficulty'], 'a': f['team_a_difficulty']}
 
     def get_difficulty(row):
         fid = row['fixture']
@@ -168,7 +154,7 @@ def load_and_process_data():
 
     final_df['difficulty'] = final_df.apply(get_difficulty, axis=1)
 
-    # Player Rolling Stats
+    # Rolling Stats
     stats_to_roll = ['minutes', 'goals_scored', 'assists', 'bps', 'influence', 'creativity',
                      'threat', 'expected_goals', 'expected_assists', 'expected_goals_conceded', 'total_points']
     final_df = final_df.sort_values(by=['element', 'round'])
@@ -181,20 +167,15 @@ def load_and_process_data():
     final_df['total_points_SD5'] = final_df.groupby('element')['total_points'].transform(
         lambda x: x.rolling(window=5, min_periods=1).std().shift(1)
     )
-
     final_df['total_points_RA10'] = final_df.groupby('element')['total_points'].transform(
         lambda x: x.rolling(window=10, min_periods=1).mean().shift(1)
     )
 
     def get_trend_emoji(row):
-        short = row['total_points_RA5']
-        long = row['total_points_RA10']
+        short, long = row['total_points_RA5'], row['total_points_RA10']
         if short > 0 and long > 0:
-            if short > long: return '⬆️'
-            elif short < long: return '⬇️'
-            else: return '➡️'
-        elif short > 0 or long > 0: return '➡️'
-        else: return '⚪'
+            return '⬆️' if short > long else ('⬇️' if short < long else '➡️')
+        return '➡️' if short > 0 or long > 0 else '⚪'
 
     final_df['Trend'] = final_df.apply(get_trend_emoji, axis=1)
     final_df.fillna(0, inplace=True)
@@ -204,7 +185,7 @@ def load_and_process_data():
                 'opponent_defence_strength', 'total_points_SD5'] + [f'{stat}_RA5' for stat in stats_to_roll]
     target = 'total_points'
 
-    # 4. Time-Based Split & Model Training
+    # Train Models
     final_df = final_df.sort_values(by='round')
     unique_rounds = final_df['round'].unique()
     split_idx = int(len(unique_rounds) * 0.8)
@@ -213,14 +194,11 @@ def load_and_process_data():
     train_df = final_df[final_df['round'] <= split_round]
     test_df = final_df[final_df['round'] > split_round]
 
-    X_train = train_df[features]
-    y_train = train_df[target]
-    X_test = test_df[features]
-    y_test = test_df[target]
+    X_train, y_train = train_df[features], train_df[target]
+    X_test, y_test = test_df[features], test_df[target]
 
     scaler = StandardScaler()
     X_train_scaled = scaler.fit_transform(X_train)
-    X_test_scaled = scaler.transform(X_test)
 
     ridge_model = Ridge()
     ridge_model.fit(X_train_scaled, y_train)
@@ -228,7 +206,7 @@ def load_and_process_data():
     xgb_model = XGBRegressor(n_estimators=100, learning_rate=0.1, random_state=42)
     xgb_model.fit(X_train_scaled, y_train)
 
-    # 5. Generate Predictions for Next Gameweek
+    # Generate Predictions
     NEXT_GW = current_gameweek + 1
     next_gw_fixtures = FPL.get_gameweek_fixtures(NEXT_GW)
     prediction_rows = []
@@ -236,29 +214,17 @@ def load_and_process_data():
     if next_gw_fixtures:
         team_fixture_map = {}
         for f in next_gw_fixtures:
-            team_fixture_map[f['team_h']] = {
-                'opponent': f['team_a'],
-                'was_home': True,
-                'difficulty': f['team_h_difficulty']
-            }
-            team_fixture_map[f['team_a']] = {
-                'opponent': f['team_h'],
-                'was_home': False,
-                'difficulty': f['team_a_difficulty']
-            }
+            team_fixture_map[f['team_h']] = {'opponent': f['team_a'], 'was_home': True, 'difficulty': f['team_h_difficulty']}
+            team_fixture_map[f['team_a']] = {'opponent': f['team_h'], 'was_home': False, 'difficulty': f['team_a_difficulty']}
 
         for idx, player in all_players.iterrows():
             team_id = player['team']
             if team_id in team_fixture_map:
                 fix_info = team_fixture_map[team_id]
                 prediction_rows.append({
-                    'element': player['id'],
-                    'web_name': player['web_name'],
-                    'team': team_id,
-                    'value': player['now_cost'],
-                    'was_home': fix_info['was_home'],
-                    'opponent_team': fix_info['opponent'],
-                    'difficulty': fix_info['difficulty']
+                    'element': player['id'], 'web_name': player['web_name'], 'team': team_id,
+                    'value': player['now_cost'], 'was_home': fix_info['was_home'],
+                    'opponent_team': fix_info['opponent'], 'difficulty': fix_info['difficulty']
                 })
 
     prediction_df = pd.DataFrame(prediction_rows)
@@ -274,7 +240,6 @@ def load_and_process_data():
 
     # Calculate latest rolling stats
     player_stats_latest = final_df.sort_values(by=['element', 'round']).copy()
-
     for stat in stats_to_roll:
         player_stats_latest[f'{stat}_RA5_latest'] = player_stats_latest.groupby('element')[stat].transform(
             lambda x: x.rolling(window=5, min_periods=1).mean()
@@ -283,22 +248,17 @@ def load_and_process_data():
     player_stats_latest['total_points_SD5_latest'] = player_stats_latest.groupby('element')['total_points'].transform(
         lambda x: x.rolling(window=5, min_periods=1).std()
     )
-
     player_stats_latest['total_points_RA10_latest'] = player_stats_latest.groupby('element')['total_points'].transform(
         lambda x: x.rolling(window=10, min_periods=1).mean()
     )
 
-    def get_trend_emoji_latest(row):
-        short = row[f'total_points_RA5_latest']
-        long = row['total_points_RA10_latest']
+    def get_trend_latest(row):
+        short, long = row['total_points_RA5_latest'], row['total_points_RA10_latest']
         if short > 0 and long > 0:
-            if short > long: return '⬆️'
-            elif short < long: return '⬇️'
-            else: return '➡️'
-        elif short > 0 or long > 0: return '➡️'
-        else: return '⚪'
+            return '⬆️' if short > long else ('⬇️' if short < long else '➡️')
+        return '➡️' if short > 0 or long > 0 else '⚪'
 
-    player_stats_latest['Trend'] = player_stats_latest.apply(get_trend_emoji_latest, axis=1)
+    player_stats_latest['Trend'] = player_stats_latest.apply(get_trend_latest, axis=1)
     player_stats_latest = player_stats_latest.groupby('element').tail(1)
 
     cols_to_merge = ['element', 'total_points_SD5_latest', 'Trend'] + [f'{stat}_RA5_latest' for stat in stats_to_roll]
@@ -314,19 +274,16 @@ def load_and_process_data():
     X_pred = prediction_df[features]
     X_pred_scaled = scaler.transform(X_pred)
 
-    prediction_df['Ridge Pred'] = ridge_model.predict(X_pred_scaled)
-    prediction_df['XGB Pred'] = xgb_model.predict(X_pred_scaled)
+    prediction_df['Ridge Pred'] = ridge_model.predict(X_pred_scaled).clip(min=0)
+    prediction_df['XGB Pred'] = xgb_model.predict(X_pred_scaled).clip(min=0)
 
-    prediction_df['Ridge Pred'] = prediction_df['Ridge Pred'].clip(lower=0)
-    prediction_df['XGB Pred'] = prediction_df['XGB Pred'].clip(lower=0)
-
-    # Prepare final predictions dataframe
+    # Prepare final dataframe
     final_predictions_df = prediction_df.copy()
     final_predictions_df['player_name'] = final_predictions_df['web_name']
 
     element_type_map = all_players.set_index('id')['element_type'].to_dict()
-    final_predictions_df['element_type'] = final_predictions_df['element'].map(element_type_map)
     position_map = {1: 'Goalkeeper', 2: 'Defender', 3: 'Midfielder', 4: 'Forward'}
+    final_predictions_df['element_type'] = final_predictions_df['element'].map(element_type_map)
     final_predictions_df['position'] = final_predictions_df['element_type'].map(position_map)
 
     team_name_mapping = {team['id']: team['name'] for team in teams}
@@ -342,28 +299,11 @@ def load_and_process_data():
 
     final_predictions_df = pd.merge(final_predictions_df, cols_from_players, on='element', how='left')
 
-    rename_map = {
+    final_predictions_df.rename(columns={
         'total_points_RA5': 'Pts Mean (5GW)',
         'total_points_SD5': 'Pts Std Dev (5GW)',
         'opponent_team': 'Next Opponent'
-    }
-    final_predictions_df.rename(columns=rename_map, inplace=True)
-
-    final_predictions_df['Closest Prediction Method'] = 'Pending'
-    final_predictions_df['Actual GW Pts'] = 0
-
-    cols_to_show = [
-        'element', 'player_name', 'team_name', 'position', 'Next Opponent',
-        'Ridge Pred', 'XGB Pred', 'Actual GW Pts', 'Closest Prediction Method',
-        'Total Pts', 'Last GW Pts', 'Pts Mean (5GW)', 'Pts Std Dev (5GW)', 'Trend',
-        'difficulty', 'was_home', 'value'
-    ]
-
-    for col in cols_to_show:
-        if col not in final_predictions_df.columns:
-            final_predictions_df[col] = 0
-
-    final_predictions_df = final_predictions_df[cols_to_show]
+    }, inplace=True)
 
     numericals = ['Ridge Pred', 'XGB Pred', 'Pts Mean (5GW)', 'Pts Std Dev (5GW)']
     for col in numericals:
@@ -402,8 +342,7 @@ def load_and_process_data():
             manager_players_df = pd.merge(
                 manager_players_df,
                 final_predictions_df[['element', 'XGB Pred', 'difficulty', 'Next Opponent']],
-                on='element',
-                how='left'
+                on='element', how='left'
             )
         else:
             manager_players_df = pd.DataFrame(columns=['player_name', 'team_name', 'position', 'XGB Pred'])
@@ -414,106 +353,200 @@ def load_and_process_data():
     return final_predictions_df, team_performance_df, manager_players_df, current_gameweek, NEXT_GW
 
 
-# Load data when app starts
+# Load data
 print("Loading FPL data and training models...")
 final_predictions_df, team_performance_df, manager_players_df, current_gameweek, NEXT_GW = load_and_process_data()
 print("Data loaded successfully!")
 
 
-def filter_predictions(position=None, team=None, player_name=None):
-    filtered_df = final_predictions_df.copy()
+# MCP Tool Functions (exposed to Claude)
+def get_top_predictions(top_n: int = 10, position: Optional[str] = None) -> pd.DataFrame:
+    """
+    Get top predicted players for the upcoming gameweek.
+
+    Args:
+        top_n (int): Number of top players to return (default: 10)
+        position (str): Optional filter by position: Goalkeeper, Defender, Midfielder, or Forward
+
+    Returns:
+        pd.DataFrame: Top predicted players with their stats
+    """
+    df = final_predictions_df.copy()
+
     if position:
-        filtered_df = filtered_df[filtered_df['position'] == position]
-    if team:
-        filtered_df = filtered_df[filtered_df['team_name'] == team]
-    if player_name and len(player_name) >= 3:
-        filtered_df = filtered_df[filtered_df['player_name'].str.contains(player_name, case=False, na=False)]
+        df = df[df['position'] == position]
+
+    df = df.sort_values('XGB Pred', ascending=False).head(top_n)
+
+    cols = ['player_name', 'team_name', 'position', 'value', 'XGB Pred',
+            'Pts Mean (5GW)', 'Trend', 'difficulty']
+
+    return df[cols]
+
+
+def compare_players(player1_name: str, player2_name: str, player3_name: Optional[str] = None) -> pd.DataFrame:
+    """
+    Compare multiple players side-by-side with their statistics.
+
+    Args:
+        player1_name (str): First player name to compare
+        player2_name (str): Second player name to compare
+        player3_name (str): Optional third player name to compare
+
+    Returns:
+        pd.DataFrame: Comparison of players with their predictions and stats
+    """
+    df = final_predictions_df.copy()
+
+    player_names = [player1_name, player2_name]
+    if player3_name:
+        player_names.append(player3_name)
+
+    matched_players = []
+    for name in player_names:
+        matches = df[df['player_name'].str.contains(name, case=False, na=False)]
+        if not matches.empty:
+            matched_players.append(matches.iloc[0])
+
+    if not matched_players:
+        return pd.DataFrame({"error": ["No players found"]})
+
+    comparison_df = pd.DataFrame(matched_players)
 
-    cols = [
-        'element', 'player_name', 'team_name', 'position', 'Next Opponent',
-        'Ridge Pred', 'XGB Pred', 'Actual GW Pts', 'Closest Prediction Method',
-        'Total Pts', 'Last GW Pts', 'Pts Mean (5GW)', 'Pts Std Dev (5GW)', 'Trend',
-        'difficulty', 'was_home', 'value'
-    ]
-    return filtered_df[cols]
+    cols = ['player_name', 'team_name', 'position', 'value', 'XGB Pred',
+            'Ridge Pred', 'Total Pts', 'Last GW Pts', 'Pts Mean (5GW)',
+            'Pts Std Dev (5GW)', 'Trend', 'difficulty']
 
+    return comparison_df[cols]
 
-def export_to_csv(df, filename_prefix="fpl_predictions"):
-    if not filename_prefix:
-        filename_prefix = "fpl_predictions"
-    filename = f"{filename_prefix}.csv"
-    df.to_csv(filename, index=False)
-    return filename
 
+def get_team_stats(team_name: Optional[str] = None) -> pd.DataFrame:
+    """
+    Get team performance statistics including attack and defense rankings.
+
+    Args:
+        team_name (str): Optional team name to filter (e.g., 'Arsenal', 'Liverpool')
+
+    Returns:
+        pd.DataFrame: Team performance statistics
+    """
+    df = team_performance_df.copy()
+
+    if team_name:
+        df = df[df['team_name'].str.contains(team_name, case=False, na=False)]
+
+    df = df.sort_values('attack_rank')
+
+    cols = ['team_name', 'goals_scored_per_game', 'goals_conceded_per_game',
+            'attack_rank', 'defense_rank']
+
+    return df[cols]
+
+
+def get_differentials(max_price: float = 10.0, min_predicted: float = 4.0, top_n: int = 10) -> pd.DataFrame:
+    """
+    Find best differential players (high predicted points at low price).
+
+    Args:
+        max_price (float): Maximum player price in millions (default: 10.0)
+        min_predicted (float): Minimum predicted points (default: 4.0)
+        top_n (int): Number of results to return (default: 10)
+
+    Returns:
+        pd.DataFrame: Best differential players
+    """
+    df = final_predictions_df.copy()
+
+    df = df[(df['value'] <= max_price) & (df['XGB Pred'] >= min_predicted)]
+    df = df.sort_values('XGB Pred', ascending=False).head(top_n)
+
+    cols = ['player_name', 'team_name', 'position', 'value', 'XGB Pred',
+            'Pts Mean (5GW)', 'Trend', 'difficulty']
+
+    return df[cols]
+
+
+def get_manager_team_predictions() -> pd.DataFrame:
+    """
+    Get your current FPL manager team with predictions for next gameweek.
+
+    Returns:
+        pd.DataFrame: Manager team with predictions
+    """
+    return manager_players_df
 
-unique_positions = final_predictions_df['position'].unique().tolist()
-unique_teams = final_predictions_df['team_name'].unique().tolist()
 
 # Build Gradio Interface
-with gr.Blocks(title=f"Gameweek {NEXT_GW} Predicted Points") as interface:
-    gr.Markdown(f"# FPL Gameweek {NEXT_GW} Predicted Points")
+with gr.Blocks(title=f"FPL GW {NEXT_GW} Predictor (MCP)") as demo:
+    gr.Markdown(f"# FPL Gameweek {NEXT_GW} Point Predictor")
     gr.Markdown("""
-    This app predicts Fantasy Premier League player points using machine learning models (Ridge Regression & XGBoost).
+    **MCP-Enabled**: This app exposes prediction tools for Claude Desktop!
 
-    **Features:**
-    - Predictions based on rolling averages, team strength, fixture difficulty, and more
-    - Trend indicators showing player form (⬆️ improving, ⬇️ declining, ➡️ stable)
-    - Team performance analysis
-    - Export predictions to CSV
+    Use the functions below or connect via Claude Desktop to query FPL data.
     """)
 
-    with gr.Row():
-        position_filter = gr.Dropdown(choices=[None] + unique_positions, label="Filter by Position")
-        team_filter = gr.Dropdown(choices=[None] + unique_teams, label="Filter by Team")
-        player_name_filter = gr.Textbox(label="Filter by Player Name (min 3 letters)")
-
-    output_dataframe = gr.Dataframe(label="Filtered Predictions", interactive=False)
-
-    with gr.Row():
-        export_filename = gr.Textbox(label="Filename Prefix", value="fpl_predictions")
-        export_button = gr.Button("Export Predictions to CSV")
-        export_output = gr.File(label="Download CSV")
+    with gr.Tab("Top Predictions"):
+        with gr.Row():
+            top_n_input = gr.Slider(5, 50, value=10, step=5, label="Number of Players")
+            position_input = gr.Dropdown(
+                choices=["", "Goalkeeper", "Defender", "Midfielder", "Forward"],
+                label="Position Filter",
+                value=""
+            )
+        top_pred_btn = gr.Button("Get Top Predictions")
+        top_pred_output = gr.Dataframe()
 
-    export_button.click(
-        fn=export_to_csv,
-        inputs=[output_dataframe, export_filename],
-        outputs=export_output
-    )
+        top_pred_btn.click(
+            fn=lambda n, p: get_top_predictions(n, p if p else None),
+            inputs=[top_n_input, position_input],
+            outputs=top_pred_output
+        )
 
-    gr.Markdown("## Team Performance and Ranks")
-    gr.Dataframe(
-        value=team_performance_df[['team_name', 'overall_goals_scored', 'overall_goals_conceded',
-                                   'goals_scored_per_game', 'goals_conceded_per_game',
-                                   'attack_rank', 'defense_rank']].round(2),
-        label="Team Performance",
-        interactive=False
-    )
+    with gr.Tab("Compare Players"):
+        player1 = gr.Textbox(label="Player 1", value="Salah")
+        player2 = gr.Textbox(label="Player 2", value="Haaland")
+        player3 = gr.Textbox(label="Player 3 (Optional)", value="")
+        compare_btn = gr.Button("Compare Players")
+        compare_output = gr.Dataframe()
+
+        compare_btn.click(
+            fn=lambda p1, p2, p3: compare_players(p1, p2, p3 if p3 else None),
+            inputs=[player1, player2, player3],
+            outputs=compare_output
+        )
 
-    gr.Markdown("## My Manager Team")
-    gr.Dataframe(
-        value=manager_players_df,
-        label=f"Manager Team for Gameweek {current_gameweek}",
-        interactive=False
-    )
+    with gr.Tab("Team Stats"):
+        team_input = gr.Textbox(label="Team Name (optional)", value="")
+        team_btn = gr.Button("Get Team Stats")
+        team_output = gr.Dataframe()
 
-    with gr.Row():
-        mgr_export_filename = gr.Textbox(label="Manager Filename Prefix", value="manager_team")
-        mgr_export_button = gr.Button("Export Manager Team to CSV")
-        mgr_export_output = gr.File(label="Download Manager CSV")
+        team_btn.click(
+            fn=lambda t: get_team_stats(t if t else None),
+            inputs=team_input,
+            outputs=team_output
+        )
 
-    manager_df_state = gr.State(value=manager_players_df)
+    with gr.Tab("Differentials"):
+        with gr.Row():
+            max_price = gr.Slider(4.0, 15.0, value=8.0, step=0.5, label="Max Price (£m)")
+            min_pred = gr.Slider(0.0, 10.0, value=4.0, step=0.5, label="Min Predicted Points")
+            diff_top_n = gr.Slider(5, 30, value=10, step=5, label="Results")
+        diff_btn = gr.Button("Find Differentials")
+        diff_output = gr.Dataframe()
+
+        diff_btn.click(
+            fn=get_differentials,
+            inputs=[max_price, min_pred, diff_top_n],
+            outputs=diff_output
+        )
 
-    mgr_export_button.click(
-        fn=export_to_csv,
-        inputs=[manager_df_state, mgr_export_filename],
-        outputs=mgr_export_output
-    )
+    with gr.Tab("My Team"):
+        mgr_btn = gr.Button("Load My Team")
+        mgr_output = gr.Dataframe()
 
-    inputs = [position_filter, team_filter, player_name_filter]
-    for inp in inputs:
-        inp.change(fn=filter_predictions, inputs=inputs, outputs=output_dataframe)
+        mgr_btn.click(fn=get_manager_team_predictions, outputs=mgr_output)
 
-    interface.load(fn=filter_predictions, inputs=inputs, outputs=output_dataframe)
 
 if __name__ == "__main__":
-    interface.launch()
+    # Enable MCP server - this exposes all functions as tools for Claude!
+    demo.launch(mcp_server=True)