Jose-Prince/Game-Predictor-MCP

Game-predictor MCP Server

A Model Context Protocol (MCP) server that predicts video game scores using machine learning based on game characteristics like price, release month, tags, genres, and platforms.

Purpose

This MCP server provides AI assistants with the capability to predict game scores (similar to Metacritic ratings) by analyzing various game attributes. It uses a Random Forest regression model trained on Steam game data to make predictions.

Features

• Score Prediction: Predicts game scores (0-100 scale) based on game characteristics
• Steam Data Integration: Automatically collects game data from Steam API and SteamSpy
• RAWG API Integration: Retrieves additional platform information
• Machine Learning: Uses scikit-learn's Random Forest algorithm for predictions
• MCP Protocol: Compatible with Claude Desktop and other MCP clients

Requirements

Dependencies

Install the required packages:

pip install -r requirements.txt

API Keys

You'll need a RAWG API key for platform data:

1. Sign up at RAWG.io
2. Create a .env file in the project root:

RAWG_KEY=your_rawg_api_key_here

Installation & Setup

1. Clone/Download the project
2. Install dependencies:

   pip install -r requirements.txt
   

3. Set up environment variables:

   echo "RAWG_KEY=your_api_key" > .env
   

4. Run the server:

   python mcp_server/main.py
   

How It Works

Data Collection

• On first run, the server automatically creates a dataset by fetching game information from:
  • SteamSpy: Player statistics and tags
  • Steam Store API: Game details and pricing
  • RAWG API: Platform information and ratings
• Data is saved to data/games_dataset.csv

Model Training

• Uses Random Forest regression with 200 estimators
• Features include: price, release month, encoded tags/genres/platforms, and player statistics
• Target variable: Game score (Metacritic or RAWG rating converted to 0-100 scale)

Available Tools

make_prediction

Predicts a game's score based on its characteristics.

Parameters:

• price (float): Game price in USD
• release_month (int): Month of release (1-12)
• tags (list[str]): List of game tags (e.g., ["Action", "Multiplayer"])
• genres (list[str]): List of game genres (e.g., ["Action", "Adventure"])
• platforms (list[str]): List of platforms (e.g., ["PC", "PlayStation 5"])

Returns: Predicted score (float, 0-100 scale)

Usage Examples

Here are some example queries you can use with the MCP server:

Basic Prediction

"Predict the score for a $29.99 action game releasing in December with tags 'Action' and 'Singleplayer', genre 'Action', on PC platform"

Indie Game Prediction

"What score would you predict for an indie puzzle game costing $14.99, releasing in March, with tags ['Indie', 'Puzzle', 'Casual'], genres ['Indie', 'Casual'], and available on ['PC', 'Nintendo Switch']?"

AAA Game Prediction

"Predict the score for a $59.99 AAA RPG releasing in November with tags ['RPG', 'Open World', 'Multiplayer'], genres ['Action', 'RPG'], on ['PC', 'PlayStation 5', 'Xbox Series X/S']"

Free-to-Play Game

"What would be the predicted score for a free-to-play battle royale game (price: 0) releasing in June with tags ['Free to Play', 'Battle Royale', 'Multiplayer'], genres ['Action'], on ['PC', 'Mobile']?"

File Structure

mcp_server/
├── main.py                 # Entry point
├── server.py              # FastMCP server setup
├── tools/
│   └── predict_tool.py    # Prediction tool definition
├── utils/
│   ├── game.py           # Game data collection utilities
│   └── predict_model.py  # ML model setup and prediction
├── data/                 # Generated dataset storage
│   └── games_dataset.csv # Game data (auto-generated)
├── requirements.txt      # Python dependencies
└── .env                 # Environment variables (you create this)

Configuration with Claude Desktop

To use this server with Claude Desktop, add it to your claude_desktop_config.json:

{
  "mcpServers": {
    "game-predictor": {
      "command": "python",
      "args": ["/path/to/your/mcp_server/main.py"],
      "env": {
        "RAWG_KEY": "your_rawg_api_key_here"
      }
    }
  }
}

Limitations

• Dataset Size: Initially limited to 1000 games to avoid API rate limits
• API Dependencies: Requires internet connection for RAWG API
• Rate Limiting: Includes 1-second delays between API calls
• Data Quality: Predictions depend on the quality of training data
• Regional Variations: Scores may not reflect regional preferences

Troubleshooting

Common Issues

1. "games_dataset.csv not found":

   • This is normal on first run. The server will automatically create the dataset.

2. API Rate Limiting:

   • The server includes built-in delays to respect API limits
   • If you encounter rate limits, wait before retrying

3. Model Not Trained Error:

   • Ensure setup_model() is called before making predictions
   • Check that the CSV file was created successfully

4. Missing RAWG API Key:

   • Verify your .env file exists and contains the correct API key
   • Ensure the key is valid and active