Redis Cloud API MCP Server

Official

by redis

Overview Schema Related Servers Score Discussions(1)

TypeScript

Remote

Server Quality Checklist

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

Latest release: v1.0.0
Disambiguation4/5
Most tools have distinct purposes targeting specific resources (subscriptions, databases, tasks, etc.), but there's some potential confusion between get-essential-subscription-by-id and get-essential-subscriptions, and between get-pro-subscription and get-pro-subscriptions, as the singular/plural versions could be misselected for the wrong granularity. Overall, the resource-action combinations are mostly clear.
Naming Consistency5/5
Tool names follow a highly consistent verb-noun pattern with hyphens (e.g., create-essential-subscription, get-pro-databases). All tools use lowercase with hyphens, and verbs like 'create', 'get', and 'delete' are applied consistently across resources, making the naming predictable and readable.
Tool Count4/5
With 16 tools, the count is slightly high but reasonable for managing Redis Cloud subscriptions, databases, and related tasks. It covers essential and pro tiers comprehensively, though it might feel a bit heavy for a single domain. The tools are well-scoped without obvious bloat.
Completeness4/5
The toolset provides good coverage for managing Redis Cloud resources, including CRUD operations for subscriptions and databases, plus supporting tools for tasks, payment methods, and plans. Minor gaps exist, such as no update or delete tools for pro databases or payment methods, but agents can likely work around these with the available creation and retrieval tools.
Average 3.3/5 across 16 of 16 tools scored.
See the Tool Scores section below for per-tool breakdowns.
- 0 of 5 community issues answered or closed in the last 6 months
- 0 commits in the last 12 weeks
- No stable releases found
- No critical vulnerability alerts
- No high-severity vulnerability alerts
- No code scanning findings
- CI status not available
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

Behavior2/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 of behavioral disclosure. While 'Delete' implies a destructive mutation, the description doesn't specify whether this action is reversible, what permissions are required, what happens to associated data, or any rate limits. For a destructive tool with zero annotation coverage, this is a significant gap in safety and operational context.
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 a single, efficient sentence with zero waste. It's appropriately sized for a simple tool and front-loads the core action and resource without unnecessary elaboration.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's destructive nature, lack of annotations, and absence of an output schema, the description is incomplete. It doesn't address critical context such as the irreversible nature of deletion, error conditions, or what happens post-deletion (e.g., confirmation message or status). For a mutation tool with no structured safety hints, this leaves significant gaps for an AI agent.
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?
The schema description coverage is 100%, with the single parameter 'subscriptionId' fully documented in the schema. The description adds no additional meaning beyond what's in the schema (e.g., it doesn't clarify format, source, or validation rules). With high schema coverage, the baseline score of 3 is appropriate as the description doesn't compensate but also doesn't detract.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action ('Delete') and target resource ('an essential subscription by ID'), providing a specific verb+resource combination. However, it doesn't differentiate this tool from potential sibling deletion tools (none exist in the provided list, but the description doesn't explicitly state this uniqueness).
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?
The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., needing the subscription ID from a get operation), consequences of deletion, or when not to use it (e.g., for pro subscriptions). With siblings like 'get-essential-subscription-by-id' and 'get-essential-subscriptions', the description should ideally reference these for obtaining the required ID.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries full burden. It states a read operation ('Get'), implying it's non-destructive, but doesn't disclose behavioral traits like pagination (implied by limit/offset), authentication needs, rate limits, or return format. For a tool with 3 parameters and no annotations, this leaves significant gaps in understanding how it behaves.
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 a single, efficient sentence with zero waste. It's front-loaded with the core purpose and appropriately sized for the tool's complexity. Every word earns its place without redundancy.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given no annotations, no output schema, and 3 parameters, the description is incomplete. It lacks details on return values, error conditions, or behavioral context. For a tool that likely returns a list of databases, more information on output structure or usage constraints would be needed for adequate completeness.
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 parameters are fully documented in the schema. The description adds minimal value beyond the schema by mentioning 'subscriptionId' but doesn't explain semantics like what a 'pro database' entails or how limit/offset interact. Baseline 3 is appropriate as the schema does the heavy lifting.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action ('Get') and resource ('pro databases'), specifying it's for a 'provided subscription Id'. It distinguishes from siblings like 'get-pro-subscriptions' (which lists subscriptions) and 'get-pro-subscription' (which gets a single subscription), but doesn't explicitly contrast them. The purpose is specific but could be more differentiated.
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 guidance on when to use this tool versus alternatives like 'get-pro-subscriptions' or 'get-pro-subscription'. The description implies it's for fetching databases under a subscription, but doesn't specify prerequisites, exclusions, or contextual triggers. Usage is inferred rather than explicitly stated.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/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 of behavioral disclosure. It states this is a 'Get' operation, implying read-only behavior, but doesn't clarify authentication requirements, error handling, rate limits, or what happens if the subscription ID doesn't exist. The description adds minimal behavioral context beyond the basic operation.
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 brief (two sentences) and front-loaded with the core purpose. The second sentence about payload matching the schema is somewhat redundant given the schema documentation, but doesn't significantly detract from conciseness.
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?
For a simple read operation with one parameter and no output schema, the description provides basic purpose but lacks important context. Without annotations or output schema, it should ideally clarify what information is returned about the subscription, error conditions, or how this differs from similar tools.
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%, with the single parameter 'subscriptionId' clearly documented in the schema. The description adds no additional parameter information beyond what's already in the structured schema, so it meets the baseline expectation without adding extra value.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action ('Get') and resource ('pro subscription by ID'), making the purpose understandable. However, it doesn't differentiate this tool from its sibling 'get-pro-subscriptions' (plural), which appears to retrieve multiple subscriptions rather than a single one by ID.
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?
The description provides no guidance on when to use this tool versus alternatives like 'get-pro-subscriptions' or 'get-essential-subscription-by-id'. It mentions that 'The payload must match the input schema', but this is a generic requirement rather than specific usage context.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure. It states the tool retrieves payment methods but doesn't mention whether this requires specific permissions, what format the data is returned in, or any rate limits. The description is minimal and lacks details on behavioral traits beyond the basic action.
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 a single, clear sentence that directly states the tool's purpose without any unnecessary words. It is front-loaded with the key information and efficiently communicates the essential action and resource. There is zero waste in the phrasing.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the lack of annotations and output schema, the description is incomplete. It doesn't explain what the return values look like (e.g., list of payment methods, JSON structure) or any error conditions. For a tool that retrieves financial data, more context on behavior and output is needed to be fully helpful to an AI agent.
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 0 parameters, and the schema description coverage is 100%, so there are no parameters to document. The description appropriately doesn't discuss parameters, which is correct for a parameterless tool. This meets the baseline expectation for tools with no parameters.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action ('Get') and resource ('current payment methods for the current Cloud Redis account'), making the purpose immediately understandable. It doesn't explicitly distinguish from sibling tools like 'get-current-account', but the resource specificity provides adequate differentiation. The description avoids tautology by not just restating the tool name.
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?
The description provides no guidance on when to use this tool versus alternatives like 'get-current-account' or other sibling tools. It doesn't mention prerequisites, such as requiring an active account or authentication. The context is implied (retrieving payment methods), but no explicit usage scenarios or exclusions are provided.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries full burden for behavioral disclosure. It states this is a 'Get' operation, implying read-only behavior, but doesn't clarify authentication needs, error conditions, rate limits, or what happens if the subscription ID doesn't exist. For a tool with zero annotation coverage, this leaves significant gaps in understanding its behavior.
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 a single, efficient sentence that communicates the core purpose without unnecessary words. It's appropriately sized for a simple retrieval tool and front-loads the essential 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?
For a simple retrieval tool with one parameter and no output schema, the description covers the basic purpose adequately. However, without annotations and with sibling tools that perform similar operations, it lacks sufficient context about when to choose this tool and what behavioral characteristics to expect.
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?
The input schema has 100% description coverage, with the subscriptionId parameter clearly documented. The description adds no additional parameter information beyond what's in the schema. According to scoring rules, when schema_description_coverage is high (>80%), the baseline is 3 even with no param info in the description.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb 'Get' and the resource 'essential subscription by ID', specifying it's for the current Cloud Redis account. It distinguishes from sibling tools like get-essential-subscriptions (plural) by focusing on a single ID, but doesn't explicitly contrast with get-pro-subscription or other similar tools.
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?
The description provides no guidance on when to use this tool versus alternatives like get-essential-subscriptions (for listing) or get-pro-subscription (for pro tier). It mentions 'for the current Cloud Redis account' which gives some context but doesn't specify prerequisites, exclusions, or comparative use cases.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/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 of behavioral disclosure. It states it's a lookup (read-only) operation, implying safety, but doesn't cover aspects like rate limits, authentication needs, error handling, or response format. For a tool with zero annotation coverage, this is a significant gap in transparency.
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 with two sentences that directly convey the tool's function and data scope. It's front-loaded with the core purpose, and the second sentence adds useful clarification without waste. A minor deduction to 4 as it could be slightly more structured (e.g., explicitly stating it's a read-only list).
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?
Given the tool's low complexity (0 parameters, no output schema), the description is minimally adequate. It explains what the tool does but lacks details on behavioral traits (e.g., response format, errors) and usage context. Without annotations or output schema, it should do more to compensate, but it meets the basic threshold for a simple lookup 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?
The tool has 0 parameters, and schema description coverage is 100%, so there's no need for parameter details in the description. The baseline for 0 parameters is 4, as the description appropriately avoids redundant information and focuses on the tool's purpose.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose: 'Lookup list of regions for cloud provider.' It specifies the verb ('Lookup') and resource ('regions for cloud provider'), and adds that 'These regions include the providers too,' which clarifies the data scope. However, it doesn't explicitly differentiate from siblings like 'get-essentials-plans' or 'get-pro-databases,' which limits it to a 4.
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?
The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites, context (e.g., before creating subscriptions), or exclusions. With siblings like 'get-essentials-plans' and 'get-pro-databases,' the lack of differentiation leaves the agent without clear usage cues.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure. It states the tool retrieves data but does not mention whether it requires authentication, has rate limits, returns paginated results, or details error conditions. This leaves significant gaps for a tool that likely interacts with account data.
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 a single, direct sentence with no wasted words, clearly stating the tool's purpose. It is appropriately sized and front-loaded, making it easy to understand quickly.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the lack of annotations and output schema, the description is incomplete. It does not explain what the tool returns (e.g., list of subscriptions, details like status or plans), error handling, or authentication requirements, which are critical for a tool accessing account data.
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 0 parameters, and the schema description coverage is 100%, so no parameter documentation is needed. The description appropriately does not discuss parameters, aligning with the schema's completeness, though it could note the absence of inputs for clarity.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action ('Get') and resource ('pro subscriptions for the current Cloud Redis account'), making the purpose understandable. However, it does not explicitly differentiate from sibling tools like 'get-pro-subscription' (singular) or 'get-essential-subscriptions', leaving some ambiguity about scope.
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?
The description provides no guidance on when to use this tool versus alternatives such as 'get-pro-subscription' (singular) or 'get-essential-subscriptions'. It lacks context about prerequisites, timing, or exclusions, offering minimal usage direction.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure. It states it's a read operation ('Get'), but doesn't mention authentication requirements, rate limits, error handling, or what happens if the task ID is invalid. This leaves significant gaps for a tool that likely interacts with account-specific data.
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 a single, clear sentence with no wasted words. It's front-loaded with the core purpose and efficiently conveys the essential information without unnecessary elaboration.
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?
For a simple read tool with one parameter and no output schema, the description is minimally adequate but lacks depth. It doesn't explain return values, error cases, or account context implications, which could be important given the 'current Cloud Redis account' scope. With no annotations, more behavioral detail would improve completeness.
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?
The input schema has 100% description coverage, with 'taskId' documented as 'Task ID'. The description doesn't add any meaning beyond this, such as format examples or constraints. Baseline 3 is appropriate since the schema does the heavy lifting.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action ('Get') and resource ('a task by ID for the current Cloud Redis account'), making the purpose understandable. However, it doesn't explicitly differentiate from sibling 'get-tasks' (which likely lists multiple tasks), so it's not fully distinguished from alternatives.
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 guidance is provided on when to use this tool versus alternatives like 'get-tasks' or other sibling tools. The description implies usage for retrieving a specific task by ID but doesn't specify prerequisites, exclusions, or contextual recommendations.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure. It states a read operation ('Get') but doesn't mention authentication requirements, rate limits, error conditions, or what 'current' implies (e.g., logged-in user's account). This leaves significant gaps in understanding the tool's behavior.
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 a single, clear sentence with no wasted words. It's front-loaded with the core action and resource, making it efficient and easy to parse. Every word earns its place, achieving optimal conciseness.
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?
Given the tool's simplicity (0 params, no output schema) and lack of annotations, the description is minimally adequate. It states what the tool does but misses context like authentication needs or return format. For a basic read tool, it's passable but could be more informative to compensate for the missing structured data.
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 has 0 parameters with 100% coverage, so no parameter documentation is needed. The description doesn't add param info, which is fine, but it could have clarified that no inputs are required. Baseline is 4 for zero-param tools, as the schema fully covers the absence of parameters.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action ('Get') and resource ('current Cloud Redis account'), making the purpose understandable. However, it doesn't differentiate from siblings like 'get-current-payment-methods' or 'get-pro-subscription' beyond specifying the account type, which is adequate but not fully distinguishing.
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?
The description provides no guidance on when to use this tool versus alternatives like 'get-essential-subscriptions' or 'get-pro-subscriptions'. It lacks context about prerequisites, such as authentication needs or whether it's for account info vs. subscription details, leaving usage unclear.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/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 mentions that support varies by subscription and settings, which adds some behavioral context about dependencies. However, it lacks details on permissions, rate limits, response format, or error handling, leaving significant gaps for a tool that likely returns account-specific data.
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 a single, well-structured sentence that efficiently conveys the tool's purpose and key context (subscription/settings dependencies). It avoids redundancy and front-loads essential information, making it highly concise and effective.
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?
Given the tool's simplicity (0 parameters, no output schema, no annotations), the description is adequate but has gaps. It explains what the tool does and its dependencies, but without annotations or output schema, it should ideally provide more behavioral details (e.g., response format, error cases) to fully guide an agent.
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 0 parameters with 100% schema description coverage, so no parameter documentation is needed. The description appropriately focuses on the tool's purpose without redundant parameter details, earning a baseline score of 4 for not introducing unnecessary complexity.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose with a specific verb ('Lookup list') and resource ('database modules'), and clarifies that these are also called 'capabilities'. It distinguishes the scope as 'supported in current account' with subscription/settings dependencies, though it doesn't explicitly differentiate from sibling tools like 'get-pro-databases' or 'get-essentials-plans'.
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?
The description provides no guidance on when to use this tool versus alternatives. It mentions that support depends on subscription and database settings, which is contextual but doesn't specify use cases, prerequisites, or exclusions compared to sibling tools like 'get-pro-databases' or 'get-essential-subscriptions'.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries full burden for behavioral disclosure. It states this is a read operation ('Get') but doesn't mention authentication requirements, rate limits, pagination behavior, error conditions, or what 'current tasks' actually means (running tasks, recent tasks, all active tasks?). For a tool with zero annotation coverage, this leaves significant 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 a single, clear sentence with zero wasted words. It's front-loaded with the core purpose and includes necessary scope information. Every word earns its place, making it highly efficient for an agent to parse.
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?
For a zero-parameter read tool with no output schema, the description covers the basic purpose adequately. However, it doesn't explain what format the tasks will be returned in, what fields they contain, or how 'current' is defined. Given the lack of annotations and output schema, more detail about the return value would be helpful for agent understanding.
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, and schema description coverage is 100% (though trivial since there are no parameters). The description appropriately doesn't discuss parameters since none exist. It could theoretically mention that no filtering options are available, but the absence of parameters in the schema makes this adequate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action ('Get') and target resource ('current tasks'), and specifies the scope ('for the current Cloud Redis account'). It doesn't explicitly differentiate from sibling tools like 'get-task-by-id', but the scope clarification provides some distinction. The purpose is specific enough for an agent to understand what this tool does.
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?
The description provides no guidance on when to use this tool versus alternatives like 'get-task-by-id' or 'get-essential-subscriptions'. It doesn't mention prerequisites, timing considerations, or any context for selecting this tool over similar siblings. The agent would need to infer usage patterns from tool names alone.
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 provided, the description carries the full burden of behavioral disclosure. It usefully adds that the operation returns a TASK ID for tracking status, which is crucial context not inferable from the input schema. However, it doesn't disclose other important traits like whether this is a mutating operation (implied by 'Create'), potential side effects, authentication needs, rate limits, or error conditions, leaving significant 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 extremely concise—two sentences that directly state the tool's purpose and key behavioral detail (TASK ID return). It's front-loaded with the core action and wastes no words, making it efficient for an agent to parse quickly.
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?
Given the tool's complexity (a mutating operation with 4 parameters, no annotations, and no output schema), the description is incomplete. It covers the basic purpose and return mechanism but lacks context on usage guidelines, behavioral risks, or integration with sibling tools (e.g., 'get-task-by-id' for tracking). However, the high schema coverage and conciseness partially compensate, making it minimally adequate but with clear gaps.
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 the schema already documents all parameters thoroughly (e.g., 'planId' description references '/fixed/plans'). The description adds no additional parameter semantics beyond what's in the schema, such as explaining relationships between parameters (e.g., how 'paymentMethod' and 'paymentMethodId' interact) or usage examples. Baseline 3 is appropriate when schema does the heavy lifting.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action ('Create a new essential subscription') and resource ('essential subscription'), which is specific and unambiguous. However, it doesn't explicitly distinguish this from sibling tools like 'create-pro-subscription' or 'create-pro-database', which would require mentioning what makes an 'essential' subscription different from 'pro' alternatives.
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?
The description provides no guidance on when to use this tool versus alternatives like 'create-pro-subscription' or other sibling tools. It also doesn't mention prerequisites, such as needing plan IDs from 'get-essentials-plans' or payment methods from 'get-current-payment-methods', leaving the agent to infer context from parameter descriptions alone.
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 provided, the description carries the full burden of behavioral disclosure. It adds value by describing the paginated response behavior and how to retrieve all plans using 'page' and 'size' parameters. However, it doesn't cover other potential behavioral traits like error handling, rate limits, or authentication needs, which are gaps for a tool with no annotation coverage.
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 appropriately sized with two sentences that are front-loaded with the core purpose. The first sentence states what the tool does, and the second explains pagination behavior, with no wasted words. However, it could be slightly more structured by separating usage instructions from behavioral details for better clarity.
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?
Given the tool's moderate complexity (4 parameters, pagination) and no annotations or output schema, the description is somewhat complete but has gaps. It covers the purpose and pagination behavior but lacks details on return values, error cases, or how it differs from sibling tools, making it adequate but not fully comprehensive for an agent to use confidently without additional context.
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 the schema already documents all parameters ('page', 'provider', 'redisFlex', 'size') with descriptions and defaults. The description adds minimal semantic value beyond the schema, only emphasizing the 'provider' parameter requirement and hinting at pagination usage, which aligns with the baseline score of 3 when schema coverage is high.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb ('Get') and resource ('available plans for essential subscriptions'), making the purpose understandable. However, it doesn't explicitly differentiate from sibling tools like 'get-pro-plans-regions' or 'get-essential-subscription-by-id', which might cause confusion about when to use this specific tool versus alternatives.
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 provides some guidance by stating 'Always ask for which provider the plans are want to be retrieved,' which implies the required 'provider' parameter. However, it lacks explicit when-to-use versus when-not-to-use instructions or comparisons with sibling tools like 'get-pro-plans-regions' for pro plans, leaving usage context somewhat implied rather than clearly defined.
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 of behavioral disclosure. It effectively describes key traits: it's a read operation (implied by 'Get'), returns paginated responses, and requires iterative use of parameters to retrieve all data. However, it lacks details on authentication needs, rate limits, or error handling, which would be beneficial 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 appropriately sized with two sentences that are front-loaded with the core purpose. The second sentence adds necessary behavioral detail about pagination, but it could be slightly more concise by combining ideas without losing clarity.
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?
Given the tool's moderate complexity (paginated list retrieval), no annotations, and no output schema, the description is somewhat complete but has gaps. It covers the purpose and pagination behavior but lacks details on response format, error cases, or how to handle the iterative process effectively, which would help an agent use it correctly.
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 the schema already documents both parameters ('page' and 'size') with descriptions and defaults. The description adds value by explaining that these parameters must be used iteratively to get all subscriptions, but it doesn't provide additional semantic context beyond what the schema offers, such as typical usage patterns or constraints.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action ('Get') and resource ('essential subscriptions for the current Cloud Redis account'), making the purpose understandable. However, it doesn't explicitly differentiate from sibling tools like 'get-essential-subscription-by-id' or 'get-pro-subscriptions', which would require mentioning it retrieves all essential subscriptions in a paginated list format.
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 usage by mentioning pagination and the need to iterate through pages, but it doesn't provide explicit guidance on when to use this tool versus alternatives like 'get-essential-subscription-by-id' for single subscriptions or 'get-pro-subscriptions' for different subscription types. No exclusions or prerequisites are stated.
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 of behavioral disclosure. It states that the tool 'Returns a TASK ID that can be used to track the status of the database creation,' which is crucial behavioral information about the asynchronous nature of the operation. However, it does not mention potential side effects like resource consumption, permissions required, or error handling, leaving some gaps for a mutation tool.
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 front-loaded with the core purpose and outcome, followed by prerequisites in a bullet-like format. It is appropriately sized at three sentences, with each sentence adding value (creation action, return value, prerequisites). There is no redundant information, though it could be slightly more structured for readability.
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 complexity (21 parameters, no annotations, no output schema), the description is reasonably complete. It covers the purpose, return value (TASK ID), and prerequisites, which are essential for a creation tool. However, it lacks details on error conditions, rate limits, or authentication needs, which would enhance completeness for such a significant operation.
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 the schema already documents all 21 parameters in detail. The description adds no specific parameter information beyond the general note that 'The payload must match the input schema.' This meets the baseline of 3, as the schema does the heavy lifting, but the description does not compensate with additional context like default behaviors or interdependencies.
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 specific action ('Create a new database') and resource ('inside the specified subscription ID'), and distinguishes from siblings like 'create-pro-subscription' (which creates subscriptions) and 'get-pro-databases' (which retrieves databases). The mention of returning a TASK ID adds specificity about the outcome.
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?
The description explicitly provides prerequisites: '1) For database modules, validate against get-database-modules list. 2) Validate regions using get-pro-plans-regions.' It also mentions that 'The payload must match the input schema,' guiding proper usage. This gives clear when-to-use instructions, including validation steps before invocation.
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 full burden. It discloses key behavioral traits: it returns a TASK ID for tracking status (asynchronous operation), mentions prerequisites (validation steps), and implies a mutation/write operation ('Create'). However, it doesn't mention permissions, rate limits, or error handling, leaving some gaps for a complex creation 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 efficiently structured: first sentence states purpose and return value, second lists prerequisites as bullet points, third reminds about schema compliance. Every sentence adds value with zero waste, and it's front-loaded with the core functionality.
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 complex creation tool with 9 parameters, no annotations, and no output schema, the description does well by explaining the asynchronous nature (TASK ID) and prerequisites. However, it doesn't cover error cases, response format details beyond the task ID, or what happens on failure, which would be helpful given the tool's complexity.
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 the schema already documents all 9 parameters thoroughly. The description adds no specific parameter semantics beyond general validation guidance ('payload must match the input schema'). It doesn't explain parameter interactions or provide additional context beyond what's in 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 action ('Create a new pro subscription') and resource ('pro subscription'), distinguishing it from siblings like 'create-essential-subscription' (different tier) and 'create-pro-database' (different resource). It's specific about what the tool does.
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?
The description provides explicit prerequisites (verify payment method, validate database modules, validate regions) and references specific sibling tools ('get-current-payment-methods', 'get-database-modules', 'get-pro-plans-regions') for validation. It clearly indicates when preparation is needed before using this tool.
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:

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

Score Badge

Copy to your README.md:

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

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/redis/mcp-redis-cloud'

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