Figure 1: Model Context Protocol Diagram
Figure 1: Model Context Protocol Diagram
Figure 2: Model Context Protocol Architecture (Source: descope)
uv and setup Python project:
```bash
$ curl -LsSf https://astral.sh/uv/install.sh | sh
```
Create a new project and install dependencies:
```bash
# Create project folder
uv init mcp-server-danchoicloud
cd mcp-server-danchoicloud
# Create virtual environment and activate it
uv venv
source .venv/bin/activate
# Install dependencies
uv add "mcp[cli]" httpx
```
### 3.3. Create modules for each tool
Create a new folder called `modules` and create a file called `sieu_nhan.py` inside it. This file will contain the code for the `get_sieu_nhan` tool.
```bash
mkdir modules
touch modules/sieu_nhan.py
```
Import the necessary libraries
```python:sieu_nhan.py caption="sieu_nhan.py" showLineNumbers
import base64
from enum import Enum
import httpx
from mcp.types import TextContent, ImageContent
SIEU_NHAN_API_BASE = ''
class SieuNhanTools(str, Enum):
GET_SIEU_NHAN = 'get_sieu_nhan'
```
Create a function to get random image of "sieu nhan"
```python:sieu_nhan.py caption="get_sieu_nhan function" showLineNumbers
async def get_sieu_nhan():
"""
Get a random superhero from the API.
"""
async with httpx.AsyncClient(follow_redirects=True) as client:
try:
response = await client.get(SIEU_NHAN_API_BASE)
response.raise_for_status() # Raise an error for bad responses
data = response.json()
return data
except httpx.RequestError as e:
print(f"An error occurred while requesting the API: {e}")
return None
```
Create a function to convert the image to base64
```python:sieu_nhan.py caption="get_image_base64 function" showLineNumbers
async def get_image_base64(img_url: str) -> str | None:
"""
Fetch an image from the given URL and return its base64-encoded data.
"""
async with httpx.AsyncClient(follow_redirects=True) as client:
try:
response = await client.get(img_url)
response.raise_for_status()
image_data = response.content
base64_encoded_data = base64.b64encode(image_data).decode('utf-8')
return base64_encoded_data
except httpx.RequestError as e:
print(f"An error occurred while requesting the image: {e}")
return None
```
Cause `ImageContent` requires base64-encoded image data, we need to convert the image to base64 before returning it.
Create Tool function
```python:sieu_nhan.py caption="get_sieu_nhan_tools function" showLineNumbers
async def get_sieu_nhan_tools() -> TextContent | ImageContent:
"""
Get a random superhero from the API and format it for display.
"""
data = await get_sieu_nhan()
if data:
image_url = data.get('image')
if image_url:
base64_image = await get_image_base64(image_url)
if base64_image:
return ImageContent(
type="image",
data=base64_image,
mimeType="image/jpeg",
)
else:
return TextContent(type="text", text="Failed to retrieve image.")
else:
return TextContent(type="text", text="No image URL found in the response.")
else:
return TextContent(type="text", text="Failed to retrieve superhero data.")
```
### 3.4. Setup MCP server
Create a file called `server.py` in the root directory of your project.
```bash
$ touch server.py
```
Import the necessary libraries
```python:server.py caption="server.py" showLineNumbers
from typing import Sequence
from mcp.server import Server
from mcp.server.stdio import stdio_server
from mcp.types import Tool, TextContent, ImageContent
from mcp_server_danchoicloud.modules.sieu_nhan import SieuNhanTools, get_sieu_nhan_tools
```
Create a list of tools
```python:server.py caption="serve function" showLineNumbers
async def serve() -> None:
server = Server('mcp_server_danchoicloud', 'v0.1.0')
@server.list_tools()
async def list_tools() -> list[Tool]:
"""List available tools."""
return [
Tool(
name=SieuNhanTools.GET_SIEU_NHAN.value,
description="Get a random superhero from the API.",
inputSchema={
"type": "object",
"properties": {
"text": {
"type": "string",
"description": "The text to display.",
},
},
"required": ["text"],
}
)
]
```
Create a function to call the tool
```python:server.py caption="handle_call_tool function" showLineNumbers
@server.call_tool()
async def handle_call_tool(
name: str, arguments: dict | None
) -> Sequence[TextContent | ImageContent]:
"""Handle tool calls."""
try:
match name:
case SieuNhanTools.GET_SIEU_NHAN.value:
result = await get_sieu_nhan_tools()
case _:
raise ValueError(f"Unknown tool: {name}")
return [result]
except Exception as e:
raise ValueError(f"Error processing mcp_server_danchoicloud query: {str(e)}")
```
Initialize the server
```python:server.py caption="initialize_server function" showLineNumbers
options = server.create_initialization_options()
async with stdio_server() as (read_stream, write_stream):
await server.run(read_stream, write_stream, options)
```
### 3.5. Build the server
We will build the server using `Docker`:
Figure 3: Testing MCP server with continue
Figure 4: Testing MCP server with cursor
Figure 5: Testing MCP server with Claude for Desktop
Figure 6: Testing MCP server with Claude for Desktop
Figure 7: Result from `get_sieu_nhan` from `danchoicloud` local server