Suno-MCP

by MeroZemory

Overview Schema Related Servers Score Discussions

Python

Local

Server Quality Checklist

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

Latest release: v2.0.0
Disambiguation5/5
Every tool has a clearly distinct purpose with no ambiguity. Each tool targets a specific action on a specific resource (e.g., generate_track vs. download_track vs. track_info), and even similar-sounding tools like track_extend and track_remix have clearly differentiated functions described in their arguments.
Naming Consistency5/5
All tools follow a consistent suno_verb_noun pattern throughout (e.g., suno_generate_track, suno_download_track, suno_track_info). The naming is predictable and readable, with no deviations in convention or style.
Tool Count5/5
With 10 tools, this is well-scoped for automating Suno AI interactions. Each tool earns its place, covering browser management, authentication, track generation, library access, and track operations, without being overly sparse or bloated.
Completeness4/5
The tool surface is nearly complete for the Suno AI domain, covering login, browser setup, track generation, extension, remixing, info retrieval, library listing, and downloading. A minor gap is the lack of a tool to delete or manage tracks beyond generation, but core workflows are well-covered.
Average 3.3/5 across 10 of 10 tools scored.
See the Tool Scores section below for per-tool breakdowns.
- No community issues 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?
With no annotations provided, the description carries the full burden of behavioral disclosure. It mentions downloading files and optional stems, but lacks details on permissions, rate limits, file formats, error handling, or whether it's a read-only operation. This is a significant gap for a tool that likely involves file system writes.
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 and front-loaded: the first sentence states the core purpose, followed by a structured parameter list. Every sentence adds value, though the parameter explanations could be more detailed to improve clarity without sacrificing 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 complexity (file download with optional stems) and no annotations, the description is minimally adequate but has clear gaps. It covers the basic action and parameters but lacks behavioral context. The presence of an output schema helps, but the description doesn't reference it or explain return values, leaving uncertainty about success/failure responses.
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 description lists all three parameters with brief explanations, adding meaning beyond the schema's 0% coverage. However, it doesn't specify formats (e.g., track ID structure, path syntax) or constraints (e.g., stem availability conditions). Given the low schema coverage, this provides basic but incomplete compensation.
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: 'Download a generated track from Suno AI by track ID.' It specifies the verb (download), resource (track), and source (Suno AI). However, it doesn't explicitly differentiate from siblings like 'suno_track_info' or 'suno_get_status', which might provide track details without downloading.
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 a generated track first), exclusions, or comparisons to sibling tools like 'suno_track_info' for metadata or 'suno_library_list' for browsing tracks.
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 mentions OAuth and session persistence, which are useful, but fails to cover critical aspects like authentication requirements (e.g., 2FA handling), error conditions (e.g., invalid credentials), rate limits, or what 'Saves session' entails (e.g., duration, storage). This leaves significant gaps for a tool that handles sensitive credentials.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness3/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is front-loaded with the main purpose and includes a structured 'Args' section, but the formatting is inconsistent (e.g., mixing markdown-like elements with plain text). It could be more streamlined by integrating parameter details more seamlessly, and the second sentence about session saving, while useful, feels slightly tacked on.
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 (handling OAuth with credentials), no annotations, and an output schema (implied by 'Has output schema: true'), the description is moderately complete. It covers the basic purpose and parameters but misses behavioral details like error handling or session management specifics. The output schema likely handles return values, so that gap is mitigated.
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 adds meaningful context beyond the input schema, which has 0% coverage. It specifies that 'email' and 'password' are for a Google account, provides an example format for email, and clarifies their purpose in the OAuth login process. This compensates well for the lack of schema descriptions, though it doesn't detail constraints like password 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 action ('Login to Suno AI via Google OAuth') and resource ('Suno AI'), distinguishing it from siblings like 'suno_open_browser' or 'suno_get_status'. However, it doesn't explicitly differentiate from other potential authentication methods or tools, keeping it from a perfect score.
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 mentions that it 'Saves session for future use', which provides some context for when to use it (e.g., before other operations requiring authentication). However, it lacks explicit guidance on when to use this vs. alternatives like 'suno_open_browser' or prerequisites (e.g., needing a Google account), and no exclusions are 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 only states what the tool does ('Get detailed information') without mentioning permissions, rate limits, response format, or error handling. This is a significant gap for a tool with no annotation coverage, as it lacks crucial operational details.
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 and front-loaded, with the main purpose stated first followed by parameter details. Both sentences earn their place, and there's no unnecessary verbosity, making it efficient for quick understanding.
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 (1 parameter) and the presence of an output schema (which handles return values), the description is minimally adequate. However, with no annotations and incomplete behavioral transparency, it lacks depth for a tool that might involve network calls or authentication, leaving gaps in overall completeness.
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 adds meaningful context for the single parameter: 'track_id: The unique track identifier.' Since schema description coverage is 0% (the schema only provides a title 'Track Id' and type 'string'), this compensates well by explaining what the parameter represents, though it doesn't specify format 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 tool's purpose: 'Get detailed information about a specific Suno AI track.' It specifies the verb ('Get') and resource ('Suno AI track'), making the function unambiguous. However, it doesn't explicitly differentiate from sibling tools like 'suno_get_status' or 'suno_library_list', which might also provide track-related information.
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 sibling tools like 'suno_get_status' (which might provide status updates) or 'suno_library_list' (which might list tracks), leaving the agent to infer usage context without explicit 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?
No annotations are provided, so the description carries the full burden of behavioral disclosure. It states the tool generates music but doesn't cover critical aspects like whether it's a read-only or destructive operation, authentication requirements, rate limits, or what the output contains (though an output schema exists). The description is minimal and lacks behavioral context 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 appropriately sized and front-loaded: it starts with a clear purpose statement, followed by a structured 'Args' section listing parameters with brief explanations. Every sentence earns its place, with no redundant or verbose content. It's efficient and well-organized.
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 complexity (a generative AI tool with 4 parameters) and the presence of an output schema, the description is partially complete. It covers the basic purpose and parameters but lacks behavioral context (e.g., authentication, side effects) and usage guidelines. The output schema mitigates the need to explain return values, but other gaps remain, making it adequate but with clear omissions.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, but the description compensates by explaining all 4 parameters in the 'Args' section: prompt, style, lyrics, and duration. It adds meaning beyond the schema by providing examples (e.g., style values like 'synthwave') and clarifying optionality (lyrics is optional). This effectively documents the parameters, though it doesn't detail constraints like format or length.
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: 'Generate a new music track using Suno AI.' It specifies the verb ('Generate') and resource ('music track'), but doesn't differentiate from sibling tools like suno_track_remix or suno_track_extend, which also create or modify tracks. The purpose is clear but lacks sibling distinction.
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. The description doesn't mention sibling tools like suno_track_remix (for remixing) or suno_track_extend (for extending tracks), nor does it specify prerequisites (e.g., needing to be logged in with suno_login) or contextual constraints. Usage is implied but not explicit.
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 implies a mutation operation ('remix/cover'), but doesn't specify whether this creates a new track, modifies the original, requires authentication, has rate limits, or what the output entails. 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.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is well-structured and concise. It opens with a clear purpose statement, followed by a bulleted list of parameters with brief explanations. Every sentence earns its place, and there's no redundant or verbose content, making it easy 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 mutation operation with 3 parameters) and the presence of an output schema (which handles return values), the description is partially complete. It covers the purpose and parameters but lacks behavioral details like authentication needs or side effects. With no annotations and incomplete behavioral transparency, it's adequate but has clear gaps.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, so the description must compensate. It adds meaningful context for all three parameters: 'track_id' as 'unique track identifier to remix', 'prompt' as 'new description for the remix', and 'style' as 'optional new musical style'. This clarifies each parameter's role beyond the bare schema, though it could provide more detail on formats 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 tool's purpose: 'Remix/cover an existing Suno AI track with a new prompt.' It specifies the verb ('remix/cover'), resource ('existing Suno AI track'), and action ('with a new prompt'). However, it doesn't explicitly differentiate from sibling tools like 'suno_track_extend' or 'suno_generate_track', which keeps it from a perfect score.
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 an existing track), exclusions, or comparisons to siblings like 'suno_track_extend' for extending tracks or 'suno_generate_track' for creating new ones. This lack of context leaves the agent without clear 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?
No annotations are provided, so the description carries the full burden of behavioral disclosure. It mentions 'requires login', which adds useful context about authentication needs, but it doesn't cover other important aspects like whether this is a read-only operation, potential rate limits, pagination behavior, or what the output looks like. This is a significant gap 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: one stating the purpose and login requirement, and another detailing the parameter. It's front-loaded with the main function, but the parameter explanation could be integrated more seamlessly, and there's minor redundancy in stating 'Args:' separately.
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 has an output schema (which handles return values), the description's focus on purpose and parameters is adequate. However, with no annotations and only partial behavioral context (e.g., missing details on read-only nature or error cases), it's not fully complete. It meets minimum viability but has clear gaps.
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 adds meaningful semantics for the single parameter 'limit' by explaining it as 'Maximum number of tracks to return (default: 20)', which goes beyond the schema's basic type and title. Since schema description coverage is 0%, this compensates well, but it doesn't cover edge cases like minimum values or error handling.
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 ('List') and resource ('tracks from your Suno AI library'), making it easy to understand what it does. However, it doesn't explicitly differentiate from sibling tools like 'suno_track_info' or 'suno_get_status', which might also retrieve track information, so it doesn't reach the highest score.
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 usage context by mentioning 'requires login', implying this tool should be used after authentication. However, it doesn't specify when to use this tool versus alternatives like 'suno_track_info' for individual tracks or 'suno_generate_track' for creating new ones, leaving gaps in 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 provided, the description carries the full burden of behavioral disclosure. It adds context beyond basic functionality: 'stealth mode' implies enhanced privacy or anti-detection features, and the headless default explanation for 'Google OAuth' hints at authentication needs. However, it doesn't cover other behavioral traits like error handling, performance, or side effects, leaving gaps for a tool that likely involves browser automation.
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 and front-loaded, starting with the main purpose and following with parameter details. Both sentences earn their place by providing essential information without redundancy. However, the structure could be slightly improved by separating usage context more clearly.
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 (browser automation with stealth mode) and the presence of an output schema (which reduces need to explain return values), the description is moderately complete. It covers the purpose and key parameter semantics but lacks details on behavioral aspects like error conditions or integration with other tools, making it adequate but with clear gaps.
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 adds meaningful semantics for the single parameter 'headless,' explaining its default value (False) and purpose ('headful for Google OAuth'), which goes beyond the schema's basic type and title. With 0% schema description coverage, this compensation is effective, though it doesn't detail other potential parameters or edge cases.
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: 'Open Chrome browser with stealth mode for Suno AI.' It specifies the verb ('Open'), resource ('Chrome browser'), and context ('for Suno AI'), distinguishing it from siblings like suno_close_browser or suno_login. However, it doesn't explicitly differentiate from other browser-related tools if any existed, but the context makes it clear.
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 'for Suno AI' and the default headless setting for 'Google OAuth,' suggesting this tool is used in authentication or interaction contexts with Suno AI. However, it lacks explicit guidance on when to use this tool versus alternatives like suno_login or other siblings, leaving the agent to infer based on 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 full burden for behavioral disclosure. It states the tool extends tracks but doesn't explain what 'extend' entails operationally (e.g., appends audio, modifies metadata), authentication requirements, rate limits, or what happens to the original track. The description is too minimal 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.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is perfectly structured with a clear purpose statement followed by a bullet-point parameter explanation. Every sentence earns its place, with no redundant information or unnecessary elaboration. The formatting enhances readability.
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 has an output schema (which handles return values), the description covers the basic purpose and parameters adequately. However, as a mutation tool with no annotations, it should provide more behavioral context about what 'extend' means operationally and any side effects. The current description is minimal but not completely inadequate.
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?
With 0% schema description coverage, the description compensates well by explaining all three parameters: track_id ('unique track identifier'), prompt ('description of how to continue'), and duration ('approximate extension length in seconds' with default). It adds meaningful context beyond the bare schema titles.
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 ('Extend') and resource ('existing Suno AI track'), distinguishing it from siblings like suno_generate_track (create new) and suno_track_remix (modify differently). It uses precise terminology that directly communicates the tool's function.
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 suno_track_remix or suno_generate_track. It mentions the tool extends 'an existing' track but doesn't clarify prerequisites, timing considerations, or exclusion criteria for different scenarios.
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 states that the tool closes the browser session and cleans up resources, which implies a destructive or cleanup operation, but doesn't detail what 'clean up' involves (e.g., closing tabs, clearing cache, terminating processes). It also doesn't mention error handling or side effects, leaving gaps 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.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, well-structured sentence that directly states the tool's purpose without any unnecessary words. It is front-loaded with the main action ('Close the Playwright browser session') and adds a clarifying detail ('and clean up resources'), making it highly efficient and easy to parse.
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 (0 parameters, no annotations, but has an output schema), the description is mostly complete. It explains what the tool does, but lacks details on behavioral aspects like what 'clean up resources' entails or potential errors. The presence of an output schema means return values are documented elsewhere, so the description doesn't need to cover them, but it could benefit from more context on usage scenarios.
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 there are no parameters to document. The description appropriately doesn't discuss parameters, which is efficient. However, it doesn't add any semantic context beyond the schema, such as explaining why no parameters are needed, so it doesn't reach a perfect score.
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 ('Close') and the resource ('Playwright browser session'), making the purpose immediately understandable. It distinguishes itself from siblings like 'suno_open_browser' by performing the opposite operation. However, it doesn't specify what 'clean up resources' entails beyond closing the session, which keeps it from a perfect score.
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 after browser-based operations are complete, but it doesn't explicitly state when to use this tool versus alternatives or prerequisites. For example, it doesn't mention if this should be called after all browser-dependent tasks or as part of cleanup routines. The context is clear but lacks explicit guidance on timing or dependencies.
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 mentions what is retrieved (browser, page, session persistence), which gives some context about the tool's behavior. However, it lacks details on potential side effects, error conditions, or response format specifics that would be helpful for an agent. The description is adequate but misses deeper behavioral traits like performance or reliability hints.
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 front-loads the key action ('Get current Suno AI session status') and adds clarifying details in parentheses. Every word earns its place by specifying what status entails without redundancy. It is appropriately sized for a no-parameter tool and avoids any fluff or verbose explanations.
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 low complexity (0 parameters, no annotations, but has an output schema), the description is complete enough for basic understanding. It explains what the tool does and what it returns (session status details). Since an output schema exists, the description doesn't need to detail return values, making it sufficient. However, it could improve by hinting at why this status is useful in the context of sibling tools.
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%, meaning there are no parameters to document. The description does not need to compensate for any gaps, as there is nothing to explain beyond the schema. A baseline of 4 is appropriate since no parameter information is required, and the description focuses on the tool's purpose without unnecessary details.
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 as 'Get current Suno AI session status' with specific details about what status is retrieved (browser, page, session persistence). It distinguishes from siblings like suno_login or suno_generate_track by focusing on status retrieval rather than authentication or content creation. However, it doesn't explicitly differentiate from suno_track_info which might also provide status-related information.
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 context by specifying 'current Suno AI session status,' suggesting it should be used to check session health or persistence. However, it provides no explicit guidance on when to use this tool versus alternatives like suno_login for authentication issues or suno_open_browser for browser-related actions. The usage is inferred but not clearly articulated with exclusions or comparisons to siblings.
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:

[![suno-multi-mcp MCP server](https://glama.ai/mcp/servers/MeroZemory/suno-multi-mcp/badges/card.svg)](https://glama.ai/mcp/servers/MeroZemory/suno-multi-mcp)

Score Badge

Copy to your README.md:

[![suno-multi-mcp MCP server](https://glama.ai/mcp/servers/MeroZemory/suno-multi-mcp/badges/score.svg)](https://glama.ai/mcp/servers/MeroZemory/suno-multi-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/MeroZemory/suno-multi-mcp'

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