Skip to main content
Glama
muleiwu

DWZ Short URL MCP Server

by muleiwu

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=release

Start the service:

docker-compose up -d

After the service starts, the API address will be http://localhost:8080. Configure it in the MCP client:

REMOTE_BASE_URL=http://localhost:8080

Related 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 install

Configure Environment Variables

Copy the environment variable template and configure:

cp .env.example .env

Edit 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=info

Start 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 address

  • domain (required): Short URL domain

  • title (required): Web page title

  • custom_code (optional): Custom short code

  • description (optional): Description information

  • expire_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 1

  • page_size (optional): Items per page, default 10

  • domain (optional): Domain filter

  • keyword (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 format

Adding New Tools

  1. Create a new tool file in the src/mcp/tools/ directory

  2. Implement the tool object, including name, description, inputSchema, and handler

  3. Register 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 errors

  • CustomError: Custom error base class

  • ValidationError: Parameter validation error

  • NetworkError: 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_BASE_URL

Remote server address

-

โœ…

REMOTE_API_KEY

API key

-

โœ…

API_VERSION

API version

v1

โŒ

REQUEST_TIMEOUT

Request timeout (ms)

10000

โŒ

MAX_RETRIES

Maximum retry count

3

โŒ

LOG_LEVEL

Log level

info

โŒ

Domain Configuration

Ensure that the domains used are correctly configured in the remote short URL service.

๐Ÿšจ Troubleshooting

Common Issues

  1. Connection Failed

    • Check REMOTE_BASE_URL and REMOTE_API_KEY configuration

    • Confirm network connection is normal

    • Verify remote service status

  2. Authentication Failed

    • Confirm API key is correct

    • Check if the key has sufficient permissions

  3. 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

  1. Fork the project

  2. Create feature branch (git checkout -b feature/AmazingFeature)

  3. Commit changes (git commit -m 'Add some AmazingFeature')

  4. Push to branch (git push origin feature/AmazingFeature)

  5. 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:

  1. Check the Troubleshooting section

  2. Search existing Issues

  3. 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 tools
batch_create_short_urlsB

ๆ‰น้‡ๅˆ›ๅปบๅคšไธช็Ÿญ็ฝ‘ๅ€๏ผŒๆ้ซ˜ๅˆ›ๅปบๆ•ˆ็އใ€‚ๆœ€ๅคšๆ”ฏๆŒ50ไธชURLใ€‚

ParametersJSON Schema
NameRequiredDescriptionDefault
urlsYes่ฆ็ผฉ็Ÿญ็š„URLๅˆ—่กจ
domainYes็Ÿญ็ฝ‘ๅ€ไฝฟ็”จ็š„ๅŸŸๅ

TDQS

B3.1/5.0
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 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.

Conciseness4/5

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.

Completeness2/5

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.

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 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.

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: 'ๆ‰น้‡ๅˆ›ๅปบๅคšไธช็Ÿญ็ฝ‘ๅ€' (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.

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 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

ๅˆ›ๅปบไธ€ไธชๆ–ฐ็š„็Ÿญ็ฝ‘ๅ€ใ€‚ๆ”ฏๆŒ่‡ชๅฎšไน‰ๅŸŸๅใ€็Ÿญไปฃ็ ใ€ๆ ‡้ข˜ๅ’Œๆ่ฟฐไฟกๆฏใ€‚

ParametersJSON Schema
NameRequiredDescriptionDefault
original_urlYesๅŽŸๅง‹URLๅœฐๅ€๏ผˆ่ฆ็ผฉ็Ÿญ็š„้•ฟ้“พๆŽฅ๏ผ‰
domainYes็Ÿญ็ฝ‘ๅ€ไฝฟ็”จ็š„ๅŸŸๅ๏ผˆๅฟ…ๅกซ๏ผ‰
custom_codeNo่‡ชๅฎšไน‰็Ÿญไปฃ็ ๏ผˆๅฏ้€‰๏ผŒๅฆ‚ๆžœไธๆไพ›ๅฐ†่‡ชๅŠจ็”Ÿๆˆ๏ผ‰
titleYes็Ÿญ็ฝ‘ๅ€็š„ๆ ‡้ข˜๏ผˆๅฟ…ๅกซ๏ผ‰
descriptionNo็Ÿญ็ฝ‘ๅ€็š„ๆ่ฟฐไฟกๆฏ๏ผˆๅฏ้€‰๏ผ‰
expire_atNo่ฟ‡ๆœŸๆ—ถ้—ด๏ผˆๅฏ้€‰๏ผŒISO 8601ๆ ผๅผ๏ผŒไธๅกซ่กจ็คบๆฐธไธ่ฟ‡ๆœŸ๏ผ‰

TDQS

C2.9/5.0
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 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.

Conciseness4/5

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.

Completeness2/5

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.

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 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.

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: 'ๅˆ›ๅปบไธ€ไธชๆ–ฐ็š„็Ÿญ็ฝ‘ๅ€' (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.

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 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

ๅˆ ้™คๆŒ‡ๅฎš็š„็Ÿญ็ฝ‘ๅ€ใ€‚ๅˆ ้™คๅŽๆ— ๆณ•ๆขๅค๏ผŒ่ฏท่ฐจๆ…Žๆ“ไฝœใ€‚

ParametersJSON Schema
NameRequiredDescriptionDefault
idYes่ฆๅˆ ้™ค็š„็Ÿญ็ฝ‘ๅ€ID

TDQS

A4.2/5.0
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 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.

Conciseness5/5

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.

Completeness4/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 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.

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 '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.

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 ('ๅˆ ้™ค' 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.

Usage Guidelines4/5

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ใ€็‚นๅ‡ป็ปŸ่ฎกใ€ๅˆ›ๅปบๆ—ถ้—ด็ญ‰ใ€‚

ParametersJSON Schema
NameRequiredDescriptionDefault
idYes็Ÿญ็ฝ‘ๅ€็š„ๅ”ฏไธ€ๆ ‡่ฏ†ID

TDQS

C2.9/5.0
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 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.

Conciseness4/5

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.

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 (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.

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 '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.

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: 'ๆ นๆฎ็Ÿญ็ฝ‘ๅ€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.

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 '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

่Žทๅ–ๆ‰€ๆœ‰ๅฏ็”จ็š„ๅŸŸๅๅˆ—่กจ๏ผŒๅŒ…ๆ‹ฌๅŸŸๅ้…็ฝฎไฟกๆฏๅ’Œ็Šถๆ€ใ€‚

ParametersJSON Schema
NameRequiredDescriptionDefault

No parameters

TDQS

B3.2/5.0
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 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.

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 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.

Completeness3/5

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.

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 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.

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 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.

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. 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

ๅˆ—ๅ‡บ็”จๆˆท็š„็Ÿญ็ฝ‘ๅ€ๅˆ—่กจ๏ผŒๆ”ฏๆŒๅˆ†้กตใ€ๅŸŸๅ็ญ›้€‰ๅ’Œๅ…ณ้”ฎ่ฏๆœ็ดขใ€‚

ParametersJSON Schema
NameRequiredDescriptionDefault
pageNo้กต็ ๏ผŒไปŽ1ๅผ€ๅง‹
page_sizeNoๆฏ้กตๆ•ฐ้‡๏ผŒๆœ€ๅคง100๏ผŒ้ป˜่ฎค10
domainNoๆŒ‰ๅŸŸๅ็ญ›้€‰๏ผˆๅฏ้€‰๏ผ‰
keywordNoๆœ็ดขๅ…ณ้”ฎ่ฏ๏ผŒๆœ็ดขURLใ€ๆ ‡้ข˜ๆˆ–ๆ่ฟฐ๏ผˆๅฏ้€‰๏ผ‰

TDQS

B3.2/5.0
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. 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.

Conciseness5/5

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.

Completeness2/5

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.

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 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.

Purpose4/5

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.

Usage Guidelines3/5

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.

  1. 6 tool updates
    • First observedbatch_create_short_urls
    • First observedcreate_short_url
    • First observeddelete_short_url
    • First observedget_url_info
    • First observedlist_domains
    • First observedlist_short_urls

TDQS

A3.6/5.0

Scored across 6 tools

Disambiguation5/5

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.

Naming Consistency5/5

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.

Tool Count5/5

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.

Completeness4/5

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

ActivityInactive
ResponsivenessNo issues

Related MCP Connectors

Related MCP Servers

  • A
    license
    Not graded
    quality
    C
    maintenance
    Connects 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.
    55
    MIT
  • A
    license
    B
    quality
    D
    maintenance
    Enables AI assistants to interact with a Shlink URL shortening instance, allowing creation, listing, retrieval, and deletion of short URLs, as well as tag management.
    5
    3
    Apache 2.0