Skip to main content
Glama
247arjun

Curl MCP Server

by 247arjun
OverviewSchemaRelated ServersScoreDiscussions
JavaScript
Remote

MCP Server for Curl

npm version npm downloads

A Model Context Protocol (MCP) server that provides curl functionality, allowing AI assistants to make HTTP requests directly from their environment.

Features

  • HTTP Methods: Support for GET, POST, PUT, DELETE requests

  • File Downloads: Download files with curl

  • Advanced Options: Custom headers, timeouts, redirects, and more

  • JSON Support: Built-in JSON data handling for POST/PUT requests

  • User Agent: Custom User-Agent string support

  • Security: Safe subprocess execution with input validation

Related MCP server: MCP HTTP Client Server

Installation

Method 1: NPM Installation (Recommended)

# Install globally
npm install -g @247arjun/mcp-curl

# Or install locally in your project
npm install @247arjun/mcp-curl

Method 2: From Source

# Clone the repository
git clone https://github.com/247arjun/mcp-curl.git
cd mcp-curl

# Install dependencies
npm install

# Build the project
npm run build

# Optional: Link globally
npm link

Method 3: Direct from GitHub

# Install directly from GitHub
npm install -g git+https://github.com/247arjun/mcp-curl.git

Configuration

Claude Desktop Setup

Add to your Claude Desktop configuration file:

Location:

  • macOS: ~/Library/Application Support/Claude/claude_desktop_config.json

  • Windows: %APPDATA%/Claude/claude_desktop_config.json

Configuration:

{
  "mcpServers": {
    "mcp-curl": {
      "command": "mcp-curl",
      "args": []
    }
  }
}

Alternative: Using npx (no global install needed)

{
  "mcpServers": {
    "mcp-curl": {
      "command": "npx",
      "args": ["@247arjun/mcp-curl"]
    }
  }
}

Local Development Setup

{
  "mcpServers": {
    "mcp-curl": {
      "command": "node",
      "args": ["/absolute/path/to/mcp-curl/build/index.js"]
    }
  }
}

After adding the configuration, restart Claude Desktop to load the MCP server.

Available Tools

1. curl_get

Make HTTP GET requests.

Parameters:

  • url (string): The URL to make the GET request to

  • headers (array, optional): HTTP headers in the format 'Header: Value'

  • timeout (number, optional): Request timeout in seconds

  • follow_redirects (boolean, optional): Whether to follow redirects

  • user_agent (string, optional): Custom User-Agent string

Example:

{
  "url": "https://api.example.com/data",
  "headers": ["Authorization: Bearer token"],
  "timeout": 30,
  "follow_redirects": true,
  "user_agent": "MyApp/1.0"
}

2. curl_post

Make HTTP POST requests with data.

Parameters:

  • url (string): The URL to make the POST request to

  • json_data (object, optional): JSON object to send as POST data

  • data (string, optional): Data to send in the POST request body

  • headers (array, optional): HTTP headers

  • content_type (string, optional): Content-Type header

  • timeout (number, optional): Request timeout in seconds

  • follow_redirects (boolean, optional): Whether to follow redirects

Example:

{
  "url": "https://api.example.com/data",
  "json_data": {"key": "value"},
  "headers": ["Content-Type: application/json"]
}

3. curl_put

Make HTTP PUT requests.

Parameters:

  • url (string): The URL to make the PUT request to

  • json_data (object, optional): JSON object to send as PUT data

  • data (string, optional): Data to send in the PUT request body

  • headers (array, optional): HTTP headers

  • content_type (string, optional): Content-Type header

  • timeout (number, optional): Request timeout in seconds

  • follow_redirects (boolean, optional): Whether to follow redirects

Example:

{
  "url": "https://api.example.com/data/123",
  "data": "raw data",
  "content_type": "text/plain"
}

4. curl_delete

Make HTTP DELETE requests.

Parameters:

  • url (string): The URL to make the DELETE request to

  • headers (array, optional): HTTP headers

  • timeout (number, optional): Request timeout in seconds

  • follow_redirects (boolean, optional): Whether to follow redirects

Example:

{
  "url": "https://api.example.com/data/123",
  "headers": ["Authorization: Bearer token"]
}

5. curl_download

Download files.

Parameters:

  • url (string): The URL of the file to download

  • output_filename (string, optional): Output filename

  • resume (boolean, optional): Resume partial download if file exists

  • timeout (number, optional): Request timeout in seconds

  • follow_redirects (boolean, optional): Whether to follow redirects

Example:

{
  "url": "https://example.com/file.zip",
  "output_filename": "downloaded_file.zip",
  "resume": true
}

6. curl_advanced

Execute curl with custom arguments (advanced users).

Parameters:

  • args (array): Array of curl arguments (excluding 'curl' itself)

Example:

{
  "args": ["-X", "PATCH", "-H", "Content-Type: application/json", "-d", "{\"status\":\"updated\"}", "https://api.example.com/items/1"]
}

Usage Examples

Make a GET request

{
  "tool": "curl_get",
  "url": "https://api.example.com/users",
  "headers": ["Authorization: Bearer your-token"]
}

POST JSON data

{
  "tool": "curl_post",
  "url": "https://api.example.com/users",
  "json_data": {
    "name": "John Doe",
    "email": "john@example.com"
  }
}

Download a file

{
  "tool": "curl_download",
  "url": "https://example.com/file.zip",
  "output_filename": "download.zip"
}

Development

Prerequisites

  • Node.js 18.0.0 or higher

  • npm package manager

  • curl command-line tool

Building

npm run build

Testing

Test the server manually:

echo '{"jsonrpc": "2.0", "id": 1, "method": "tools/list", "params": {}}' | node build/index.js

Run tests:

npm test

Linting

npm run lint
npm run lint:fix

Project Structure

mcp-curl/
├── src/
│   └── index.ts          # Main server implementation
├── build/
│   └── index.js          # Compiled JavaScript
├── test/
│   └── basic.test.js     # Basic functionality tests
├── examples/
│   └── test-server.js    # Example usage
├── .github/
│   └── workflows/
│       └── ci.yml        # CI/CD pipeline
├── package.json          # Project configuration
├── tsconfig.json         # TypeScript configuration
├── .eslintrc.json        # ESLint configuration
├── LICENSE               # MIT License
├── DEPLOYMENT.md         # Deployment guide
├── CONTRIBUTING.md       # Contribution guidelines
├── CHANGELOG.md          # Version history
└── README.md             # This file

Verification

Test that the server is working:

# Test the built server
node build/index.js

# Should show: "Curl MCP Server running on stdio"
# Press Ctrl+C to exit

Troubleshooting

Common Issues

  1. "Command not found" error

    • Ensure mcp-curl is installed globally: npm install -g @247arjun/mcp-curl

    • Or use npx: "command": "npx", "args": ["@247arjun/mcp-curl"]

  2. "Permission denied" error

    • Check file permissions: chmod +x build/index.js

    • Rebuild the project: npm run build

  3. MCP server not appearing in Claude

    • Verify JSON syntax in configuration file

    • Restart Claude Desktop completely

    • Check that the command path is correct

  4. "curl command not found"

    • Install curl on your system (usually pre-installed on macOS/Linux)

    • Windows users: Install via package manager or download from curl website

Debugging

Enable verbose logging by setting environment variable:

# For development
DEBUG=1 node build/index.js

# Test with sample input
echo '{"jsonrpc": "2.0", "method": "initialize", "params": {}}' | node build/index.js

Security Notes

  • Input validation and sanitization for all curl arguments

  • Restricted file operations in advanced mode

  • Safe subprocess execution using spawn instead of shell

  • No arbitrary shell command execution

  • Input validation with Zod schemas

Available Tools

6 tools
curl_advancedC

Execute curl with custom arguments (advanced usage)

ParametersJSON Schema
NameRequiredDescriptionDefault
argsYesArray of curl arguments (excluding 'curl' itself)

TDQS

C2.7/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. The description only states it executes curl with custom arguments, lacking details on permissions, error handling, output format, or side effects (e.g., whether it makes network calls, has rate limits, or requires authentication). This is inadequate for a tool that likely performs external operations.

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 with a single sentence that directly states the tool's function. It is front-loaded and wastes no words, making it easy to parse quickly.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness2/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the complexity of executing curl commands (which can involve network operations, various arguments, and potential side effects), the description is incomplete. With no annotations, no output schema, and minimal behavioral details, it fails to provide sufficient context for safe and effective use, especially compared to more specific sibling tools.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The schema description coverage is 100%, with the single parameter 'args' documented as 'Array of curl arguments (excluding 'curl' itself)'. The description adds minimal value beyond this, only implying that arguments are custom and for advanced usage, without explaining syntax or examples. Baseline 3 is appropriate since the schema does the heavy lifting.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose3/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description 'Execute curl with custom arguments (advanced usage)' states the action (execute curl) and resource (custom arguments), but is vague about what 'advanced usage' entails. It doesn't clearly distinguish this tool from its siblings like curl_get or curl_post, which likely handle specific HTTP methods, while this one appears to be a generic wrapper.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines2/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description provides no guidance on when to use this tool versus alternatives. It mentions 'advanced usage' but doesn't specify what makes it advanced or when it's preferred over the sibling tools (curl_get, curl_post, etc.). There are no explicit when/when-not instructions or named alternatives.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

curl_deleteC

Make an HTTP DELETE request using curl

ParametersJSON Schema
NameRequiredDescriptionDefault
follow_redirectsNoWhether to follow redirects
headersNoOptional HTTP headers in the format 'Header: Value'
timeoutNoRequest timeout in seconds
urlYesThe URL to make the DELETE request to

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 the full burden of behavioral disclosure but only states the basic action. It doesn't mention potential side effects (e.g., resource deletion), error handling, rate limits, or authentication requirements, which are critical for a destructive operation like DELETE. This leaves significant gaps in understanding the tool's behavior.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single, direct sentence with zero waste—it states exactly what the tool does without unnecessary words. It's appropriately sized and front-loaded, 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.

Completeness2/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the complexity of an HTTP DELETE operation (a potentially destructive action) and the lack of annotations and output schema, the description is incomplete. It fails to address key aspects like what the tool returns, error conditions, or safety considerations, which are essential for proper tool invocation in this context.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The schema description coverage is 100%, so all parameters are documented in the schema. The description adds no additional meaning about parameters beyond what the schema provides, such as examples or constraints. This meets the baseline for high schema coverage but doesn't enhance parameter understanding.

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 ('Make an HTTP DELETE request') and the method ('using curl'), which is specific and unambiguous. However, it doesn't distinguish this tool from its sibling tools (curl_get, curl_post, etc.) beyond the HTTP method, missing explicit differentiation.

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 curl_advanced or other HTTP method-specific tools. It lacks context about scenarios where DELETE is appropriate or prerequisites such as authentication needs, leaving the agent to infer usage from the name alone.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

curl_downloadC

Download a file using curl

ParametersJSON Schema
NameRequiredDescriptionDefault
follow_redirectsNoWhether to follow redirects
output_filenameNoOutput filename (if not provided, will use remote filename)
resumeNoResume partial download if file exists
timeoutNoRequest timeout in seconds
urlYesThe URL of the file to download

TDQS

C2.7/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. 'Download a file using curl' implies a read operation, but it doesn't specify authentication needs, rate limits, error handling, or what happens on failure (e.g., partial downloads). It mentions curl but doesn't explain curl-specific behaviors like default options or security implications.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single, efficient sentence with no wasted words. It's front-loaded with the core action and method, making it easy to parse quickly. Every word earns its place by conveying essential information.

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 5 parameters, no annotations, and no output schema, the description is incomplete. It doesn't explain return values, error cases, or behavioral nuances like how output_filename interacts with remote filenames. Given the complexity and lack of structured data, more context is needed for effective use.

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 fully documents all 5 parameters. The description adds no parameter-specific information beyond what's in the schema, such as examples or constraints. With high schema coverage, the baseline is 3, as the description doesn't compensate but also doesn't detract.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose3/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description 'Download a file using curl' clearly states the action (download) and resource (file), but it's vague about scope and doesn't differentiate from sibling tools like curl_get or curl_advanced. It specifies the method (curl) but lacks details about what kind of files or protocols are supported.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines2/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

No guidance is provided on when to use this tool versus alternatives like curl_get or curl_advanced. The description doesn't mention prerequisites, exclusions, or specific contexts for use, leaving the agent to infer usage from the tool name alone.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

curl_getC

Make an HTTP GET request using curl

ParametersJSON Schema
NameRequiredDescriptionDefault
follow_redirectsNoWhether to follow redirects
headersNoOptional HTTP headers in the format 'Header: Value'
timeoutNoRequest timeout in seconds
urlYesThe URL to make the GET request to
user_agentNoCustom User-Agent string

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 the full burden of behavioral disclosure. It mentions the action but fails to describe key traits like error handling, response format, authentication needs, or rate limits. This leaves significant gaps for an agent to understand how the tool behaves beyond the basic operation.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single, clear sentence that efficiently conveys the core purpose without unnecessary words. It is front-loaded and appropriately sized, making it easy to parse quickly.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness2/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the complexity of HTTP requests and the lack of annotations and output schema, the description is incomplete. It doesn't cover behavioral aspects like error handling or response details, which are crucial for an agent to use the tool effectively in varied contexts.

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%, so the schema fully documents all parameters. The description adds no additional meaning beyond what the schema provides, such as examples or context for parameter use. This meets the baseline for high schema coverage but doesn't enhance understanding.

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 ('Make an HTTP GET request') and the method ('using curl'), which is specific and unambiguous. However, it doesn't distinguish this tool from its sibling tools like curl_post or curl_put beyond the HTTP method, missing explicit differentiation.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines2/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description provides no guidance on when to use this tool versus alternatives, such as curl_advanced or other sibling tools. It lacks context about scenarios where a GET request is appropriate or when other methods might be better, offering no usage instructions.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

curl_postC

Make an HTTP POST request using curl

ParametersJSON Schema
NameRequiredDescriptionDefault
content_typeNoContent-Type header (will be added automatically for JSON data)
dataNoData to send in the POST request body
follow_redirectsNoWhether to follow redirects
headersNoOptional HTTP headers in the format 'Header: Value'
json_dataNoJSON object to send as POST data
timeoutNoRequest timeout in seconds
urlYesThe URL to make the POST request to

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 but only states the basic action without disclosing behavioral traits. It doesn't mention error handling, authentication needs, rate limits, what happens with redirects (though the parameter hints at this), or response format expectations. For a tool with 7 parameters and no annotation coverage, this is a significant gap in behavioral context.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single, efficient sentence that directly states the tool's purpose with zero wasted words. It's appropriately sized and front-loaded, making it easy for an agent to quickly understand the core functionality without unnecessary elaboration.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness2/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the tool's complexity (7 parameters, no output schema, no annotations), the description is insufficiently complete. It doesn't address what the tool returns (no output schema means the description should hint at response format), error conditions, or practical usage scenarios. For a general-purpose HTTP tool with multiple configuration options, more context is needed to help the agent use it effectively.

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%, providing detailed parameter documentation. The description adds no additional parameter semantics beyond what's in the schema (e.g., it doesn't explain relationships between parameters like data vs json_data, or provide usage examples). With high schema coverage, the baseline of 3 is appropriate as the description doesn't compensate but doesn't need to given the comprehensive schema.

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 'Make an HTTP POST request using curl' clearly states the action (POST request) and technology (curl), providing a specific verb+resource combination. However, it doesn't differentiate from sibling tools like curl_put or curl_get, which would require mentioning it's specifically for POST method requests versus other HTTP methods.

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 curl_put or curl_get. There's no mention of POST-specific use cases (e.g., submitting form data, creating resources) or when other methods might be more appropriate, leaving the agent without contextual usage instructions.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

curl_putC

Make an HTTP PUT request using curl

ParametersJSON Schema
NameRequiredDescriptionDefault
content_typeNoContent-Type header (will be added automatically for JSON data)
dataNoData to send in the PUT request body
follow_redirectsNoWhether to follow redirects
headersNoOptional HTTP headers in the format 'Header: Value'
json_dataNoJSON object to send as PUT data
timeoutNoRequest timeout in seconds
urlYesThe URL to make the PUT request to

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 the full burden of behavioral disclosure. It mentions the basic action but fails to describe critical traits like error handling, authentication needs, rate limits, or what the response might contain. This is inadequate for a tool that performs HTTP operations with multiple parameters.

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 directly states the tool's purpose without any fluff. It's appropriately sized and front-loaded, 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.

Completeness2/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the tool's complexity (7 parameters, no annotations, no output schema), the description is insufficient. It doesn't explain return values, error conditions, or behavioral nuances, leaving significant gaps for an agent to understand how to use the tool effectively beyond basic syntax.

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%, so the schema fully documents all 7 parameters. The description adds no additional meaning beyond what's in the schema, such as explaining parameter interactions (e.g., data vs. json_data). This meets the baseline for high schema coverage.

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 ('Make an HTTP PUT request') and the method ('using curl'), which is specific and unambiguous. However, it doesn't differentiate from sibling tools like curl_post or curl_delete, which would require mentioning the HTTP method specificity.

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 curl_post or curl_advanced. It lacks context about typical PUT use cases (e.g., updating resources) or prerequisites, leaving the agent to infer usage from the tool name alone.

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. Dates show when Glama detected each change.

  1. 6 tool updatesv1.0.0
    • First observedcurl_advanced
    • First observedcurl_delete
    • First observedcurl_download
    • First observedcurl_get
    • First observedcurl_post
    • First observedcurl_put
Install Server
RayrunBuild, deploy, and operate MCP servers without becoming an infrastructure team.ray.runAd

TDQS

A3.5/5.0
Disambiguation5/5

Each tool has a clearly distinct purpose based on HTTP methods or specific actions: curl_get, curl_post, curl_put, and curl_delete cover standard HTTP operations, curl_download is for file downloads, and curl_advanced handles custom arguments. There is no overlap or ambiguity between these tools.

Naming Consistency5/5

All tool names follow a consistent 'curl_' prefix with a descriptive suffix (e.g., get, post, download, advanced), using snake_case uniformly. This pattern is predictable and easy to understand across the entire set.

Tool Count5/5

With 6 tools, this server is well-scoped for its purpose of executing curl commands. It covers essential HTTP methods (GET, POST, PUT, DELETE), a file download function, and an advanced custom option, providing a complete yet manageable set without unnecessary bloat.

Completeness5/5

The tool set offers complete coverage for the domain of curl-based HTTP operations: it includes all major HTTP methods (GET, POST, PUT, DELETE), a dedicated download tool, and an advanced tool for custom use cases. There are no obvious gaps, and agents can handle typical HTTP workflows effectively.

Maintenance

ActivityInactive
ResponsivenessSyncing

Resources

Unclaimed servers have limited discoverability.

Looking for Admin?

If you are the server author, to access and configure the admin panel.

Related MCP Connectors

Related MCP Servers

Appeared in Searches

Latest Blog Posts

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/247arjun/mcp-curl'

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