simple_mcp
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., "@simple_mcpGenerate a random float between 0 and 1."
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.
# Simple MCP Server (Python)
This project provides a minimal Model Context Protocol (MCP) server using Python. It exposes a single tool random_float that returns a random float in [0,1). The server supports multiple transport modes: STDIO (default), HTTP, and SSE.
Run locally
Default (STDIO transport)
uv run main.pyRelated MCP server: Server MCP
Server Environment Variables
Variable | Purpose | Default |
APP_TRANSPORT | Transport type (STDIO, HTTP, SSE) | STDIO |
APP_HOST | Server host | 0.0.0.0 |
APP_PORT | Server port | 8000 |
Docker
Build the image and run:
docker build -t simple-mcp .Docker with different transports
# HTTP transport
docker run --rm -p 8000:8000 -e APP_TRANSPORT=HTTP simple-mcp
# SSE transport
docker run --rm -p 8000:8000 -e APP_TRANSPORT=SSE simple-mcp
# Custom port
docker run --rm -p 9000:9000 -e APP_TRANSPORT=HTTP -e APP_PORT=9000 simple-mcpTest as a standalone app
Test using Postman
uv --directory <path_to_project_directory> run main.pyTest using Claude Desktop
{
"mcpServers": {
"simple_mcp": {
"command": "uv",
"args": [
"run",
"--directory",
"<path_to_project_directory>",
"main.py"
]
}
}
}Test as a docker image
Test using Postman
docker run --rm -i simple-mcpTest using Claude Desktop
{
"mcpServers": {
"simple_mcp": {
"command": "docker",
"args": [
"run",
"--rm",
"-i",
"simple-mcp"
]
}
}
}Available Tools
2 toolsrandom_floatA
Return a random float in [0,1).
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Output Schema
| Name | Required | Description |
|---|---|---|
| result | Yes |
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 explaining behavior. It clearly states the stochastic nature ('random') and the return interval '[0,1)' though it does not explicitly mention uniformity or other implementation details. This is adequate for a simple, stateless utility.
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?
A single, concise sentence is used—'Return a random float in [0,1).' It is front-loaded, contains no filler or redundant wording, and is exactly as long as needed.
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 zero-parameter tool with an output schema, the description fully specifies the result with no ambiguities. The interval is explicit, and no additional side effects or requirements exist. It is complete for the tool's complexity.
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?
There are zero parameters, so the input schema has no descriptive gaps. The rubric establishes a baseline of 4 for zero-parameter tools, and the description adds no needed semantics beyond what is obvious.
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 uses a specific verb ('Return') and a clear resource ('a random float') with an exact range ('[0,1)'). It fully distinguishes the tool's purpose from the sibling tool 'wait', leaving no ambiguity.
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 does not explicitly state when to use this tool or mention alternatives. However, the usage is implied by the purpose: use it when a random float in [0,1) is needed. No formal guidance is provided.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
waitA
Wait for the specified time in milliseconds and return a message.
| Name | Required | Description | Default |
|---|---|---|---|
| ms | Yes |
Output Schema
| Name | Required | Description |
|---|---|---|
| result | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the transparency burden. It clearly states that the tool waits for the specified time and returns a message, which is the core behavior. However, it does not disclose details such as whether the operation is synchronous, potential error conditions, or the exact content of the returned message.
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, front-loaded sentence that conveys the essential purpose without any fluff. It is concise and well-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 such a simple tool with one parameter and an output schema, the description is largely complete. It explains the action and the return of a message. It does not detail the message content, but the output schema likely covers that. Minor gaps are acceptable given the simplicity.
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 description explicitly clarifies that the parameter is in milliseconds, which adds meaning beyond the schema's property name and type. This is particularly helpful given the schema description coverage is 0%.
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 'Wait' and the resource 'specified time in milliseconds', and specifies that it returns a message. It is specific and distinguishes itself from the sibling tool 'random_float', which has a completely different purpose.
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, nor any preconditions or exclusions. It only states what the tool does without contextualizing it.
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.
2 tool updates
v0.1.0- First observed
random_float - First observed
wait
TDQS
Scored across 2 tools
The two tools, random_float and wait, have completely distinct purposes—one generates a random number and the other introduces a delay. There is no ambiguity whatsoever.
Both names are in lowercase snake_case, but random_float is a noun phrase while wait is a verb, creating a minor inconsistency in style. However, with only two tools, the names are clear and identifiable, so the deviation is negligible.
The server exposes only two tools, which feels thin for a general-purpose utility server. However, the scope itself is extremely narrow (random number and delay), so the count is borderline—not excessive, but minimal for broader use cases.
The domain appears to be basic utility operations, but with only two tools, there are obvious gaps such as random integer generation or more granular timing controls. The surface is too minimal to consider it complete for any meaningful utility purpose.
Maintenance
Related MCP Connectors
16 AI-native tools with dual SSE + streamable-http transport. Free tier available.
AI Reasoning Cache & Consensus Layer with 11 MCP tools via Streamable HTTP.
AI-callable tools for API mocking, testing, monitoring, security, and automation.
Exact hashing, base64/hex/URL encoding, JWT decoding and UUIDs for AI agents. No auth required.
Related MCP Servers
- FlicenseDqualityDmaintenanceProvides basic mathematical operations (addition, subtraction, multiplication, division) through a calculate tool. Supports both stdio and HTTP/SSE transport modes.110 npm-
- FlicenseNot gradedqualityDmaintenanceProvides math and weather tools accessible via LangGraph agent using MCP protocol with stdio and streamable HTTP transports.1-
- AlicenseNot gradedqualityCmaintenanceA zero-dependency Python framework for building Model Context Protocol servers using a simple @tool decorator, with support for stdio and SSE transports.MIT
- FlicenseNot gradedqualityCmaintenanceExposes local Python tools via a persistent Streamable HTTP endpoint, allowing an OpenAI Agents SDK notebook to discover and invoke them while using Groq for reasoning and tool selection.-