Control Plane OpenAPI MCP Server

Official

by Facets-cloud

Overview Schema Related Servers Score Discussions

Python

Remote

Server Quality Checklist

Profile completionA complete profile improves this server's visibility in search results.

Latest release: v0.1.0
Disambiguation5/5
Each tool has a clearly distinct purpose: getting the guide, refreshing the catalog, searching operations/schemas, loading specific operations/schemas, and calling the API. There is no overlap or ambiguity between them.
Naming Consistency2/5
Naming is inconsistent: 'FIRST_STEP_get_api_script_guide' uses an odd prefix, 'load_api_operation_by_operationId' mixes snake_case with camelCase, and verbs vary (get, refresh, search, load, call). No consistent pattern across the set.
Tool Count5/5
8 tools is well within the ideal range for an API discovery and invocation server. Each tool serves a necessary function without bloat or trivial additions.
Completeness4/5
The server covers the core workflow: loading the guide, refreshing the catalog, searching and loading operations/schemas, and making GET requests. However, it only supports GET calls and lacks a tool to list all operations/schemas in bulk, which are minor gaps.
Average 4.4/5 across 8 of 8 tools scored.
See the Tool Scores section below for per-tool breakdowns.
- 1 of 2 community issues answered or closed in the last 6 months
- 2 commits in the last 12 weeks
- Last stable release on August 6, 2026
- No critical vulnerability alerts
- No high-severity vulnerability alerts
- No code scanning findings
- CI is passing
This repository is licensed under MIT License.
This repository includes a README.md file.
No tool usage detected in the last 30 days. Usage tracking helps demonstrate server value.
Tip: use the "Try in Browser" feature on the server page to seed initial usage.
Add a glama.json file to provide metadata about your server.
If you are the author, simply .
If the server belongs to an organization, first add glama.json to the root of your repository:
```
{
  "$schema": "https://glama.ai/mcp/schemas/server.json",
  "maintainers": [
    "your-github-username"
  ]
}
```
Then . Browse examples.
Add related servers to improve discoverability.

How to sync the server with GitHub?

Servers are automatically synced at least once per day, but you can also sync manually at any time to instantly update the server profile.

To manually sync the server, click the "Sync Server" button in the MCP server admin interface.

How is the quality score calculated?

The overall quality score combines two components: Tool Definition Quality (70%) and Server Coherence (30%).

Tool Definition Quality measures how well each tool describes itself to AI agents. Every tool is scored 1–5 across six dimensions: Purpose Clarity (25%), Usage Guidelines (20%), Behavioral Transparency (20%), Parameter Semantics (15%), Conciseness & Structure (10%), and Contextual Completeness (10%). The server-level definition quality score is calculated as 60% mean TDQS + 40% minimum TDQS, so a single poorly described tool pulls the score down.

Server Coherence evaluates how well the tools work together as a set, scoring four dimensions equally: Disambiguation (can agents tell tools apart?), Naming Consistency, Tool Count Appropriateness, and Completeness (are there gaps in the tool surface?).

Tiers are derived from the overall score: A (≥3.5), B (≥3.0), C (≥2.0), D (≥1.0), F (<1.0). B and above is considered passing.

Tool Scores

Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the burden of transparency. It discloses the return behavior (JSON string or null if not found) and the prerequisite. However, it does not explicitly state whether the operation is read-only or describe any side effects, which is a notable gap for a tool with no annotations.
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 well-structured with an important note, an Args section, and a Returns section. The important note is essential but styled with an HTML-like tag that adds visual noise. Overall, every sentence earns its place and the content is appropriately sized.
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?
For a simple tool with one parameter and no annotations, the description is fairly complete. It explains the prerequisite, parameter semantics, and return format. The output schema exists, so detailed return values are not required, but the description still summarizes the return behavior adequately.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters5/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The parameter schema has no description coverage (0%), but the description fully compensates by explaining schema_name as 'The name of the schema to load (e.g., 'Stack', 'ErrorDetails')'. This provides type, meaning, and concrete examples, adding clear value beyond the bare schema.
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 'Load a specific schema by its name,' with a specific verb and resource. It distinguishes itself from sibling tools like load_api_operation_by_operationId, as it targets schemas rather than operations. The tool name and description align well.
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?
Provides an explicit prerequisite: 'Make Sure you have Called FIRST_STEP_get_api_script_guide first before this tool.' This gives clear context for when to use the tool. However, it does not explicitly mention alternatives or when not to use it, so it lacks exclusionary guidance.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden. It discloses the refresh action, the fetching of the latest OpenAPI specification, and the return of a success message. However, it omits potential side effects like overwriting existing catalog data and failure modes if the prerequisite is not met, leaving some behavioral gaps.
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?
The description is concise and front-loaded with an important prerequisite instruction. Every sentence contributes meaning, and the structure is clear and efficient.
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?
For a zero-parameter tool, the description covers the action, return value, and a key prerequisite, which is largely complete. It could improve by mentioning error cases or side effects, but given the simplicity of the tool, it is sufficiently contextualized.
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?
The tool has zero parameters, so the description does not need to explain parameter semantics. The baseline for zero-param tools is 4, and no additional parameter information is required.
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 refreshes the API catalog by fetching the latest OpenAPI specification. This is a specific verb+resource and distinguishes it from sibling tools that search or load API operations/schemas.
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 explicitly instructs that FIRST_STEP_get_api_script_guide must be called first, establishing a clear prerequisite context. However, it does not mention when not to use this tool or provide alternative options, which prevents a 5.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden. It discloses the return behavior ('JSON string containing the complete operation details or null if not found') and the prerequisite dependency. However, it does not explicitly state that the operation is read-only, nor does it cover edge behaviors like authentication or error states. This is adequate but minimal for a non-annotated tool.
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?
The description is succinct, with a highlighted <important> precondition, then a one-sentence purpose, and clearly separated Args and Returns sections. No extraneous content.
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?
The tool is simple (2 params, no nested objects), and the description covers purpose, parameters, return type, and the prerequisite call. The output schema is present so return values need not be over-explained. Lacks explicit comparison to sibling load_api_operation_by_operationId, but overall it is sufficient for an agent to invoke it correctly.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters5/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema provides only type strings with no descriptions (0% coverage). The description compensates by giving a concrete path example and an explicit list of HTTP methods, adding practical meaning to both parameters.
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 states 'Load a specific operation by its path and HTTP method' with a concrete example path. The name and description clearly distinguish it from the sibling load_api_operation_by_operationId which loads by operationId.
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 includes an explicit prerequisite: 'Make sure you have Called FIRST_STEP_get_api_script_guide first before this tool.' This gives clear context for when the tool can be used. It does not explicitly mention when to use this tool vs alternatives, but the method of selection is self-evident from the name and sibling context.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
There are no annotations, so the description carries the full disclosure burden. It discloses the fuzzy matching behavior and the return format as a JSON string. However, it does not explicitly state read-only status, permissions, or failure behavior if the prerequisite is not met, leaving some gaps.
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?
The description is concise and well-structured: it opens with an important prerequisite, then a one-sentence purpose, followed by Args and Returns sections. No redundancy or unnecessary details are present.
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?
For a simple tool with one parameter and an output schema, the description covers the key aspects: purpose, prerequisite, parameter semantics, and return type. However, it lacks explicit information about the tool's non-mutating nature or limitations, so it is not fully complete.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters5/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has no description for the 'query' parameter, but the description compensates fully by stating: 'query (str): Search query to match against schema names and descriptions.' This clearly explains the parameter's meaning and target.
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's function: 'Search for schemas across the OpenAPI specification using fuzzy matching.' This uses a specific verb (search) and resource (schemas), and the presence of the sibling tool search_api_operations indicates differentiation by resource type.
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 includes a clear prerequisite, 'Make Sure you have Called FIRST_STEP_get_api_script_guide first before this tool,' which provides context for when to use it. However, it does not explicitly mention alternatives or exclusions, such as noting that search_api_operations should be used for operations.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description discloses the HTTP method (GET), return format (JSON string), and error handling (returns error information). The <important> prerequisite also adds context about required prior steps. It does not mention auth or rate limits, but the prerequisite likely covers that.
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?
The description is compact and front-loaded, with an <important> block immediately stating the prerequisite, followed by a one-sentence description and a simple Args/Returns structure. Every sentence earns its place with no fluff.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a tool with one parameter and simple GET behavior, the description covers purpose, parameter usage, return value, and the required prerequisite. The presence of an output schema further reduces the need to explain return structure, though the description already says it returns a JSON string.
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?
The description explains the 'path' parameter with examples ('/cc-ui/v1/stacks/my-stack' or 'cc-ui/v1/stacks'), adding format and context beyond the schema's bare string type. Since schema description coverage is 0%, this fully compensates for the missing parameter documentation.
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 it makes a GET request to the Facets Control Plane API, specifying the verb (GET) and resource (Control Plane API). It also includes a prerequisite hint, distinguishing it from sibling catalog/search tools.
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 gives a clear prerequisite: 'Make sure you have Called FIRST_STEP_get_api_script_guide first before this tool.' This implies when to use the tool (after obtaining the guide) and differentiates it from catalog/search tools, though it does not explicitly mention alternatives or exclusions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Given no annotations exist, the description carries the behavioral transparency burden. It discloses the return type as 'JSON string containing the complete operation details or null if not found,' which informs the agent about output and failure behavior. The mandatory prerequisite step is also a behavioral trait. However, it does not explicitly state that the operation is read-only or free of side effects, though 'load' implies this.
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?
The description is well-structured: a bolded prerequisite, a one-line purpose, and concise Args/Returns documentation. Every sentence contributes necessary information without redundancy. The format is easy to parse and front-loads the critical prerequisite.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple one-parameter load tool, the description covers all necessary context: prerequisite, function, parameter semantics, return format, and null case. The existence of an output schema means the return structure need not be explained further. The description is complete given the tool's simplicity and available metadata.
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?
The input schema only specifies `operation_id` with type and title, lacking any description (0% coverage). The description compensates by providing an Args block explaining 'The unique operation ID to load.' This adds essential meaning beyond the schema, clarifying the nature and purpose of the 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?
The description clearly states the tool's function: 'Load a specific operation by its operationId.' It uses a specific verb 'Load' and identifies the resource (operation) and the key identifier (operationId). This distinguishes it from sibling 'load_api_operation_by_path_and_method', which uses a different identification scheme.
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 gives explicit usage guidance by mandating 'Make Sure you have Called FIRST_STEP_get_api_script_guide first before this tool.' This establishes a clear precondition and ordering. It does not explicitly mention alternatives or exclusions, but the prerequisite and phrasing imply it is used when an operationId is known and one needs the full operation details.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden. It discloses the fuzzy matching behavior, the restriction to active operations, and the return format (JSON string). It does not mention error handling or no-result behavior, but covers the core behavioral traits for a search tool.
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?
The description is concise and well-structured: a prominent prerequisite warning, a clear purpose sentence, a note about active operations, and an Args/Returns section. Every sentence earns its place with no redundancy.
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?
Given the tool's simplicity (one parameter) and the presence of an output schema, the description provides sufficient context: prerequisite, search scope, active-operation filter, and return format. It could mention how to interpret the returned JSON, but that is likely covered by the output schema.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters5/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema only lists 'query' with no description (0% coverage). The description compensates fully by explaining that the query matches operation summaries, descriptions, tags, and operation IDs, adding meaningful semantic context beyond the schema itself.
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 'Search for operations across the OpenAPI specification using fuzzy matching,' combining a specific verb (search), resource (operations), and scope. It distinguishes from sibling tools like search_api_schemas and load_api_operation_by_operationId by focusing on cross-specification search rather than schema lookup or direct loading.
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 explicitly requires calling FIRST_STEP_get_api_script_guide first, giving a clear usage prerequisite. It also notes the restriction to active (non-deprecated) operations, which sets an important boundary. However, it does not explicitly compare against alternative search/load tools, so it falls short of full when/when-not guidance.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the burden of explaining behavior. It states that the tool returns 'a JSON string containing the content of the API script guide,' which is the core expected behavior. It does not explicitly discuss side effects, but for a guide-loading tool, none are expected. This is more informative than a bare 'get guide' description.
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?
The description is highly concise and effectively front-loaded. It begins with a vital directive in a highlighted <important> tag, then gives a one-sentence purpose, and finishes with a clear return type. Every sentence earns its place.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's simplicity (no parameters, returns a string), the description is fully complete. It specifies the return format and the mandatory first-call position in the workflow. The sibling tools are all different, and no additional context is needed.
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?
The tool has zero parameters, so the baseline is 4. The input schema is empty and thus requires no additional explanation. The description appropriately focuses on the return value rather than parameters.
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 'Loads the API script generation guide' and explains what the guide contains (comprehensive instructions for creating scripts that interact with Control Plane APIs). The verb 'loads' and specific resource make it distinct from sibling tools that search or call APIs.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines5/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
Explicitly instructs the agent to 'ALWAYS Call this tool first before calling any other tool of this mcp.' This strong, unambiguous usage guidance leaves no doubt about when and how to use the tool in the workflow.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

GitHub Badge

Glama performs regular codebase and documentation scans to:

Confirm that the MCP server is working as expected.
Confirm that there are no obvious security issues.
Evaluate tool definition quality.

Our badge communicates server capabilities, safety, and installation instructions.

Card Badge

Copy to your README.md:

[![control-plane-openapi-mcp MCP server](https://glama.ai/mcp/servers/Facets-cloud/control-plane-openapi-mcp/badges/card.svg)](https://glama.ai/mcp/servers/Facets-cloud/control-plane-openapi-mcp)

Score Badge

Copy to your README.md:

[![control-plane-openapi-mcp MCP server](https://glama.ai/mcp/servers/Facets-cloud/control-plane-openapi-mcp/badges/score.svg)](https://glama.ai/mcp/servers/Facets-cloud/control-plane-openapi-mcp)

Latest Blog Posts

Who's Calling? MCP Hosts Are an Identity Blind Spot (And the Spec Knows It)
By Om-Shree-0709 on July 25, 2026.
mcp
Agent Identity
OAuth 2.1
Your AI Chatbot Just Exposed Your CEO's Salary to an Intern
By Om-Shree-0709 on July 2, 2026.
Agent Identity
MCP Security
OAuth Delegation
Why MCP Servers Need Execution Sandboxing (And Why Your Current Stack Isn't Enough)
By Om-Shree-0709 on June 30, 2026.
Agentic Ai
Prompt Injection
WebAssembly

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/Facets-cloud/control-plane-openapi-mcp'

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