Anirbanbasu Pymcp

Primarily to be used as a template repository for developing MCP servers with FastMCP in Python, PyMCP is somewhat inspired by the official everything MCP server in Typescript.

Components

The following components are available on this MCP server.

Tools

1. greet

• Greets the caller with a quintessential Hello World message.
• Input(s)
  • name: string (optional): The name to greet. Default value is none.
• Output(s)
  • TextContent with a UTC time-stamped greeting.

2. generate_password

• Generates a random password with specified length, optionally including special characters and conforming to the complexity requirements of at least one lowercase letter, one uppercase letter, and two digits. If special characters are included, it will also contain at least one such character.
• Input(s)
  • length: integer: The length of the generated password. The value must be an integer between 8 and 64, both inclusive.
  • use_special_chars: boolean (optional): A flag to indicate whether the password should include special characters. Default value is False.
• Output(s)
  • TextContent with the generated password.

3. text_web_search

• Searches the web with a text query using the Dux Distributed Global Search (DDGS).
• Input(s)
  • query: string: The search query to fetch results for. It should be a non-empty string.
  • region: string (optional): Two letter country code followed by a hyphen and then by two letter language code, e.g., uk-en or us-en. Default value is uk-en.
  • max_results: integer (optional): Optional maximum number of results to be fetched. Default value is 10.
  • pages: integer (optional): Optional number of pages to spread the results over. Default value is 1.
• Environment variable(s)
  • DDGS_PROXY: string (optional): Optional proxy server to use for egress web search requests.
• Output(s)
  • TextContent with a list of dictionaries with search results.

4. permutations

• Calculates the number of ways to choose $k$ items from $n$ items without repetition and with order. If $k$ is not provided, it defaults to $n$.
• Input(s)
  • n: integer: The number of items to choose from. This should be a non-zero, positive integer.
  • k: integer (optional): The number of items to choose. Default value is the value of n.
• Output(s)
  • TextContent with number of ways to choose $k$ items from $n$, essentially ${}^{n}P_{k}$.

5. run_python_code

• Runs arbitrary Python code in a secure and fast interpreter using Pydantic Monty. Note that Pydantic Monty is experimental and Python language support is partial as of February 8, 2026.
• Input(s)
  • code: string: The Python code to run.
  • inputs: dict[str, Any] (optional): A dictionary of input values for the Python code. Default value is None.
  • script_name: str (optional): The name of the script used in traceback and error messages. Default value is main.py.
  • check_types: bool (optional): A flag to indicate whether to check types. Default value is True.
  • type_definitions: str (optional): Type definitions to be used for type checking. Default value is None.
• Output(s)
  • TextContent with the output, if any, of the Python code.

[!NOTE] The pirate_summary (LLM client sampling) and vonmises_random (client elicitation) example tools have been removed. Both relied on server-initiated requests (ctx.sample() and ctx.elicit()), which SEP-2577 removed from the modern MCP protocol (2026-07-28) in favour of a stateless per-request envelope with no back-channel for the server to call back into the client. FastMCP now marks both APIs deprecated — they still function, but only on the older, handshake-era (session-based) protocol. These tools were dropped rather than kept working against a deprecated protocol era.

This does not affect the tools, resources, and prompts that remain: the underlying MCP SDK negotiates the protocol version per connection and serves both 2026-07-28+ and handshake-era clients automatically, with no code changes needed here. Only server-initiated back-channel patterns (i.e., anything using ctx.sample() or ctx.elicit()) are legacy-only. If you fork this template and want to add a tool that relies on client sampling or elicitation, be aware it will only work against clients that negotiate the older, deprecated protocol.

Resources

1. resource_logo

• Retrieves the Base64 encoded PNG logo of PyMCP along with its SHA3-512 hash.
• URL: data://logo
• Output(s)
  • TextContent with a Base64EncodedBinaryDataResponse Pydantic object with the following fields.
    • data: string: The Base64 encoded PNG logo of PyMCP.
    • hash: string: The hexadecimal encoded cryptographic hash of the raw binary data, which is represented by its Base64 encoded string equivalent in data. (The hex encoded hash value is expected to be 6414b58d9e44336c2629846172ec5c4008477a9c94fa572d3419c723a8b30eb4c0e2909b151fa13420aaa6a2596555b29834ac9b2baab38919c87dada7a6ef14.)
    • hash_algorithm: string: The cryptographic hash algorithm used, e.g., sha3_512.

2. resource_logo_svg

• Retrieves the SVG logo of PyMCP.
• URL: data://logo_svg
• Output(s)
  • TextContent with a the SVG data for the PyMCP logo.

3. resource_unicode_modulo10

• Computes the modulus 10 of a given number and returns a Unicode character representing the result. The character is chosen based on whether the modulus is odd or even. For odd modulus, it uses the Unicode characters ❶ (U+2776), ❸ (U+2778), ❺ (U+277A), ❼ (U+277C), and ❾ (U+277E). For even modulus, it uses the Unicode characters ⓪ (U+24EA), ② (U+2461), ④ (U+2463), ⑥ (U+2465), and ⑧ (U+2467).
• URL: data://modulo10/{number}
• Input(s)
  • number: integer: A positive integer between 1 and 1000, both inclusive.
• Output(s)
  • TextContent with a string representing the correct Unicode character.

Prompts

1. code_prompt

• Get a prompt to write a code snippet in Python based on the specified task..
• Input(s)
  • task: string: The description of the task for which a code implementation prompt will be generated.
• Output(s)
  • str representing the prompt.

Installation

The directory where you clone this repository will be referred to as the working directory or WD hereinafter.

Install uv. Install just. To install the project with its minimal dependencies in a virtual environment, run the following in the WD. To install all non-essential dependencies (which are required for developing and testing), replace the install target with the install-all target in the following command.

just install

Environment variables

The following environment variables can be configured.

• PYMCP_LOG_LEVEL: Sets the Python log level for the PyMCP server. Default is INFO.
• MCP_SERVER_TRANSPORT: Sets the FastMCP server transport type of this MCP server. Default is stdio.
• RESPONSE_CACHE_TTL: Sets the time, in seconds, for the time-to-live (TTL) cache that can be activated for caching prompt, resource and tool responses from the server. Default value is 30. Any integer value between 0 and 86400 (i.e., one day), both inclusive, is valid. Setting it to 0 effectively disables response caching.
• FASTMCP_HOST: Sets the host address for the FastMCP server when using network transports (e.g., streamable-http, sse). Default is localhost.
• FASTMCP_PORT: Sets the port number for the FastMCP server when using network transports. Default is 8000.
• ASGI_CORS_ALLOWED_ORIGINS: Sets the CORS allowed origins when the MCP server is started with a transport over HTTP. Default is ["*"].

Standalone usage

PyMCP can be started standalone as a MCP server with stdio transport by running the following. Alternatively, it can be started using streamable-http or sse transports by specifying the transport type using the MCP_SERVER_TRANSPORT environment variable.

uv run pymcp

Test with the MCP Inspector

The MCP Inspector is an official Model Context Protocol tool that can be used by developers to test and debug MCP servers. This is the most comprehensive way to explore the MCP server.

To use it, you must have Node.js installed. The best way to install and manage node as well as packages such as the MCP Inspector is to use the Node Version Manager (or, nvm). Once you have nvm installed, you can install and use the latest Long Term Release version of node by executing the following.

nvm install --lts
nvm use --lts

Following that, run the MCP Inspector and PyMCP by executing the following in the WD.

npx @modelcontextprotocol/inspector uv run pymcp

This will create a local URL at port 6274 with an authentication token, which you can copy and browse to on your browser. Once on the MCP Inspector UI, press Connect to connect to the MCP server. Thereafter, you can explore the tools available on the server.

You can, alternatively, launch the MCP inspector by running just launch-inspector.

Use it with Claude Desktop, Visual Studio, and so on

The server entry to run with stdio transport that you can use with systems such as Claude Desktop, Visual Studio Code, and so on is as follows.

{
    "command": "uv",
    "args": [
        "run",
        "pymcp"
    ]
}

Instead of having pymcp as the last item in the list of args, you may need to specify the full path to the script, e.g., WD/.venv/bin/pymcp.

Remotely hosted options

The currently available remotely hosted options are as follows.

• FastMCP Cloud: https://pymcp-template.fastmcp.app/mcp
• Glama.AI: https://glama.ai/mcp/servers/@anirbanbasu/pymcp

Testing and coverage

To run the provided set of tests using pytest, execute the following in WD. To get a report on coverage while invoking the tests, run the following in WD.

just test-coverage

This will generate something like the following output.

Name    Stmts   Miss    Cover   Missing
---------------------------------------
TOTAL     214      0  100.00%

Contributing

See the Contributing guide.

License

MIT.