A
licenseB
qualityD
maintenanceEnables LLMs to retrieve and analyze Steam game reviews, providing access to review statistics, game information, and helping summarize pros and cons of games.
1
27
7
MIT
Steam Reviews MCP
by jhomen368
This server lets AI assistants search Steam games, fetch and filter user reviews, and perform sentiment analysis on reviews via the Model Context Protocol.
Search games: Single or batch queries (up to 5) with per-query limits, returning AppID, name, price, and preview image.
Get game details: Fetch comprehensive info by AppID, including description, developers, platforms, Metacritic, price, review stats, and optionally system requirements, DLC, and current player counts.
Filter games by criteria: Return only games matching conditions like minimum review score, minimum reviews, price cap, free-only, or Metacritic presence.
Fetch reviews: Retrieve user reviews with filters for sentiment (positive/negative), language, purchase type, time range (last N days), Steam Deck, and review-bomb/off-topic filtering.
Paginate reviews: Use cursors to page through large review sets (up to 100 per request).
Analyze sentiment: Automatically analyze review sentiment, identify common themes, drill into specific topics like performance, and get example quotes with Steam community links.
Work with pre-fetched reviews: Pass existing reviews into analysis to avoid duplicate API calls.
Reduce API load: Built-in caching and rate limiting help minimize Steam API usage.
Allows filtering of game information and search results based on Metacritic review scores and availability.
Provides comprehensive tools to search for Steam games, retrieve detailed game information including system requirements and DLC, and fetch user reviews with advanced filtering options.
Enables specialized filtering of game reviews to focus on Steam Deck compatibility and performance feedback.
Steam Reviews MCP Server
A Model Context Protocol (MCP) server for Steam game reviews and analysis. Search games, fetch reviews, and analyze sentiment through the Model Context Protocol.
🎯 Key Features
🔍 Game Search - Search Steam games by name with batch support (up to 5 queries)
📊 Detailed Game Info - Get comprehensive game data with criteria filtering
💬 Review Fetching - Advanced filtering (time-bounded, Steam Deck, review bombs)
🧠 Sentiment Analysis - NLP-powered analysis with topic drill-down
⚡ Smart Caching - 70-85% API call reduction with variable TTL
🔗 Example Quotes - Clickable Steam community links for review quotes
📣 App Announcements - Official Steam Community posts, patch notes, and hotfixes
Related MCP server: Steam Review and Forum MCP
🔒 Security
🐳 Hardened Docker Images
Non-root user (mcpuser)
Multi-stage builds
Minimal Alpine base
dumb-init process management
✅ Input Validation
Zod schema validation for all inputs
Type-safe TypeScript throughout
🛠️ Available Tools
Tool | Purpose | Key Features |
search_steam_games | Search for games | Single/batch search, AppID lookup, price info |
get_game_info | Get game details | Regional pricing, purchase notices, languages, Store features, Deck compatibility |
fetch_reviews | Fetch user reviews | Advanced filters, pagination, time-bounded queries |
analyze_reviews | Analyze sentiment | NLP analysis, topic drill-down, example quotes with links |
fetch_app_announcements | Read official app announcements | Full available Steam markup, publication details, backward pagination |
📋 Prerequisites
Node.js 18.0 or higher
npm or compatible package manager
No API key required! Uses public Steam Store API
🚀 Quick Start
Option 1: NPM (Recommended)
npm install -g @jhomen368/steam-reviews-mcpConfigure with Claude Desktop:
Add to your configuration file:
macOS:
~/Library/Application Support/Claude/claude_desktop_config.jsonWindows:
%APPDATA%\Claude\claude_desktop_config.json
{
"mcpServers": {
"steam-reviews": {
"command": "npx",
"args": ["-y", "@jhomen368/steam-reviews-mcp"]
}
}
}Option 2: Docker (HTTP Mode)
docker run -d \
--name steam-reviews-mcp \
-p 8086:8086 \
ghcr.io/jhomen368/steam-reviews-mcp:latestDocker Compose:
services:
steam-reviews-mcp:
image: ghcr.io/jhomen368/steam-reviews-mcp:latest
container_name: steam-reviews-mcp
ports:
- "8086:8086"
restart: unless-stoppedTest the server:
curl http://localhost:8086/healthConnect MCP clients:
Transport: SSE (Server-Sent Events)
URL:
http://localhost:8086/mcp
Option 3: From Source
git clone https://github.com/jhomen368/steam-reviews-mcp.git
cd steam-reviews-mcp
npm install
npm run build
node build/index.js💡 Usage Examples
Search for Games
// Single search
search_steam_games({
query: "Baldur's Gate 3",
limit: 10
})
// Batch search (up to 5 queries)
search_steam_games({
queries: ["Elden Ring", "Cyberpunk 2077", "Hades"],
limit: 5
})Search terms must not be blank. If a generated client sends queries: [] alongside a valid
query, the empty batch field is ignored.
Get Regional Game Info with Criteria
get_game_info({
appIds: [1086940, 1245620],
country: "de",
language: "german",
criteria: {
minReviewScore: 80,
minReviews: 1000,
requireMetacritic: true
},
includeRequirements: true,
includeDlc: true
})country accepts two-letter ISO 3166-1 store country codes and language accepts Steam's internal
language codes, such as english, german, and schinese. They default to us and english. ISO
language codes such as en, de, and zh are rejected before a Steam request.
Each game includes a storefront object identifying the requested country and language.
Its priceStatus distinguishes an available regional quote, a genuinely free game, an
unreleased game, and an unavailable quote. currency and priceFormatted preserve Steam's
current regional quote without conversion. Missing quote fields never imply that a game is free.
If Steam returns no usable app details, the AppID and storefront context remain in the result with
a steam_store warning instead of disappearing or being presented as a free game.
An unavailable quote does not infer whether the cause is delisting, package-only sale, regional
restriction, or another Store condition. Active criteria still exclude results that cannot satisfy
the requested filter.
Steam does not report which language it actually served and may silently fall back when a
translation is missing. For that reason, storefront.languageStatus is
requested_not_verified: it records the request context without claiming that returned text was
translated into the requested language.
purchaseNotices preserves Steam's raw third-party account and DRM or launcher notices. Each
notice has a supplied, not_supplied, or malformed status. not_supplied means only that Steam
omitted the notice; it does not prove that the game has no account requirement, launcher,
online-only behavior, activation limit, anti-cheat, or DRM. The server does not infer those claims
from notice text.
languageSupport contains structured language, full-audio, and subtitle declarations when Steam's
public Store service returns them. It also retains rawDeclaration from app details. If structured
retrieval fails, the status is partial_raw_only when that raw declaration exists, or unavailable
when it does not, and the game includes a steam_language_support warning.
storeCategories.items preserves Steam's category IDs and localized labels for declarations such
as controller support, co-op, multiplayer, achievements, and Steam Cloud. Unknown category IDs are
retained. These Store declarations are separate from tags and are not independently tested
behavior. When includeRequirements is true, Steam's localized minimum and recommended PC text is
returned without interpretation.
Omit criteria when no filtering is needed. Zero and false criteria values are inactive;
use requireFree: true to return only free games.
Each returned game includes Valve's Steam Deck compatibility evidence when available. Known
category values are verified, playable, unsupported, and unknown. The raw
categoryCode and Valve test-result token values are retained so new values are not discarded.
categoryCode: null means Valve has not published a result and is reported as unknown, not
unsupported. If Steam's Deck endpoint fails or returns malformed data, the game remains in the
result with a steam_deck_compatibility warning and no deckCompatibility claim.
Fetch Reviews with Filters
// Recent positive reviews
fetch_reviews({
appId: 1086940,
filter: "recent",
reviewType: "positive",
dayRange: 30
})
// Filter out review bombs
fetch_reviews({
appId: 1086940,
filterOfftopicActivity: true
})
// All-time reviews (`dayRange` may also be omitted)
fetch_reviews({
appId: 1086940,
dayRange: 0
})Analyze Sentiment
// General analysis
analyze_reviews({
appId: 1086940,
sampleSize: 100
})
// Topic-focused analysis
analyze_reviews({
appId: 1086940,
topic: "performance"
})Fetch Official App Announcements
// Latest announcements
const firstPage = await fetch_app_announcements({
appId: 1086940,
limit: 10
})
// Older announcements using the previous result's nextCursor
fetch_app_announcements({
appId: 1086940,
limit: 10,
cursor: firstPage.nextCursor
})Announcement bodies retain Steam's BBCode, HTML, and image placeholders. Check bodyStatus
before treating the text as full: it can be full_requested, possibly_truncated, or
malformed. full_requested means the client asked Steam not to shorten the body; it is not
independent proof that the source text is complete.
authorLabel is the label displayed by Steam and does not verify an employer or publisher role.
Natural Language Examples
Simply ask your AI assistant:
"Search for Elden Ring on Steam"
"Get info about Baldur's Gate 3 including system requirements"
"What are people saying about Cyberpunk 2077 recently?"
"Analyze negative reviews for No Man's Sky - what are the main complaints?"
"Find free games with at least 90% positive reviews"
"Show me the latest official updates for Baldur's Gate 3"
⚙️ Configuration
Environment Variables
All configuration is optional with sensible defaults:
# Cache settings
CACHE_ENABLED=true # Enable caching (default: true)
CACHE_MAX_SIZE=1000 # Max cache entries
# Rate limiting
RATE_LIMIT_ENABLED=true # Enable rate limiting (default: true)
MAX_REQUESTS_PER_MINUTE=30 # Max API calls per minute
# HTTP mode (for Docker)
HTTP_MODE=false # Enable HTTP transport
PORT=8086 # HTTP server port📚 Documentation
CHANGELOG.md - Version history and release notes
CONTRIBUTING.md - Contribution guidelines
Steam Store API - Steam API reference
🔧 Troubleshooting
Connection Issues
Verify Steam Store API is accessible (no firewall blocks)
Check rate limiting if receiving 429 errors
Review logs for timeout errors
Docker Issues
# Check logs
docker logs steam-reviews-mcp
# Verify health
curl http://localhost:8086/healthBuild Issues
# Ensure Node.js 18+
node --version
# Clean rebuild
rm -rf node_modules build
npm install
npm run build🤝 Contributing
Contributions welcome! Please see CONTRIBUTING.md for guidelines.
📄 License
MIT License - see LICENSE for details
🙏 Acknowledgments
Steam - Gaming platform and API
Model Context Protocol - Open protocol for AI integrations
Anthropic - Creators of the MCP standard
Support this project:
Available Tools
4 toolsanalyze_reviewsA
Fetch and analyze Steam game reviews to extract sentiment, common themes, and key insights. Supports optional topic drill-down, time-bounded analysis, and pre-fetched reviews.
ParametersJSON Schema
| Name | Required | Description | Default |
|---|---|---|---|
| appId | Yes | Steam AppID of the game to analyze | |
| sampleSize | No | Number of reviews to analyze (default: 100, max: 200) | |
| language | No | Filter reviews by language (e.g., "english", "schinese") | |
| reviewType | No | Filter by review sentiment (default: all) | |
| topic | No | Optional: Drill down into specific theme (e.g., "performance", "multiplayer") | |
| dayRange | No | Only analyze reviews from last N days (e.g., 30, 90, 365) | |
| filterOfftopicActivity | No | Filter out review bombing (default: false to show all reviews including controversies) | |
| steamDeckOnly | No | Only analyze Steam Deck reviews (experimental) | |
| preFetchedReviews | No | Optional: Pre-fetched reviews to analyze instead of fetching new ones. Useful to avoid duplicate API calls. If provided, sampleSize, language, reviewType, dayRange, and filtering parameters are ignored. |
TDQS
A3.7/5.0
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided, so description is the sole source. It mentions pre-fetched reviews avoid duplicate API calls, but does not disclose other behavioral traits like read-only nature, rate limits, or side effects.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Two clear sentences, front-loaded with main purpose. No redundant information.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
With 9 parameters and no output schema, the description covers high-level features but does not explain output format or 'key insights'. Adequate but not fully comprehensive.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100%, so baseline is 3. The description summarizes parameter categories (topic drill-down, time-bounded, pre-fetched) but adds no new meaning beyond the schema 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 the tool fetches and analyzes Steam game reviews, extracting sentiment, themes, and insights. It distinguishes from siblings like fetch_reviews by combining both actions.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description mentions optional features (topic drill-down, time-bounded analysis, pre-fetched reviews) but does not explicitly state when to use vs. alternatives. Context from siblings implies separation of concerns.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
fetch_reviewsB
Fetch actual user reviews for a Steam game with advanced filtering and pagination support. Returns review text, author info, timestamps, and voting data. Supports time-bounded queries and review bomb filtering.
ParametersJSON Schema
| Name | Required | Description | Default |
|---|---|---|---|
| appId | Yes | Steam AppID of the game | |
| filter | No | Review filter (default: all) | |
| language | No | Language code (e.g., "english", "schinese", Steam format) | |
| reviewType | No | Filter by review sentiment (default: all) | |
| purchaseType | No | Filter by purchase type (default: all) | |
| limit | No | Number of reviews to fetch (default: 20, max: 100) | |
| cursor | No | Pagination cursor from previous response | |
| dayRange | No | Only include reviews from last N days (e.g., 30, 90, 365) | |
| filterOfftopicActivity | No | Filter out review bombing and off-topic activity (default: false to show all reviews) | |
| steamDeckOnly | No | Only include Steam Deck reviews (experimental, may not work reliably) |
TDQS
B3.4/5.0
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided, so description carries full burden. It mentions returns review text, author info, timestamps, voting data, and supports time-bounded queries and review bomb filtering. However, it does not disclose side effects, auth requirements, rate limits, or data freshness. Minimal transparency beyond parameter descriptions.
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?
Two sentences covering main action and key features. No wasted words. Could be improved by front-loading essential info more clearly, but sufficiently concise for a tool with many parameters.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Description provides a high-level overview of what the tool does and its capabilities. However, it lacks details about output format, pagination mechanics, or error handling. Given the complexity (10 params, no output schema), more context would help an agent use it effectively.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so baseline is 3. Description adds high-level context ('advanced filtering and pagination support') but does not provide significant additional meaning beyond the detailed schema descriptions for each parameter.
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?
Description clearly states 'Fetch actual user reviews for a Steam game' with specific verb and resource. It distinguishes from sibling tools like analyze_reviews and get_game_info by mentioning advanced filtering and pagination.
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?
Description implies usage for fetching reviews with filters, but does not explicitly state when to use this tool vs siblings like analyze_reviews or search_steam_games. No when-not-to-use or alternative guidance provided.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_game_infoA
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.
ParametersJSON Schema
| Name | Required | Description | Default |
|---|---|---|---|
| appIds | Yes | Array of Steam AppIDs to fetch information for (supports batch queries) | |
| includeStats | No | Include review statistics (default: true) | |
| includeCurrentPlayers | No | Include current player count (default: false) | |
| criteria | No | Optional filter criteria - only games matching ALL criteria will be returned | |
| includeRequirements | No | Include system requirements (PC minimum/recommended specs) | |
| includeDlc | No | Include list of available DLC |
TDQS
A3.7/5.0
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.
search_steam_gamesA
Search for Steam games by name or keywords. Supports single or batch queries. Returns basic game information including AppID, name, price, and preview image.
ParametersJSON Schema
| Name | Required | Description | Default |
|---|---|---|---|
| query | No | Single search query (game name or keywords) | |
| queries | No | Multiple search queries for batch searching | |
| limit | No | Maximum number of results PER QUERY (default: 10, max: 25) |
TDQS
A3.5/5.0
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description provides some behavioral detail (batch support, returned fields) but lacks info on rate limits, concurrency, or behavior on no results. Adequate but not comprehensive.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Two concise sentences, front-loaded with core purpose. Every word contributes without redundancy.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
No output schema, so description should clarify return structure more. Mentions fields but not format or pagination. Adequate for a simple search tool but incomplete.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100%, so baseline is 3. The description adds some context ('per query' for limit) but mostly repeats schema descriptions. Minimal added value.
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?
Clearly states verb (search), resource (Steam games), method (by name or keywords), and returned information (AppID, name, price, preview image). Distinct from sibling tools like analyze_reviews or get_game_info.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
No explicit guidance on when to use this tool versus alternatives. While it mentions single or batch queries, there is no advice on when to choose batch over single or situations where this tool is inappropriate.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections. Dates show when Glama detected each change.
4 tool updates
v1.0.0- First observed
analyze_reviews - First observed
fetch_reviews - First observed
get_game_info - First observed
search_steam_games
TDQS
A3.7/5.0
Disambiguation5/5
Each tool has a clearly distinct purpose: analyze_reviews focuses on sentiment and theme analysis, fetch_reviews retrieves raw review data, get_game_info provides game metadata, and search_steam_games handles game discovery. There is no overlap in functionality that would cause confusion.
Naming Consistency4/5
The tools follow a consistent verb_noun pattern (analyze_reviews, fetch_reviews, get_game_info, search_steam_games), with all using snake_case. The minor deviation is 'get_game_info' using 'get' while others use more specific verbs like 'analyze' or 'fetch', but this is still readable and coherent.
Tool Count5/5
With 4 tools, the set is well-scoped for the server's purpose of accessing Steam reviews and game data. Each tool serves a distinct, essential function without bloat, covering analysis, data retrieval, game info, and search effectively.
Completeness4/5
The tool set covers core workflows for Steam reviews and game info, including analysis, fetching, metadata retrieval, and search. A minor gap is the lack of tools for user-specific operations (e.g., fetching user profiles or managing reviews), but the domain is well-covered for general use cases.
Maintenance
ActivityActive
ResponsivenessUnresponsive
Resources
Unclaimed servers have limited discoverability.
Looking for Admin?
If you are the server author, to access and configure the admin panel.
Related MCP Connectors
Steam Web API: profiles, owned games, achievements, app news, player counts.
Live Steam market data for AI agents: top sellers, deals, player counts. Paid per call via x402.
Ranks Steam games by how much players like them, learned from head-to-head duels.
Explore and discover video games from the Internet Game Database. Search titles, view detailed inf…
Related MCP Servers
- AlicenseNot gradedqualityBmaintenanceEnables exploring Steam store reviews and community discussion threads with server-side filtering, temporal analysis, and metadata context for understanding player sentiment and feedback beyond store page noise.291BSD 3-Clause
- AlicenseAqualityAmaintenanceEnables interaction with Steam: search games, get store details, reviews, prices, discounts, news, and player profiles, libraries, and achievements via the Steam Web API.252234MIT
- FlicenseNot gradedqualityCmaintenanceHelps users choose which Steam games to play or buy by analyzing their library, playtime, discounts, and reviews.-
Latest Blog Posts
- Who's Calling? MCP Hosts Are an Identity Blind Spot (And the Spec Knows It)By Om-Shree-0709 on .mcpAgent IdentityOAuth 2.1
- Your AI Chatbot Just Exposed Your CEO's Salary to an InternBy Om-Shree-0709 on .Agent IdentityMCP SecurityOAuth Delegation
- Why MCP Servers Need Execution Sandboxing (And Why Your Current Stack Isn't Enough)By Om-Shree-0709 on .Agentic AiPrompt InjectionWebAssembly
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