mymcpservercli
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., "@mymcpservercli What's the current weather in San Francisco?"
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.
mymcpservercli
mymcpservercli is a Model Context Protocol (MCP) server built with FastMCP featuring dynamic tool loading.
Features
Dynamic Tool Loading: Tools are automatically discovered and loaded from
src/tools/One Tool Per File: Each tool is a single file with a function matching the filename
FastMCP Integration: Leverages FastMCP for robust MCP protocol handling
Configuration Management: Tool-specific configuration via
mcp.yamlFail-Fast: Server won't start if any tool fails to load
Auto-Generated Tests: Automatic test generation for tool validation
Related MCP server: my-mcp-server
Project Structure
src/
├── tools/ # Tool implementations (one file per tool)
│ ├── echo.py # Example echo tool
│ └── __init__.py # Auto-generated tool registry
├── core/ # Dynamic loading framework
│ ├── server.py # Dynamic MCP server
│ └── utils.py # Shared utilities
└── main.py # Entry point
mcp.yaml # Configuration file
tests/ # Generated testsQuick Start
Option 1: Local Development (with Python/uv)
Install Dependencies:
uv syncRun the Server:
# Stdio mode (default MCP transport) uv run python src/main.py # HTTP mode with WebSocket MCP endpoint uv run python src/main.py --http # HTTP mode with custom host/port uv run python src/main.py --http --host 0.0.0.0 --port 8080Using uv Scripts:
# Development mode (HTTP on port 3000) uv run dev # HTTP mode uv run dev-http # Stdio mode uv run startAdd New Tools:
# Create a new tool (no tool types needed!) arctl mcp add-tool weather # The tool file will be created at src/tools/weather.py # Edit it to implement your tool logic
Option 2: Docker-Only Development (no local Python/uv required)
Build Docker Image:
arctl mcp build --verboseRun in Container:
docker run -i mymcpservercli:latestAdd New Tools:
# Create a new tool arctl mcp add-tool weather # Edit the tool file, then rebuild arctl mcp build
HTTP Transport Mode
The server supports running in HTTP mode for development and integration purposes.
Starting in HTTP Mode
# Command line flag
python src/main.py --http
# Environment variable
MCP_TRANSPORT_MODE=http python src/main.py
# Custom host and port
python src/main.py --http --host localhost --port 8080Creating Tools
Basic Tool Structure
Each tool is a Python file in src/tools/ containing a function decorated with @mcp.tool():
# src/tools/weather.py
from core.server import mcp
from core.utils import get_tool_config, get_env_var
@mcp.tool()
def weather(location: str) -> str:
"""Get weather information for a location."""
# Get tool configuration
config = get_tool_config("weather")
api_key = get_env_var(config.get("api_key_env", "WEATHER_API_KEY"))
base_url = config.get("base_url", "https://api.openweathermap.org/data/2.5")
# TODO: Implement weather API call
return f"Weather for {location}: Sunny, 72°F"Tool Examples
The generated tool template includes commented examples for common patterns:
# HTTP API calls
# async with httpx.AsyncClient() as client:
# response = await client.get(f"{base_url}/weather?q={location}&appid={api_key}")
# return response.json()
# Database operations
# async with asyncpg.connect(connection_string) as conn:
# result = await conn.fetchrow("SELECT * FROM weather WHERE location = $1", location)
# return dict(result)
# File processing
# with open(file_path, 'r') as f:
# content = f.read()
# return {"content": content, "size": len(content)}Configuration
Configure tools in mcp.yaml:
tools:
weather:
api_key_env: "WEATHER_API_KEY"
base_url: "https://api.openweathermap.org/data/2.5"
timeout: 30
database:
connection_string_env: "DATABASE_URL"
max_connections: 10Testing
Run the generated tests to verify your tools load correctly:
uv run pytest tests/Development
Adding Dependencies
Update pyproject.toml and run:
uv syncCode Quality
uv run black .
uv run ruff check .
uv run mypy .Deployment
Docker
# Build image (handles lockfile automatically)
arctl mcp build
# Run container
docker run -i mymcpservercli:latestAvailable Tools
1 toolechoB
Echo a message back to the client.
Args: message: The message to echo
Returns: The echoed message with any configured prefix
Inputs: message (required). Returns: result
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
TDQS
Scored across 1 tool
With only one tool, there is no possibility of ambiguity or overlap with other tools, making disambiguation perfect.
A single tool inherently has consistent naming, as there are no other tools to compare against for patterns or conventions.
One tool is too few for most server purposes, as it severely limits functionality and scope, making the server feel trivial or incomplete.
The server lacks a clear domain, and with only an echo tool, there are significant gaps in coverage, making it severely incomplete for any meaningful workflow.
Maintenance
Related MCP Connectors
MCP server for progressive tool usage at any scale (see https://klavis.ai)
Model Context Protocol server for the Apideck Unified API. Connect any MCP-compatible agent framework to 100+ accounting systems, HRIS platforms, file storage providers, and more through one integration. More information https://www.apideck.com/mcp-server
MCP server for your apps' tools and custom tools, plus hosted AI agents and approval-gated workflows
Nifty's MCP server — exposes tasks, projects, messages, and files as tools for AI agents.
Related MCP Servers
- AlicenseAqualityDmaintenanceA lightweight framework for building and running Model Context Protocol (MCP) servers using FastMCP, providing tools for development, debugging, and server management.4MIT
- FlicenseBqualityDmaintenanceA Model Context Protocol server built with FastMCP that enables dynamic tool loading and configuration from individual Python files. It provides a flexible framework for automatically discovering, testing, and running tools via Stdio or HTTP transport modes.1-
- FlicenseNot gradedqualityDmaintenanceA Model Context Protocol server built with FastMCP that features dynamic tool loading and modular management via a dedicated tool directory. It supports both stdio and HTTP transport modes, enabling efficient development and deployment of custom MCP tools.-
- FlicenseNot gradedqualityDmaintenanceA production-ready Python scaffold for building Model Context Protocol (MCP) servers using FastMCP. It provides a structured framework for developers and AI agents to rapidly develop, test, and manage custom tools and workflows.1-