main.py

from typing import Any
import httpx
from mcp.server.fastmcp import FastMCP

from typing import Any, Optional
import httpx
import json
from mcp.server.fastmcp import FastMCP
from os import getenv
from dotenv import load_dotenv

async def get_game_details(
    game_name: str,
    fields: Optional[list[str]] = None,
    include: Optional[list[str]] = None
) -> dict:
    """
    Search through games on TheGamesDB by name. Returns: JSON array. Argument: name (required).
    """


    """
    Makes an asynchronous GET request to TheGamesDB API to retrieve game details by name.

    Args:
        game_name (str): The name of the game to search for.
        fields (list[str], optional): A list of additional fields to include in the response.
                                      Defaults to ['players', 'publishers', 'genres', 'overview',
                                                  'last_updated', 'rating', 'platform', 'coop',
                                                  'youtube', 'os', 'processor', 'ram', 'hdd',
                                                  'video', 'sound', 'alternates'].
        include (list[str], optional): A list of related data to include (e.g., 'boxart', 'platform').
                                       Defaults to ['boxart', 'platform'].

    Returns:
        dict: A dictionary containing the JSON response from the API, or an error message.
    """
    base_url = "https://api.thegamesdb.net/v1.1/Games/ByGameName"

    # Set default values for fields and include if not provided
    if fields is None:
        fields = [
            'players', 'publishers', 'genres', 'overview', 'last_updated', 'rating',
            'platform', 'coop', 'youtube', 'os', 'processor', 'ram', 'hdd',
            'video', 'sound', 'alternates'
        ]
    if include is None:
        include = ['boxart', 'platform']

    # Construct query parameters
    params = {
        "apikey": THEGAMESDB_API_KEY, # Use the global API key
        "name": game_name,
        "fields": ",".join(fields),  # Join list elements with a comma
        "include": ",".join(include) # Join list elements with a comma
    }

    try:
        # Use an asynchronous httpx client
        async with httpx.AsyncClient() as client:
            print(f"Making request to: {base_url} with params: {params}")
            response = await client.get(base_url, params=params, follow_redirects=True)

            # Raise an exception for bad status codes (4xx or 5xx)
            response.raise_for_status()

            # Parse the JSON response
            data = response.json()
            return data

    except httpx.RequestError as e:
        print(f"An error occurred while requesting {e.request.url!r}: {e}")
        return {"error": f"Network or request error: {e}"}
    except httpx.HTTPStatusError as e:
        print(f"Error response {e.response.status_code} while requesting {e.request.url!r}: {e}")
        return {"error": f"API returned an error: Status {e.response.status_code}, Response: {e.response.text}"}
    except json.JSONDecodeError as e:
        print(f"Failed to decode JSON response: {e}")
        return {"error": f"Invalid JSON response from API: {e}"}
    except Exception as e:
        print(f"An unexpected error occurred: {e}")
        return {"error": f"An unexpected error occurred: {e}"}


async def get_platform_details() -> dict:
    """
    Makes an asynchronous GET request to TheGamesDB API to retrieve platform details.

    Args:
        fields (list[str], optional): A list of additional fields to include in the response.
                                      Defaults to ['icon', 'console', 'controller', 'developer',
                                                  'manufacturer', 'media', 'cpu', 'memory',
                                                  'graphics', 'sound', 'maxcontrollers',
                                                  'display', 'overview', 'youtube'].

    Returns:
        dict: A dictionary containing the JSON response from the API, or an error message.
    """

    base_url = "https://api.thegamesdb.net/v1/Platforms"

    # Set default values for fields if not provided
    fields = [
            'icon', 'console', 'controller', 'developer', 'manufacturer', 'media',
            'cpu', 'memory', 'graphics', 'sound', 'maxcontrollers', 'display',
            'overview', 'youtube'
        ]

    # Construct query parameters
    params = {
        "apikey": THEGAMESDB_API_KEY, # Use the global API key loaded from .env
        "fields": ",".join(fields),  # Join list elements with a comma
    }

    try:
        # Use an asynchronous httpx client
        async with httpx.AsyncClient() as client:
            print(f"Making request to: {base_url} with params: {params}")
            response = await client.get(base_url, params=params, follow_redirects=True)

            # Raise an exception for bad status codes (4xx or 5xx)
            response.raise_for_status()

            # Parse the JSON response
            data = response.json()
            return data

    except httpx.RequestError as e:
        print(f"An error occurred while requesting {e.request.url!r}: {e}")
        return {"error": f"Network or request error: {e}"}
    except httpx.HTTPStatusError as e:
        print(f"Error response {e.response.status_code} while requesting {e.request.url!r}: {e}")
        return {"error": f"API returned an error: Status {e.response.status_code}, Response: {e.response.text}"}
    except json.JSONDecodeError as e:
        print(f"Failed to decode JSON response: {e}")
        return {"error": f"Invalid JSON response from API: {e}"}
    except Exception as e:
        print(f"An unexpected error occurred: {e}")
        return {"error": f"An unexpected error occurred: {e}"}

# Initialize FastMCP server
mcp = FastMCP("testmonkey")

@mcp.tool()
async def TGDB_search_game(game_name: str) -> str:
    a = await get_game_details(game_name)
    return json.dumps(a)

@mcp.tool()
async def TGDB_platforms_details() -> str:
    """
    Returns the Platforms (C64, Amiga etc) recorded on TheGamesDB. Returns: JSON data.
    """
    a = await get_platform_details()
    return json.dumps(a)

# Run the server

if __name__ == "__main__":

    # Load environment variables from a .env file
    # Ensure you have 'python-dotenv' installed (pip install python-dotenv)
    # And create a .env file in the same directory as your script with:
    # THEGAMESDB_API_KEY="YOUR_ACTUAL_API_KEY_HERE"
    load_dotenv()


    # Define the API key globally, loaded from environment variables.
    # This is a more secure way to manage API keys than hardcoding them.
    THEGAMESDB_API_KEY = getenv("THEGAMESDB_API_KEY")

    # Ensure API key is available before making the request
    if not THEGAMESDB_API_KEY:
        print ({"error": "API Key is missing. Cannot proceed with the request."})
        exit()

    # Initialize and run the server
    mcp.run(transport='stdio')