MCP server for the Stacklet environment providing access to AssetDB (cloud asset warehouse), Platform GraphQL API (governance operations), and documentation
The Stacklet MCP server demonstrates solid definition quality with comprehensive tool coverage, well-structured descriptions, and explicit schema definitions. Most tools follow verb-noun naming conventions and include parameter descriptions. However, there are systematic issues with schema completeness, parameter documentation gaps, and missing error handling guidance that prevent a higher score. All 16 tools are properly registered with names, descriptions, and input schemas visible in the source code. The server uses fastmcp framework which enforces structured tool registration.
Archive a saved query in AssetDB. Archives the query by setting its archived status to true. Archived queries are hidden from normal query listings but remain in the database. The query's associated visualizations and alerts are also removed during archiving. This operation cannot be undone through the API, but the query data is preserved in the database and could potentially be restored by database administrators.
Get complete details for a saved query including its SQL, parameters, and metadata. Use this when you need to examine a query's structure, understand its parameters, or check its settings before executing or modifying it. Returns the full query object with SQL text, parameter definitions, tags, creation info, and other metadata. Use assetdb_query_result() to actually execute the query and get data.
Browse and search through saved SQL queries in AssetDB. Use this to discover existing queries before creating new ones, or to find queries by name, content, or tags. Results are paginated for performance. Common use cases: - Find queries related to a specific topic: search="cost analysis" - Browse queries by category: tags=["production", "monitoring"] - List recently created queries: page=1, page_size=10 Next steps: Use assetdb_query_get() to get full details or assetdb_query_result() to execute.
Execute a saved query by ID and get results. Use this to run queries you've created or discovered. Supports parameter binding and result caching control.
STDIO-only transport limits remote accessibility and testing. The server uses STDIO transport exclusively, which cannot be used by hosted MCP clients or external integrations.
Missing error handling and recovery guidance in tool descriptions. Tools like assetdb_sql_query, platform_graphql_query, and platform_dataset_export do not document what happens on failure, what errors to expect, or how to recover. Per pattern:recovery-guide, errors should tell the LLM what to do next.
Insufficient parameter constraint documentation. Parameters like 'query' (in assetdb_sql_query) lack format guidance beyond the name. 'timeout' parameters lack explanation of what happens on timeout (retry? fail? partial results?). Per pattern:constrained-input, format constraints should be explicit in descriptions.
| Scored | Grade | Overall | Spec posture | Rubric |
|---|---|---|---|---|
| 2026-09-22 | C | 69 | 2026-07-28+ | v2 |
| 2026-03-09 | B | 70 | - | v1 |
Save a new query or update an existing one in AssetDB. Use this to preserve useful SQL queries for future use and sharing. New queries are created as drafts by default - set is_draft=False to publish them. Creating a new query (query_id=None): - Provide at minimum: name and query (SQL text) - Optionally add description, tags for organization Updating existing query (provide query_id): - Only specify fields you want to change - Leave others as None/unset to keep current values Tags help organize queries by team, purpose, or data domain. Use descriptive names like "cost-analysis", "security", "daily-reports".
Essential guide for working with AssetDB - read this before writing SQL queries. AssetDB is Stacklet's massive cloud asset warehouse containing billions of records across resources, costs, tags, and relationships. This guide explains the schema, performance best practices, and common query patterns. ⚠️ Critical: Many tables are extremely large and require careful indexing and filtering to avoid timeouts. This guide shows you how to query safely and efficiently.
Execute ad-hoc SQL queries against AssetDB without saving them. For one-time analysis or testing SQL before saving. Returns full result data and download links in multiple formats.
Browse the complete library of Stacklet documentation files. Returns all available documentation including user guides, API references, tutorials, and troubleshooting resources. Each file has a path and descriptive title. Start with "index_llms.md" - it's specifically designed as an LLM-friendly overview of all documentation and provides the best entry point for understanding Stacklet's features and capabilities. The glossary is also extremely valuable in understanding the most important concepts and their relationships. Use docs_read() with any of the returned file paths to get the actual content.
Read Stacklet documentation files for detailed guidance and reference information. Provides access to the complete Stacklet knowledge base including setup guides, feature explanations, API documentation, best practices, and troubleshooting help. Recommended reading order: 1. Start with "index_llms.md" for the big picture overview 2. Follow links to specific topics you need 3. Check troubleshooting guides for common issues All documentation is written in Markdown format and regularly updated to reflect the latest Stacklet features and best practices.
Export large governance datasets to CSV for analysis and reporting. Perfect for exporting thousands of resources, policies, executions, or other governance data when GraphQL pagination would be too slow. The server handles all paging and generates a downloadable CSV file. Process: 1. Define columns mapping GraphQL fields to CSV columns 2. Optionally add filters via params 3. Export runs asynchronously - use timeout=0 to return immediately 4. Use platform_dataset_lookup() to check progress and get download URL
Guide for exporting large datasets from Stacklet Platform - use for big data analysis. When you need to export thousands of governance records (policies, resources, executions, etc.), the dataset export tools provide server-side CSV generation that's much more efficient than paging through GraphQL connections. This guide explains how to structure export requests, handle large datasets, and work with the async export process. Essential for data analysis workflows.
Monitor dataset export progress and retrieve download links. Use this to check on exports started with platform_dataset_export(). Returns current status, progress info, and download URL when complete. Export states: - Processing: Export is running (shows progress if available) - Complete: Ready for download (includes download_url and expiry time) - Failed: Export encountered an error Set timeout > 0 to wait for completion, or timeout=0 for immediate status check. Download URLs are temporary and expire after a few hours.
Get detailed GraphQL type definitions to understand schema structure. Returns the full GraphQL Schema Definition Language (SDL) for specified types, showing all fields, arguments, relationships, and documentation. Essential for building correct queries. Use this after platform_graphql_list_types() to understand: - What fields are available on each type - Required vs optional arguments - Relationships between types - Input types for mutations The SDL output shows exactly how to structure your GraphQL queries.
Essential guide for Stacklet Platform GraphQL API - read this first before using other tools. The Platform API provides access to all Stacklet governance features: policies, account groups, bindings, resources, executions, and more. This guide explains the GraphQL schema patterns, connection-based pagination, filtering, and best practices for effective queries. ⚠️ Always check this guide first - it contains critical information about schema introspection, filtering syntax, and performance considerations for large-scale governance data.
Discover available GraphQL types in the Stacklet Platform API. Use this to explore the schema and find the right types for your queries. Essential for understanding what data is available and how types relate to each other. Without a filter, returns all available types. With a regex filter, narrows down to matching type names (e.g., "Account.*" finds AccountGroup, AccountList, etc.). Next step: Use platform_graphql_get_types() to see detailed definitions for interesting types.
Execute GraphQL queries against the Stacklet Platform for governance operations. This is your main tool for querying policies, account groups, bindings, resources, executions, and all other governance data. Supports both queries and mutations. ⚠️ Important guidelines: - Always query for "problems" field alongside your data - Use small page sizes (5-10) for exploration, larger for known datasets - Check types with platform_graphql_get_types() first - For large exports, use platform_dataset_export() instead
Limited guidance on tool selection between similar tools. assetdb_query_list, assetdb_query_get, and assetdb_query_result serve related purposes but descriptions don't clearly state when to use each vs the others. Per pattern:tool-chain, descriptions should guide sequencing.
Complex nested schema structures in platform_dataset_export (columns parameter contains inline objects) lack detailed validation rules. The 'columns' array with inline object properties should document required vs optional object properties, but the schema is minimally documented.
Destructive/write operations lack confirmation or dry-run patterns. assetdb_query_save (WRITE) and assetdb_query_archive (DESTRUCTIVE) do not offer confirmation steps or dry-run modes. Per pattern:confirmation-request, irreversible operations should support explicit confirmation.
Output schema documentation is incomplete for tools that return complex structures. While assetdb_sql_query and assetdb_query_result declare output_schema=ToolQueryResult.model_json_schema(), other tools' return types are inferred from code rather than explicitly documented. Per pattern:tool, all tools should document their output structure.