Skip to main content
Glama

get_game_info

Fetch detailed information for one or more Steam games by AppID. Includes descriptions, prices, developers, platforms, metacritic scores, and review statistics. Optionally get system requirements and DLC with filtering by review quality.

Instructions

Get detailed information about one or more Steam games by AppID. Returns comprehensive game data including description, price, developers, publishers, platforms, metacritic score, review statistics, and optionally system requirements and DLC list. Supports filtering by review quality criteria.

Input Schema

TableJSON Schema
NameRequiredDescriptionDefault
appIdsYesArray of Steam AppIDs to fetch information for (supports batch queries)
includeStatsNoInclude review statistics (default: true)
includeCurrentPlayersNoInclude current player count (default: false)
criteriaNoOptional filter criteria - only games matching ALL criteria will be returned
includeRequirementsNoInclude system requirements (PC minimum/recommended specs)
includeDlcNoInclude list of available DLC

Implementation Reference

  • Input parameter interface for get_game_info tool. Defines appIds (required array), includeStats, and includeCurrentPlayers.
    export interface GetGameInfoInput {
      appIds: number[]; // Support batch queries
      includeStats?: boolean; // Default: true
      includeCurrentPlayers?: boolean; // Default: false
    }
  • src/index.ts:60-129 (registration)
    Tool registration definition for get_game_info in the tools array. Includes name, description, and JSON input schema exposed to MCP clients.
    {
      name: 'get_game_info',
      description:
        'Get detailed information about one or more Steam games by AppID. Returns comprehensive game data including description, price, developers, publishers, platforms, metacritic score, review statistics, and optionally system requirements and DLC list. Supports filtering by review quality criteria.',
      inputSchema: {
        type: 'object',
        properties: {
          appIds: {
            type: 'array',
            items: { type: 'number' },
            description: 'Array of Steam AppIDs to fetch information for (supports batch queries)',
            minItems: 1,
            maxItems: 10,
          },
          includeStats: {
            type: 'boolean',
            description: 'Include review statistics (default: true)',
          },
          includeCurrentPlayers: {
            type: 'boolean',
            description: 'Include current player count (default: false)',
          },
          criteria: {
            type: 'object',
            description:
              'Optional filter criteria - only games matching ALL criteria will be returned',
            properties: {
              minReviewScore: {
                type: 'number',
                description: 'Minimum review score percentage (0-100)',
                minimum: 0,
                maximum: 100,
              },
              minReviews: {
                type: 'number',
                description: 'Minimum number of total reviews',
                minimum: 0,
              },
              maxPrice: {
                type: 'number',
                description: 'Maximum price in cents (e.g., 1999 for $19.99)',
                minimum: 0,
              },
              requireFree: {
                type: 'boolean',
                description: 'Only include free games',
              },
              requireMetacritic: {
                type: 'boolean',
                description: 'Only include games with metacritic scores',
              },
              minMetacritic: {
                type: 'number',
                description: 'Minimum metacritic score (0-100)',
                minimum: 0,
                maximum: 100,
              },
            },
          },
          includeRequirements: {
            type: 'boolean',
            description: 'Include system requirements (PC minimum/recommended specs)',
          },
          includeDlc: {
            type: 'boolean',
            description: 'Include list of available DLC',
          },
        },
        required: ['appIds'],
      },
  • Zod schema for validating get_game_info input. Extends the basic interface with criteria, includeRequirements, and includeDlc fields.
    const getGameInfoSchema = z.object({
      appIds: z.array(z.number()).min(1).max(10),
      includeStats: z.boolean().optional(),
      includeCurrentPlayers: z.boolean().optional(),
      criteria: gameInfoCriteriaSchema.optional(),
      includeRequirements: z.boolean().optional(),
      includeDlc: z.boolean().optional(),
    });
  • Main handler for the get_game_info tool (stdio mode). Validates input via Zod schema, fetches game details via SteamAPIClient.getAppDetails, optionally fetches review stats, current player counts, DLC names, filters by criteria, generates info summaries, and returns enriched game data.
    } else if (name === 'get_game_info') {
      const validatedInput = getGameInfoSchema.parse(args);
    
      // Fetch game details
      const games = await steamClient.getAppDetails(validatedInput.appIds);
    
      // Determine if we need review stats (default: include, or required for criteria)
      const hasCriteria = validatedInput.criteria !== undefined;
      const includeStats = validatedInput.includeStats !== false || hasCriteria;
      const reviewSummaries = new Map<number, ReviewStats | null>();
    
      if (includeStats) {
        await Promise.all(
          games.map(async (game) => {
            try {
              const stats = await steamClient.getReviewSummary(game.appId);
              reviewSummaries.set(game.appId, stats);
            } catch (error) {
              // Silently fail for review stats (not critical)
              console.error(`Failed to get review summary for ${game.appId}:`, error);
              reviewSummaries.set(game.appId, null);
            }
          })
        );
      }
    
      // Optionally include current players
      if (validatedInput.includeCurrentPlayers ?? false) {
        await Promise.all(
          games.map(async (game) => {
            try {
              game.currentPlayers = await steamClient.getCurrentPlayers(game.appId);
            } catch (error) {
              // Silently fail for current players (not critical)
              console.error(`Failed to get current players for ${game.appId}:`, error);
            }
          })
        );
      }
    
      // Build enriched games with review stats attached
      const gamesWithStats = games.map((game) => {
        const reviewStats = reviewSummaries.get(game.appId);
        return {
          ...game,
          reviewStats: includeStats ? reviewStats : undefined,
        };
      });
    
      // Fetch DLC names if requested
      if (validatedInput.includeDlc) {
        // Collect all DLC AppIDs from all games
        const allDlcAppIds: number[] = [];
        for (const game of gamesWithStats) {
          if (game.dlc && game.dlc.length > 0) {
            for (const dlc of game.dlc) {
              if (dlc.appId) {
                allDlcAppIds.push(dlc.appId);
              }
            }
          }
        }
    
        // Fetch DLC names in parallel
        if (allDlcAppIds.length > 0) {
          const dlcNames = await steamClient.fetchDlcNames(allDlcAppIds);
    
          // Update DLC names in games
          for (const game of gamesWithStats) {
            if (game.dlc && game.dlc.length > 0) {
              for (const dlc of game.dlc) {
                const name = dlcNames.get(dlc.appId);
                if (name) {
                  dlc.name = name;
                }
              }
            }
          }
        }
      }
    
      // Strip out optional fields if not requested
      const processedGames = gamesWithStats.map((game) => {
        const processed = { ...game };
    
        if (!validatedInput.includeRequirements) {
          delete processed.systemRequirements;
        }
    
        if (!validatedInput.includeDlc) {
          delete processed.dlc;
        }
    
        return processed;
      });
    
      // Filter by criteria if provided
      let filteredGames = processedGames;
      if (validatedInput.criteria) {
        filteredGames = processedGames.filter((game) =>
          meetsGameCriteria(game, validatedInput.criteria!)
        );
      }
    
      // Generate info summaries for filtered results
      const enrichedGames = filteredGames.map((game) => ({
        ...game,
        infoSummary: generateInfoSummary(game, game.reviewStats ?? null),
      }));
    
      return {
        content: [
          {
            type: 'text',
            text: JSON.stringify(enrichedGames, null, 2),
          },
        ],
      };
  • Duplicate handler for the get_game_info tool (HTTP/SSE mode). Contains identical logic as the stdio handler - validates input, fetches game details, review stats, current players, DLC names, filters by criteria, and returns enriched results.
    } else if (name === 'get_game_info') {
      const validatedInput = getGameInfoSchema.parse(args);
      const games = await steamClient.getAppDetails(validatedInput.appIds);
      const hasCriteria = validatedInput.criteria !== undefined;
      const includeStats = validatedInput.includeStats !== false || hasCriteria;
      const reviewSummaries = new Map<number, ReviewStats | null>();
    
      if (includeStats) {
        await Promise.all(
          games.map(async (game) => {
            try {
              const stats = await steamClient.getReviewSummary(game.appId);
              reviewSummaries.set(game.appId, stats);
            } catch (error) {
              console.error(`Failed to get review summary for ${game.appId}:`, error);
              reviewSummaries.set(game.appId, null);
            }
          })
        );
      }
    
      if (validatedInput.includeCurrentPlayers ?? false) {
        await Promise.all(
          games.map(async (game) => {
            try {
              game.currentPlayers = await steamClient.getCurrentPlayers(game.appId);
            } catch (error) {
              console.error(`Failed to get current players for ${game.appId}:`, error);
            }
          })
        );
      }
    
      const gamesWithStats = games.map((game) => ({
        ...game,
        reviewStats: includeStats ? reviewSummaries.get(game.appId) : undefined,
      }));
    
      // Fetch DLC names if requested
      if (validatedInput.includeDlc) {
        // Collect all DLC AppIDs from all games
        const allDlcAppIds: number[] = [];
        for (const game of gamesWithStats) {
          if (game.dlc && game.dlc.length > 0) {
            for (const dlc of game.dlc) {
              if (dlc.appId) {
                allDlcAppIds.push(dlc.appId);
              }
            }
          }
        }
    
        // Fetch DLC names in parallel
        if (allDlcAppIds.length > 0) {
          const dlcNames = await steamClient.fetchDlcNames(allDlcAppIds);
    
          // Update DLC names in games
          for (const game of gamesWithStats) {
            if (game.dlc && game.dlc.length > 0) {
              for (const dlc of game.dlc) {
                const name = dlcNames.get(dlc.appId);
                if (name) {
                  dlc.name = name;
                }
              }
            }
          }
        }
      }
    
      const processedGames = gamesWithStats.map((game) => {
        const processed = { ...game };
        if (!validatedInput.includeRequirements) delete processed.systemRequirements;
        if (!validatedInput.includeDlc) delete processed.dlc;
        return processed;
      });
    
      let filteredGames = processedGames;
      if (validatedInput.criteria) {
        filteredGames = processedGames.filter((game) =>
          meetsGameCriteria(game, validatedInput.criteria!)
        );
      }
    
      const enrichedGames = filteredGames.map((game) => ({
        ...game,
        infoSummary: generateInfoSummary(game, game.reviewStats ?? null),
      }));
    
      return {
        content: [{ type: 'text', text: JSON.stringify(enrichedGames, null, 2) }],
      };
Behavior2/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations exist, so the description must disclose behavioral traits. It does not mention side effects, rate limits, permissions, or data freshness. The operation is read-only but that is implied. Lacks necessary behavioral context for safe agent invocation.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness4/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is concise, front-loaded with the core purpose, and uses efficient language. It could be slightly more structured (e.g., bullet points) but remains clear and avoids unnecessary verbosity.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness4/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

With no output schema, the description adequately explains return values (list of data fields). It covers the main parameters and optional includes. Minor gaps like pagination or error handling are absent, but overall complete for a game info retrieval tool.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters4/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema coverage is 100%, but the description adds meaning by listing the type of returned data (e.g., 'description, price, developers, publishers, platforms, metacritic score, review statistics') and explaining optional includes and filtering criteria. This adds context beyond the schema's parameter descriptions.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states 'Get detailed information about one or more Steam games by AppID' and lists specific data fields (description, price, developers, etc.). It distinguishes from siblings like analyze_reviews and search_steam_games by focusing on retrieving comprehensive game data for given AppIDs.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines3/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description implies use when you have AppIDs and want detailed info, but provides no explicit guidance on when to use alternatives (e.g., search_steam_games for discovering AppIDs). No exclusions or when-not-to-use context is given.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Install Server

Other Tools

Latest Blog Posts

MCP directory API

We provide all the information about MCP servers via our MCP API.

curl -X GET 'https://glama.ai/api/mcp/v1/servers/jhomen368/steam-reviews-mcp'

If you have feedback or need assistance with the MCP directory API, please join our Discord server