DWZ Short URL MCP Server
The DWZ Short URL MCP Server provides comprehensive short URL management capabilities for AI assistants through MCP protocol integration with a dwz-server backend.
Core Capabilities:
Create Short URLs - Generate shortened links with custom domains, titles, descriptions, optional custom codes, and expiration dates
Batch Operations - Create up to 50 short URLs simultaneously for improved efficiency
Retrieve URL Information - Get detailed data for specific short URLs, including original URLs, click statistics, and creation timestamps
List and Search URLs - Browse paginated lists with filtering by domain and keyword search across URLs, titles, and descriptions
Delete URLs - Permanently remove specific short URLs by ID
Manage Domains - List all available domains with configuration details, activation status, and usage statistics
Track Analytics - Access click statistics and usage data for shortened URLs
Secure Operations - API authentication via Bearer Token with comprehensive validation and error handling
Error Handling - Automatic retry mechanisms for reliable operations
Runtime environment used to execute the MCP server
Package manager used for installing dependencies and distributing the MCP server
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@DWZ Short URL MCP Servershorten this product page URL: https://www.example.com/products"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
Mliev Short URL MCP Client
A short URL management client based on MCP (Model Context Protocol) protocol, providing complete short URL generation, management, and statistics functionality for AI assistants. This MCP server is implemented based on the API interface of the dwz-server project.
๐๏ธ Server Architecture
This MCP client calls the short URL service API based on the dwz-server project. dwz-server is a high-performance short URL service developed in Go language, providing complete short URL generation, management, and statistics functionality.
Deploy dwz-server with Docker
It is recommended to deploy dwz-server using Docker as the backend service for the MCP client:
# docker-compose.yml
services:
dwz-server:
container_name: dwz-server
image: docker.cnb.cool/mliev/open/dwz-server:latest
restart: always
ports:
- "8080:8080"
volumes:
- "./config/:/app/config/"
environment:
- TZ=Asia/Shanghai
- GIN_MODE=releaseStart the service:
docker-compose up -dAfter the service starts, the API address will be http://localhost:8080. Configure it in the MCP client:
REMOTE_BASE_URL=http://localhost:8080Related MCP server: Clypt MCP Server
โจ Features
๐ Short URL Creation: Support custom domains, short codes, titles, and descriptions
๐ Batch Operations: Create multiple short URLs at once to improve efficiency
๐ Search & Filter: Support domain filtering and keyword search
๐ Statistics & Analytics: Get detailed click statistics information
๐ก๏ธ Error Handling: Comprehensive error handling and retry mechanisms
๐ Security Authentication: API authentication based on Bearer Token
๐ Quick Start
Prerequisites
Node.js >= 18.0.0
npm or yarn
Direct MCP Usage
{
"mcpServers": {
"dwz-mcp": {
"name": "dwz-mcp",
"type": "stdio",
"isActive": true,
"registryUrl": "",
"command": "npx",
"args": [
"-y",
"@muleiwu/dwz-mcp"
],
"env": {
"REMOTE_BASE_URL": "Your short URL service address",
"REMOTE_API_KEY": "apiKey"
}
}
}
}Install Dependencies
npm installConfigure Environment Variables
Copy the environment variable template and configure:
cp .env.example .envEdit the .env file:
# Remote short URL server configuration
REMOTE_BASE_URL=https://api.example.com
REMOTE_API_KEY=your-api-key-here
# Other optional configuration
REQUEST_TIMEOUT=10000
MAX_RETRIES=3
LOG_LEVEL=infoStart Service
# Development mode
npm run dev
# Production mode
npm start๐ MCP Tool List
1. create_short_url
Create a new short URL
Parameters:
original_url(required): Original URL addressdomain(required): Short URL domaintitle(required): Web page titlecustom_code(optional): Custom short codedescription(optional): Description informationexpire_at(optional): Expiration time
Example:
{
"original_url": "https://www.example.com/products",
"domain": "short.ly",
"title": "Product Page",
"description": "Our product showcase page",
"custom_code": "products"
}2. get_url_info
Get detailed information about a short URL
Parameters:
id(required): Short URL ID
Example:
{
"id": 123
}3. list_short_urls
List short URLs with pagination and search support
Parameters:
page(optional): Page number, default 1page_size(optional): Items per page, default 10domain(optional): Domain filterkeyword(optional): Search keyword
Example:
{
"page": 1,
"page_size": 20,
"domain": "short.ly",
"keyword": "product"
}4. delete_short_url
Delete a short URL
Parameters:
id(required): Short URL ID
Example:
{
"id": 123
}5. batch_create_short_urls
Batch create short URLs
Parameters:
urls(required): URL array (maximum 50)domain(required): Short URL domain
Example:
{
"urls": [
"https://www.example1.com",
"https://www.example2.com"
],
"domain": "short.ly"
}6. list_domains
Get list of all available domains
Parameters: None required
Example:
{}Return Information:
Domain basic information: ID, domain, protocol
Website information: website name, registration information
Configuration information: activation status, parameter pass-through settings
Statistics information: total count, active count, inactive count
๐๏ธ Project Structure
mliev-dwz-mcp/
โโโ src/
โ โโโ index.js # Entry file
โ โโโ config/
โ โ โโโ remoteConfig.js # Configuration management
โ โโโ services/
โ โ โโโ httpClient.js # HTTP client
โ โ โโโ shortLinkService.js # Short link service
โ โโโ utils/
โ โ โโโ validation.js # Parameter validation
โ โ โโโ errorHandler.js # Error handling
โ โโโ mcp/
โ โโโ server.js # MCP server
โ โโโ tools/ # MCP tools
โ โโโ createShortUrl.js
โ โโโ getUrlInfo.js
โ โโโ listShortUrls.js
โ โโโ deleteShortUrl.js
โ โโโ batchCreateShortUrls.js
โ โโโ listDomains.js
โโโ tests/ # Test files
โโโ package.json # Project configuration
โโโ .env.example # Environment variable template
โโโ README.md # Project documentation๐ง Development Guide
Available Scripts
# Start development server (hot reload)
npm run dev
# Build project
npm run build
# Run production environment
npm start
# Run tests
npm test
# Code linting
npm run lint
# Auto-fix code formatting
npm run formatAdding New Tools
Create a new tool file in the
src/mcp/tools/directoryImplement the tool object, including
name,description,inputSchema, andhandlerRegister the new tool in
src/mcp/server.js
Error Handling
The project uses a unified error handling mechanism:
ErrorHandler.asyncWrapper(): Wrap async functions, automatically handle errorsCustomError: Custom error base classValidationError: Parameter validation errorNetworkError: Network request error
๐ API Specification
Response Format
All API responses follow a unified format:
{
"success": true,
"message": "Operation successful",
"data": {
// Response data
},
"meta": {
"operation": "Operation name",
"timestamp": "2024-01-01T00:00:00.000Z"
}
}Error Response
{
"success": false,
"error": {
"code": "ERROR_CODE",
"message": "Error description",
"details": {},
"timestamp": "2024-01-01T00:00:00.000Z"
}
}๐ Configuration Instructions
Environment Variables
Variable Name | Description | Default Value | Required |
| Remote server address | - | โ |
| API key | - | โ |
| API version | v1 | โ |
| Request timeout (ms) | 10000 | โ |
| Maximum retry count | 3 | โ |
| Log level | info | โ |
Domain Configuration
Ensure that the domains used are correctly configured in the remote short URL service.
๐จ Troubleshooting
Common Issues
Connection Failed
Check
REMOTE_BASE_URLandREMOTE_API_KEYconfigurationConfirm network connection is normal
Verify remote service status
Authentication Failed
Confirm API key is correct
Check if the key has sufficient permissions
Parameter Validation Failed
Check if parameter format is correct
Confirm all required parameters are provided
Log Debugging
Set log level to debug to view detailed information:
LOG_LEVEL=debug npm start๐ค Contributing Guide
Fork the project
Create feature branch (
git checkout -b feature/AmazingFeature)Commit changes (
git commit -m 'Add some AmazingFeature')Push to branch (
git push origin feature/AmazingFeature)Open a Pull Request
๐ License
This project is open source under the MIT License - see the LICENSE file for details.
๐ Support
If you encounter problems or have suggestions, please:
Check the Troubleshooting section
Search existing Issues
Create a new Issue describing the problem
๐ Version History
v1.0.0 - Initial version
Basic short URL management functionality
MCP protocol support
Complete error handling mechanism
Available Tools
6 toolsbatch_create_short_urlsB
ๆน้ๅๅปบๅคไธช็ญ็ฝๅ๏ผๆ้ซๅๅปบๆ็ใๆๅคๆฏๆ50ไธชURLใ
| Name | Required | Description | Default |
|---|---|---|---|
| urls | Yes | ่ฆ็ผฉ็ญ็URLๅ่กจ | |
| domain | Yes | ็ญ็ฝๅไฝฟ็จ็ๅๅ |
TDQS
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 mentions the 50-URL limit which is useful context, but doesn't describe what happens on success/failure, whether URLs are validated, if the operation is atomic, what permissions are needed, or what the response format looks like. For a batch creation tool with zero annotation coverage, this is insufficient.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is appropriately concise with two sentences that each add value. The first sentence states the core purpose and benefit, the second provides an important constraint. No wasted words, though it could be slightly more structured.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a batch creation tool with no annotations and no output schema, the description is incomplete. It doesn't explain what gets returned, how errors are handled, whether the operation is transactional, or what authentication/rate limits apply. The efficiency benefit and URL limit are helpful but insufficient for proper agent usage.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
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 thoroughly. The description doesn't add any parameter-specific information beyond what's in the schema - it mentions the 50-URL limit which is already in the schema's maxItems constraint. Baseline 3 is appropriate when the schema does the heavy lifting.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose: 'ๆน้ๅๅปบๅคไธช็ญ็ฝๅ' (batch create multiple short URLs) with the efficiency benefit mentioned. It specifies the resource (short URLs) and verb (create in batch), but doesn't explicitly differentiate from the sibling 'create_short_url' tool beyond mentioning batch capability.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage context by mentioning 'ๆ้ซๅๅปบๆ็' (improve creation efficiency) and the 50-URL limit, suggesting this should be used for bulk operations. However, it doesn't explicitly state when to use this vs. the sibling 'create_short_url' tool or provide clear alternatives or exclusions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
create_short_urlC
ๅๅปบไธไธชๆฐ็็ญ็ฝๅใๆฏๆ่ชๅฎไนๅๅใ็ญไปฃ็ ใๆ ้ขๅๆ่ฟฐไฟกๆฏใ
| Name | Required | Description | Default |
|---|---|---|---|
| original_url | Yes | ๅๅงURLๅฐๅ๏ผ่ฆ็ผฉ็ญ็้ฟ้พๆฅ๏ผ | |
| domain | Yes | ็ญ็ฝๅไฝฟ็จ็ๅๅ๏ผๅฟ ๅกซ๏ผ | |
| custom_code | No | ่ชๅฎไน็ญไปฃ็ ๏ผๅฏ้๏ผๅฆๆไธๆไพๅฐ่ชๅจ็ๆ๏ผ | |
| title | Yes | ็ญ็ฝๅ็ๆ ้ข๏ผๅฟ ๅกซ๏ผ | |
| description | No | ็ญ็ฝๅ็ๆ่ฟฐไฟกๆฏ๏ผๅฏ้๏ผ | |
| expire_at | No | ่ฟๆๆถ้ด๏ผๅฏ้๏ผISO 8601ๆ ผๅผ๏ผไธๅกซ่กจ็คบๆฐธไธ่ฟๆ๏ผ |
TDQS
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 creates a new short URL and lists supported features, but doesn't disclose important behavioral traits: whether this is a write operation (implied but not explicit), what permissions are needed, what happens on success/failure, rate limits, or what the return value looks like (no output schema). The description is insufficient for a mutation tool with zero 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.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient Chinese sentence that states the core purpose and lists key features. It's appropriately sized and front-loaded with the main action. No wasted words, though it could be slightly more structured by separating purpose from features.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a mutation tool (creating resources) with no annotations and no output schema, the description is incomplete. It doesn't explain what happens after creation, what gets returned, error conditions, or behavioral constraints. The 100% schema coverage helps with parameters, but the overall context for using this tool is inadequate given its complexity and lack of structured metadata.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
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 6 parameters thoroughly with descriptions, examples, and constraints. The description mentions the same parameters (custom domain, short code, title, description) but adds no additional semantic meaning beyond what's in the schema. 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.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose: 'ๅๅปบไธไธชๆฐ็็ญ็ฝๅ' (create a new short URL). It specifies the action (create) and resource (short URL), and lists supported features (custom domain, short code, title, description). However, it doesn't explicitly differentiate from sibling tools like batch_create_short_urls, which creates multiple URLs at once.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
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 batch_create_short_urls for bulk operations or get_url_info for retrieving existing URLs. There's no context about prerequisites, typical use cases, or when not to use this tool.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
delete_short_urlA
ๅ ้คๆๅฎ็็ญ็ฝๅใๅ ้คๅๆ ๆณๆขๅค๏ผ่ฏท่ฐจๆ ๆไฝใ
| Name | Required | Description | Default |
|---|---|---|---|
| id | Yes | ่ฆๅ ้ค็็ญ็ฝๅID |
TDQS
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 communicates key behavioral traits: it is a destructive operation ('ๅ ้คๅๆ ๆณๆขๅค' meaning cannot be recovered after deletion) and requires caution ('่ฏท่ฐจๆ ๆไฝ' meaning please operate carefully). This covers safety aspects well, though it could add more context like authentication needs or rate limits for a higher score.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is extremely concise and front-loaded, consisting of just two short sentences that directly state the purpose and critical warning. Every sentence earns its place by providing essential information without any waste, making it highly efficient and well-structured for an AI agent.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's complexity (a destructive delete operation), lack of annotations, and no output schema, the description does a good job of covering key aspects: purpose, irreversible nature, and caution. However, it could be more complete by mentioning potential side effects (e.g., impact on linked data) or response format, which would help the agent understand the full context better.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has 100% description coverage, with the 'id' parameter fully documented in the schema ('่ฆๅ ้ค็็ญ็ฝๅID' meaning short URL ID to delete). The description does not add any additional meaning or details beyond what the schema provides, such as format examples or constraints. Given the high schema coverage, a baseline score of 3 is appropriate as the schema handles the parameter semantics adequately.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the specific action ('ๅ ้ค' meaning delete) and resource ('ๆๅฎ็็ญ็ฝๅ' meaning specified short URL), distinguishing it from sibling tools like create_short_url, batch_create_short_urls, get_url_info, and list_short_urls. It precisely communicates what the tool does without being vague or tautological.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides clear context for usage by warning that deletion is irreversible ('ๅ ้คๅๆ ๆณๆขๅค'), implying this tool should be used cautiously and only when permanent removal is intended. However, it does not explicitly state when to use alternatives (e.g., for temporary deactivation or other operations), nor does it name specific sibling tools as alternatives, which prevents a perfect score.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_url_infoC
ๆ นๆฎ็ญ็ฝๅID่ทๅ่ฏฆ็ปไฟกๆฏ๏ผๅ ๆฌๅๅงURLใ็นๅป็ป่ฎกใๅๅปบๆถ้ด็ญใ
| Name | Required | Description | Default |
|---|---|---|---|
| id | Yes | ็ญ็ฝๅ็ๅฏไธๆ ่ฏID |
TDQS
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 it states this is a read operation ('่ทๅ'), it doesn't mention potential constraints like authentication requirements, rate limits, error conditions (e.g., invalid ID), or what happens if the ID doesn't exist. For a tool with no 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.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence that states the purpose and lists examples of returned information (original URL, click statistics, creation time). It's front-loaded with the core function and avoids unnecessary words. However, it could be slightly more structured by separating the purpose from the examples for clarity.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's simplicity (1 parameter, no output schema, no annotations), the description is minimally adequate. It covers the basic purpose and hints at return values, but lacks details on behavioral aspects like errors or constraints. Without annotations or output schema, the description should ideally provide more context on what '่ฏฆ็ปไฟกๆฏ' entails and any usage limitations to be fully complete.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
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 'id' well-documented in the schema as '็ญ็ฝๅ็ๅฏไธๆ ่ฏID' (unique identifier ID for short URL). The description doesn't add any parameter-specific information beyond what's in the schema, such as format details or examples. With high schema coverage, the baseline score of 3 is appropriate as the schema handles the parameter documentation adequately.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose: 'ๆ นๆฎ็ญ็ฝๅID่ทๅ่ฏฆ็ปไฟกๆฏ' (get detailed information based on short URL ID). It specifies the verb '่ทๅ' (get/retrieve) and resource '่ฏฆ็ปไฟกๆฏ' (detailed information), and lists examples of what information is included. However, it doesn't explicitly differentiate from sibling tools like 'list_short_urls' which might provide similar information in a different format.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
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 'list_short_urls' (which might list multiple URLs without details) or 'batch_create_short_urls' (for creation). There's no context about prerequisites, such as needing an existing short URL ID, or when this tool is preferred over others.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
list_domainsB
่ทๅๆๆๅฏ็จ็ๅๅๅ่กจ๏ผๅ ๆฌๅๅ้ ็ฝฎไฟกๆฏๅ็ถๆใ
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
TDQS
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 mentions what information is returned (configuration and status) but doesn't describe important behaviors like whether this is a read-only operation, if it requires authentication, rate limits, pagination, or what happens if no domains exist. For a list operation with zero annotation coverage, this leaves 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.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence that communicates the core purpose without any wasted words. It's appropriately sized for a simple list operation and front-loads the key information ('่ทๅๆๆๅฏ็จ็ๅๅๅ่กจ'). Every word earns its place.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple list operation with no parameters and no output schema, the description provides adequate but minimal information. It states what the tool does and what information it returns, but lacks behavioral context that would be helpful given the absence of annotations. Without an output schema, the description should ideally provide more detail about return format, but it only mentions '้ ็ฝฎไฟกๆฏๅ็ถๆ' without specifics.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
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 the schema already fully documents the parameter situation. The description appropriately doesn't waste space discussing non-existent parameters. A baseline of 4 is appropriate for zero-parameter tools where the schema handles everything.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action ('่ทๅๆๆๅฏ็จ็ๅๅๅ่กจ' - get all available domain list) and the resource ('ๅๅ' - domains), including what information is returned ('ๅๅ้ ็ฝฎไฟกๆฏๅ็ถๆ' - domain configuration information and status). It distinguishes from siblings like list_short_urls by focusing on domains rather than URLs. However, it doesn't explicitly contrast with other domain-related tools (none in sibling list), so it's not a perfect 5.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
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. There's no mention of prerequisites, timing considerations, or comparison with other tools. The agent must infer usage from the purpose alone, which is insufficient for optimal tool selection.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
list_short_urlsB
ๅๅบ็จๆท็็ญ็ฝๅๅ่กจ๏ผๆฏๆๅ้กตใๅๅ็ญ้ๅๅ ณ้ฎ่ฏๆ็ดขใ
| Name | Required | Description | Default |
|---|---|---|---|
| page | No | ้กต็ ๏ผไป1ๅผๅง | |
| page_size | No | ๆฏ้กตๆฐ้๏ผๆๅคง100๏ผ้ป่ฎค10 | |
| domain | No | ๆๅๅ็ญ้๏ผๅฏ้๏ผ | |
| keyword | No | ๆ็ดขๅ ณ้ฎ่ฏ๏ผๆ็ดขURLใๆ ้ขๆๆ่ฟฐ๏ผๅฏ้๏ผ |
TDQS
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. While it mentions pagination support, it doesn't describe important behavioral aspects like authentication requirements, rate limits, error conditions, or what the response format looks like (since there's no output schema). For a listing tool with filtering capabilities, this leaves significant gaps in understanding how the tool actually behaves.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient Chinese sentence that front-loads the core purpose ('ๅๅบ็จๆท็็ญ็ฝๅๅ่กจ') followed by the key capabilities ('ๆฏๆๅ้กตใๅๅ็ญ้ๅๅ ณ้ฎ่ฏๆ็ดข'). Every word earns its place with zero wasted text, making it immediately scannable and understandable.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a tool with 4 parameters, no annotations, and no output schema, the description is insufficiently complete. While it states what the tool does at a high level, it doesn't provide enough context about authentication requirements, response format, error handling, or practical usage examples. The agent would need to guess about important operational aspects of this listing tool.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the schema already fully documents all 4 parameters with descriptions, constraints, and examples. The description mentions the three filtering parameters (pagination, domain filtering, keyword search) but adds no additional semantic information beyond what's in the schema. This meets the baseline of 3 for high schema coverage situations.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb ('ๅๅบ' - list) and resource ('็จๆท็็ญ็ฝๅๅ่กจ' - user's short URL list), making the purpose immediately understandable. It distinguishes from siblings like 'get_url_info' (which likely gets details of a specific URL) by focusing on listing multiple items with filtering. However, it doesn't explicitly mention how it differs from 'list_domains' (which lists domains rather than URLs).
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage context through the mention of filtering capabilities (domain filtering and keyword search), suggesting this tool should be used when needing filtered lists rather than all URLs. However, it doesn't explicitly state when to use this versus alternatives like 'get_url_info' for single URL details or 'list_domains' for domain management. No explicit 'when-not' guidance is provided.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
6 tool updates
- First observed
batch_create_short_urls - First observed
create_short_url - First observed
delete_short_url - First observed
get_url_info - First observed
list_domains - First observed
list_short_urls
TDQS
Scored across 6 tools
Each tool has a clearly distinct purpose with no overlap. Batch creation, single creation, deletion, info retrieval, domain listing, and URL listing all target specific operations in the short URL domain, making misselection unlikely.
All tools follow a consistent verb_noun pattern with snake_case (e.g., create_short_url, list_domains). The naming is predictable and readable across all six tools.
Six tools is well-scoped for a short URL management server. It covers core CRUD operations (create, get, delete, list) plus domain management and batch creation, with each tool earning its place without bloat.
The toolset provides strong coverage for short URL lifecycle management, including creation, deletion, listing, and info retrieval, plus domain handling. A minor gap is the lack of an update tool for modifying existing short URLs, but agents can work around this by deletion and recreation.
Maintenance
Related MCP Connectors
Create and manage short links, track clicks, and automate URL management
Free URL shortener: manage short links, QR codes and click analytics from AI clients.
Create short links, QR codes, UTM templates, vCards, and landing pages from your AI assistant.
Short-link service embedded in your AI workflow โ shorten links, track campaigns, read stats.
Related MCP Servers
- AlicenseBqualityDmaintenanceEnables AI agents to create, update, and manage short links through your Dub.co account, allowing for creation, modification, and deletion of custom shortened URLs.418MIT
- AlicenseNot gradedqualityCmaintenanceConnects AI assistants to the Clypt Link Intelligence platform to shorten URLs, manage tags, and generate QR codes. It enables users to view link analytics and perform bulk link operations through natural language commands.55MIT
- AlicenseBqualityDmaintenanceEnables AI assistants to interact with a Shlink URL shortening instance, allowing creation, listing, retrieval, and deletion of short URLs, as well as tag management.53Apache 2.0
- AlicenseAqualityBmaintenanceEnables AI assistants to manage ULink deep linking projects, including creating smart links, configuring domains, and viewing analytics.24100MIT