🎮 SteamMCP

AI-Powered Steam Game Recommendation Agent

SteamMCP is an agentic AI application that recommends Steam games based on natural language preferences. It uses the Model Context Protocol (MCP) to allow an LLM agent to dynamically discover and invoke specialized recommendation tools.

The application supports game search, similarity-based recommendations, tag-based recommendations, platform filtering, and detailed game metadata retrieval.

🌐 Live Demo: https://steam-mcp-alpha.vercel.app/

🚀 Features

• 🤖 AI-powered game recommendations using an LLM agent

• 🔌 Model Context Protocol (MCP) tool integration

• 🔍 Search Steam games by name

• 🎮 Find games similar to a selected game

• 🏷️ Recommend games based on Steam tags and preferences

• 💻 Filter recommendations by platform

  • Windows

  • macOS

  • Linux

• 📖 Retrieve detailed game information

• 🌐 REST API built with FastAPI

• ⚛️ React frontend

• ☁️ Cloud deployment using Render and Vercel

Related MCP server: Steam MCP Server

🏗️ Architecture

                    User
                     │
                     ▼
              React Frontend
                     │
                     ▼
                FastAPI API
                     │
                     ▼
                AI Agent
                     │
                     ▼
              Groq LLM API
                     │
              Tool Selection
                     │
                     ▼
              MCP Client / Server
                     │
       ┌─────────────┼─────────────┐
       ▼             ▼             ▼
 Game Search    Tag Recommender  Game Details
       │             │             │
       └─────────────┼─────────────┘
                     │
                     ▼
                Steam Dataset

🧠 How It Works

SteamMCP uses an LLM agent to understand the user's request and decide which tools should be used.

For example:

User Request

"I want a relaxing farming game."

The AI agent:

1. Understands the user's preferences.

2. Selects the appropriate MCP recommendation tool.

3. Calls the tool through the MCP server.

4. Receives game recommendations.

5. Generates a final response based only on the returned tool results.

🔌 MCP Tools

The MCP server exposes the following tools.

search_for_games

Search for Steam games by name.

Input:
Game name

Output:
Matching Steam games and app IDs

recommend_similar_games

Find games similar to a selected Steam game.

Input:
appid
platform (optional)

Output:
Similar games

recommend_by_preferences

Recommend games based on Steam tags.

Example:

Tags:
farming
crafting
simulation
management

Optional platform filtering:

windows
mac
linux

get_game_details_tool

Retrieve detailed metadata for a Steam game.

Example information includes:

• Game name

• Genres

• Tags

• Platform support

• Ratings

• Price

• Description

🛠️ Tech Stack

Backend

• Python

• FastAPI

• Model Context Protocol (MCP)

• Groq

• Pandas

• NumPy

Frontend

• React

• JavaScript

• CSS

Deployment

• Render

• Vercel

📁 Project Structure

SteamMCP/
│
├── src/
│   │
│   ├── agent/
│   │   └── steam_agent.py
│   │
│   ├── api/
│   │   └── main.py
│   │
│   ├── mcp/
│   │   └── server.py
│   │
│   ├── recommenders/
│   │   ├── tag_recommender.py
│   │   └── hybrid_recommender.py
│   │
│   ├── search/
│   │   ├── game_search.py
│   │   └── game_details.py
│   │
│   └── utils/
│       ├── data_loader.py
│       └── filters.py
│
├── data/
│
├── requirements.txt
│
└── README.md

⚙️ Installation

1. Clone the Repository

git clone https://github.com/rayyan2099/SteamMCP.git

cd SteamMCP

2. Create a Virtual Environment

python -m venv venv

Activate it.

macOS / Linux

source venv/bin/activate

Windows

venv\Scripts\activate

3. Install Dependencies

pip install -r requirements.txt

4. Configure Environment Variables

Create a .env file:

GROQ_API_KEY=your_groq_api_key_here

▶️ Running the Backend

Start the FastAPI server:

uvicorn src.api.main:app --reload

The API will be available at:

http://localhost:8000

📚 API Documentation

FastAPI automatically generates interactive API documentation.

Open:

http://localhost:8000/docs

🎮 API Usage

Recommendation Endpoint

POST /recommend

Request

{
    "query": "I want a relaxing farming game"
}

Response

{
    "recommendation": "Based on your preferences, here are some recommended games..."
}

🤖 Agent Workflow

User Query
    │
    ▼
FastAPI Endpoint
    │
    ▼
SteamMCP Agent
    │
    ▼
Groq LLM
    │
    ▼
Tool Selection
    │
    ▼
MCP Tool Call
    │
    ▼
Steam Recommendation Engine
    │
    ▼
Tool Results
    │
    ▼
LLM Generates Final Recommendation

🧩 Example Queries

Find Similar Games

Games similar to Stardew Valley

Tag-Based Recommendations

Recommend some open-world survival crafting games

Platform Filtering

Recommend RPG games that work on Mac

Game Search

Find games similar to Hollow Knight

🧠 Recommendation System

SteamMCP uses multiple recommendation strategies.

Tag-Based Recommendations

Games are compared using Steam tags.

Example:

Input:
farming
crafting
simulation

↓

Find games with similar tags.

Similar Game Recommendations

Given a Steam game's appid, the system identifies games with similar metadata and tags.

Platform Filtering

Recommendations can be filtered based on platform availability.

Supported platforms:

Windows
macOS
Linux

🔒 Tool-Grounded Responses

The AI agent is instructed to avoid hallucinating game information.

The agent:

• Uses MCP tools to retrieve game data.

• Does not invent game mechanics or metadata.

• Uses retrieved information when generating recommendations.

• Retrieves detailed game information before providing factual details.

🌐 Deployment

Backend

The FastAPI backend is deployed using:

Render

Frontend

The React frontend is deployed using:

Vercel

🎯 What I Learned

This project explores several concepts in modern AI engineering:

• AI Agents

• Tool Calling

• Model Context Protocol (MCP)

• LLM Orchestration

• Agent-to-tool communication

• REST API development

• Recommendation systems

• Cloud deployment

• Frontend and backend integration

🔮 Future Improvements

Potential improvements include:

• Semantic search using embedding models

• Improved hybrid recommendation algorithms

• User accounts and saved recommendations

• Conversation memory

• Streaming responses

• Steam API integration for real-time data

• Improved frontend UI

• Recommendation feedback system

👨‍💻 Author

Rayyan Kaukab Faridy

• GitHub: https://github.com/rayyan2099

• LinkedIn: https://www.linkedin.com/in/rayyan-faridy/

📄 License

This project is intended for educational and portfolio purposes.

⭐ If you found this project interesting, consider giving the repository a star!