The aleostudio MCP Server is a lightweight Python server that provides AI agents with utility tools through the Model Context Protocol (MCP).
Available Tools:
calculate - Perform basic mathematical operations (add, subtract, multiply, divide, power)
get_datetime - Retrieve current date/time with configurable timezone offsets (UTC -12 to +14) and multiple output formats (ISO, human-readable, Unix timestamp, components)
process_text - Analyze and manipulate text with operations including word/character counting, case conversion (uppercase, lowercase, title case, reverse), email/URL extraction, and statistics summaries
fetch_url - Execute HTTP GET/HEAD requests to retrieve content, headers, and status codes from URLs
convert_data - Convert data between formats including JSON, Base64, and Hexadecimal
Deployment Options:
STDIO mode for local integration (e.g., Claude Desktop)
SSE mode for remote agent access via HTTP
Extensible architecture for creating custom tools following the provided template
Compatible with Python 3.11+ with VSCode debugging support and MCP Inspector testing
Click on "Install 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., "@aleostudio MCP Server calculate 125 multiplied by 8"
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.
A fast and lightweight MCP server with different tools for AI agents. It supports STDIO (Claude Desktop) and SSE (remote agents).
Related MCP server: Python FastMCP Server
Python >= 3.11
uv and pip installed
Init virtualenv and install dependencies with:
uv venv
source .venv/bin/activate
uv syncCreate your .env file by copying:
cp env.dist .envThen, customize it if needed.
First of all, to test the server, install and run a MCP Inspector with:
npx @modelcontextprotocol/inspector uv run python -m app.mainAt the end, a UI will open in your browser. Connect to the server by clicking Connect on the left menu.
Then, from the top bar, click on Tools and List tools. At this point you can choose you preferred tools and play with it.
If you want to test it without the inspector, simply launch with:
uv run python -m app.mainIf you want to use the server through SSE from remote agents, launch it with:
uv run python -m app.main --sse --port 8000As the STDIO mode, you can test it with MCP Inspector (remote) with:
npx @modelcontextprotocol/inspectorIf you want to simulate a tool call from a remote agent, create a simple STDIO client in python (e.g. stdio_test.py) with this code:
import asyncio
from mcp import ClientSession, StdioServerParameters
from mcp.client.stdio import stdio_client
async def test():
server_params = StdioServerParameters(command="uv", args=["run", "python", "server.py"], cwd="./")
async with stdio_client(server_params) as (read, write):
async with ClientSession(read, write) as session:
await session.initialize()
# Tools list
tools = await session.list_tools()
print("Tools:", [t.name for t in tools.tools])
# Call calculate
result = await session.call_tool("calculate", { "operation": "multiply", "a": 6, "b": 7 })
print("Result:", result.content)
asyncio.run(test())Then run with:
python3 stdio_test.pyYou will see a the available tools list and the result of calculate.
If you want to use tools on Claude Desktop, create the file claude_desktop_config.json with this content:
{
"mcpServers": {
"mcp-server-tools": {
"command": "uv",
"args": ["run", "--directory", "/path/to/mcp-server", "python", "-m", "app.main"]
}
}
}Move this file in:
macOS: ~/Library/Application Support/Claude
Windows: %APPDATA%\Claude
Tool | Descrizione |
| Math operations (add, subtract, multiply, divide, power) |
| Date/hour with timezone and configurable format |
| Text handler (word count, extract email/URL, stats) |
| HTTP GET/HEAD requests |
| JSON, Base64, Hex conversions |
To create new tool you need to:
Create a new file (e.g. app/tools/my_new_tool.py)
Write your logic keeping this structure:
from app.mcp import mcp
@mcp.tool()
def my_new_tool(your_param: str) -> dict[str, Any]:
"""
Clear and exaustive tool description.
Args:
your_param: clear and exaustive param description
Returns:
Clear and exaustive result description
"""
# YOUR LOGIC HERE
if some_error:
return {"success": False, "error": "Clear error description"}
return {
"success": True,
"your_resp": "...",
"other_resp": "...",
}Edit app/tools/__init__.py file and add your tool:
from app.tools import my_new_tool
__all__ = [
"my_new_tool",
]Restart your server
In the same way, if you want to delete an existing tool, simply delete it from __init__.py and delete the related .py file.
To debug your Python microservice you need to:
Install VSCode
Ensure you have Python extension installed
Ensure you have selected the right interpreter with virtualenv on VSCode
Click on Run and Debug menu and create a launch.json file
From dropdown, select Python debugger and FastAPI
Change the .vscode/launch.json created in the project root with this (customizing host and port if changed):
{
"version": "0.2.0",
"configurations": [
{
"name": "MCP Server (SSE)",
"type": "debugpy",
"request": "launch",
"module": "app.main",
"args": [
"--sse",
"--port", "8000",
"--reload"
],
"envFile": "${workspaceFolder}/.env",
"console": "integratedTerminal",
"cwd": "${workspaceFolder}",
"justMyCode": true
},
{
"name": "MCP Server (STDIO)",
"type": "debugpy",
"request": "launch",
"module": "app.main",
"args": [
"--reload"
],
"envFile": "${workspaceFolder}/.env",
"console": "integratedTerminal",
"cwd": "${workspaceFolder}",
"justMyCode": true
}
]
}Put some breakpoint in the code, then press the green play button
Call the API to debug
Made with ♥️ by Alessandro Orrù
Execute basic math operation.
Args:
operation: operation to execute (add, subtract, multiply, divide, power)
a: first operand
b: second operand
Returns:
Operation result with details
| Name | Required | Description | Default |
|---|---|---|---|
| operation | Yes | ||
| a | Yes | ||
| b | Yes |
| Name | Required | Description |
|---|---|---|
No output parameters | ||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries full burden. It mentions 'Returns: Operation result with details' which gives some behavioral context about output, but doesn't cover important aspects like error handling (e.g., division by zero), precision limitations, rate limits, or authentication requirements for a calculation service.
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 well-structured with clear sections (Args, Returns) and front-loaded purpose statement. Every sentence earns its place, though the 'Returns' statement could be slightly more specific about what 'details' includes.
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 moderate complexity (3 parameters, basic math operations) and the presence of an output schema (which should document return values), the description is reasonably complete for core functionality. However, it lacks important context about error cases, limitations, and behavioral expectations that would be needed for robust 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?
With 0% schema description coverage, the description adds significant value by documenting all three parameters with clear semantics: operation types (add, subtract, multiply, divide, power) and operand roles (first and second). This fully compensates for the schema's lack of descriptions, though it doesn't provide format details like whether 'power' means exponentiation.
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 as 'Execute basic math operation' with specific operations listed in the Args section. It distinguishes itself from sibling tools like convert_data or process_text by focusing on mathematical calculations. However, it doesn't explicitly differentiate from potential mathematical siblings that might not exist in this set.
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. While the sibling tools have different domains (data conversion, URL fetching, datetime operations, text processing), there's no explicit comparison or context about when mathematical calculation is appropriate versus other operations.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Convert data in different formats.
Args:
data: data to convert
from_format: source format (json, base64, hex)
to_format: destination format (json, base64, hex)
Returns:
Converted data
| Name | Required | Description | Default |
|---|---|---|---|
| data | Yes | ||
| from_format | Yes | ||
| to_format | Yes |
| Name | Required | Description |
|---|---|---|
No output parameters | ||
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. It mentions conversion behavior but lacks details on error handling (e.g., invalid formats), performance characteristics, or side effects. The description is minimal and doesn't compensate for the absence of annotations, leaving behavioral traits unclear.
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 sized and front-loaded: it starts with the core purpose, then lists args and returns in a structured format. Every sentence earns its place without redundancy, making it efficient and easy to parse.
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 moderate complexity (3 parameters, no annotations, but with an output schema), the description is partially complete. It covers the purpose and parameters adequately, and the output schema handles return values, but it lacks usage guidelines and behavioral details. For a conversion tool with no annotations, more context on errors or limitations would improve completeness.
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 adds significant meaning beyond the input schema, which has 0% description coverage. It explains each parameter's purpose ('data to convert', 'source format', 'destination format') and lists valid format options (json, base64, hex). This compensates well for the schema's lack of descriptions, though it doesn't detail format-specific requirements or constraints.
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: 'Convert data in different formats.' This specifies the verb ('convert') and resource ('data'), though it doesn't explicitly distinguish from sibling tools like 'process_text' which might also handle data transformation. The purpose is clear but lacks sibling differentiation.
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 like 'process_text' or other siblings. It lists parameters and returns but offers no context about appropriate use cases, prerequisites, or exclusions. Usage is implied through parameter descriptions but not explicitly stated.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Execute HTTP requests to external URLs.
Args:
url: URL to fetch
method: HTTP method (GET, HEAD)
Returns:
Status code, headers and content (truncated if too long)
| Name | Required | Description | Default |
|---|---|---|---|
| url | Yes | ||
| method | No | GET |
| Name | Required | Description |
|---|---|---|
No output parameters | ||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries full burden and does well by disclosing key behavioral traits: it specifies supported HTTP methods (GET, HEAD), mentions content truncation behavior, and describes the return format (status code, headers, content). It doesn't cover rate limits, authentication needs, or error handling, but provides solid foundational information.
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 perfectly structured with a clear purpose statement followed by organized Args and Returns sections. Every sentence earns its place, with zero wasted words. The information is front-loaded and efficiently presented in just four lines.
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 moderate complexity (HTTP client), no annotations, and the presence of an output schema, the description provides good coverage of purpose, parameters, and return behavior. It could benefit from mentioning security considerations or error scenarios, but covers the essential operational aspects adequately.
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?
With 0% schema description coverage, the description compensates well by explaining both parameters: 'url' as 'URL to fetch' and 'method' as 'HTTP method (GET, HEAD)' with the default value implied. It adds meaningful context beyond the bare schema, though it could specify URL format requirements or method constraints more explicitly.
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 ('Execute HTTP requests') and target resource ('to external URLs'), distinguishing it from sibling tools like calculate or process_text. It uses precise technical terminology that leaves no ambiguity about the tool's function.
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 'external URLs' and HTTP methods, suggesting this is for web requests rather than internal operations. However, it provides no explicit guidance on when to use this tool versus alternatives or any prerequisites for usage.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Get current date/time with configurable format.
Args:
timezone_offset: UTC offset in hours (-12 +14)
format_type: output format (iso, human, unix, components)
Returns:
Date/time in the required format
| Name | Required | Description | Default |
|---|---|---|---|
| timezone_offset | No | ||
| format_type | No | iso |
| Name | Required | Description |
|---|---|---|
No output parameters | ||
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 explains the tool returns current date/time with configurable format, which covers the basic behavior, but doesn't mention performance characteristics, error conditions, or whether it requires external resources. The description doesn't contradict annotations since none exist.
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 well-structured with clear sections for Args and Returns, and every sentence serves a purpose. It could be slightly more concise by combining some elements, but overall it's efficient and front-loaded with the core functionality.
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 moderate complexity, no annotations, and the presence of an output schema (which handles return value documentation), the description provides adequate context. It explains parameters thoroughly and states the return purpose, though it could benefit from more behavioral context about edge cases or limitations.
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 adds significant value beyond the input schema, which has 0% description coverage. It explains what 'timezone_offset' represents (UTC offset in hours with valid range) and what 'format_type' controls (output format with specific options like iso, human, unix, components), providing crucial semantic context that the schema alone lacks.
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 with a specific verb ('Get') and resource ('current date/time'), plus it distinguishes its functionality from siblings by specifying configurable format options. It goes beyond a simple tautology by explaining what the tool actually does.
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 like 'calculate' or other siblings. It mentions configurable format but doesn't specify scenarios where one format would be preferred over another or when this tool is appropriate compared to other date/time operations.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Handle text with various operations.
Args:
text: text to handle
operation: action to perform (word_count, char_count, reverse, uppercase, lowercase, title_case, extract_emails, extract_urls, summarize_stats)
options: additional options for specific operations
Returns:
Operation result
| Name | Required | Description | Default |
|---|---|---|---|
| text | Yes | ||
| operation | Yes | ||
| options | No |
| Name | Required | Description |
|---|---|---|
No output parameters | ||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries full burden. It mentions 'various operations' and lists them in the Args section, but doesn't disclose behavioral traits like whether operations are read-only or mutating, performance characteristics, error handling, or rate limits. The description is minimal and lacks important behavioral context for a tool with multiple operations.
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 sized and well-structured with clear sections (Args, Returns). The first sentence is front-loaded with the main purpose. However, the 'Args' section could be more integrated with the description rather than appearing as separate documentation, and the 'Handle text with various operations' opening is somewhat generic.
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 3 parameters with 0% schema description coverage but an output schema exists, the description provides adequate parameter information but lacks behavioral context. The existence of an output schema means return values don't need explanation, but for a tool with multiple operations and no annotations, more guidance about operation selection and behavioral characteristics would improve completeness.
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 provides significant parameter semantics beyond the schema. While schema description coverage is 0%, the Args section explicitly lists all 9 possible operations for the 'operation' parameter and explains the purpose of 'text' and 'options' parameters. This compensates well for the lack of schema descriptions, though it doesn't detail what 'options' might contain for specific operations.
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 states 'Handle text with various operations' which provides a general purpose but is vague about what specific operations are available. It mentions 'text' as the resource but doesn't clearly distinguish this tool from potential siblings like 'calculate' or 'convert_data' that might also handle text. The verb 'handle' is generic rather than specific.
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?
No guidance is provided about when to use this tool versus alternatives. The description doesn't mention any prerequisites, constraints, or comparison with sibling tools like 'calculate' or 'convert_data'. There's no indication of when specific operations should be chosen or what context makes this tool appropriate.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Recent tool additions, removals, and schema changes observed during successful MCP inspections. Dates show when Glama detected each change.
v1.0.0calculateconvert_datafetch_urlget_datetimeprocess_textEach tool has a clearly distinct purpose with no overlap: calculate handles math operations, convert_data transforms data formats, fetch_url performs HTTP requests, get_datetime retrieves time information, and process_text manipulates text. The descriptions clearly differentiate their domains, making misselection unlikely.
All tool names follow a consistent verb_noun pattern (calculate, convert_data, fetch_url, get_datetime, process_text). The naming is uniform and predictable throughout the set, with no mixing of conventions or styles.
With 5 tools, this server is well-scoped for a utility toolkit. Each tool serves a distinct and useful function, and the count is appropriate for covering basic operations without being overly sparse or bloated.
The tool set covers a broad range of utility operations (math, data conversion, HTTP, datetime, text processing) with no obvious major gaps. Minor gaps might include more advanced HTTP methods (e.g., POST) or additional data formats, but the surface is largely complete for general-purpose tasks.
Unclaimed servers have limited discoverability.
If you are the server author, to access and configure the admin panel.
Nifty's MCP server — exposes tasks, projects, messages, and files as tools for AI agents.
MCP server for progressive tool usage at any scale (see https://klavis.ai)
Read-only developer, date, finance, and text utilities. Authless remote MCP server by Clean.tools.
A comprehensive Model Context Protocol (MCP) server that enables AI assistants to interact with yo…
We provide all the information about MCP servers via our MCP API.
curl -X GET 'https://glama.ai/api/mcp/v1/servers/aleostudio/mcp-server'
If you have feedback or need assistance with the MCP directory API, please join our Discord server
