Model Context Protocol (MCP)

$ curl -LsSf https://astral.sh/uv/install.sh | sh

# 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

mkdir modules
touch modules/sieu_nhan.py

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'

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

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

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.")

$ touch server.py

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

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"],
                }
            )
        ]

    @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)}")

    options = server.create_initialization_options()
    async with stdio_server() as (read_stream, write_stream):
        await server.run(read_stream, write_stream, options)

$ docker build . -t hoangndst/mcp-server-danchoicloud:v0.1.0

{
    "mcpServers": {
      "danchoicloud": {
        "command": "docker",
        "args": ["run", "-i", "--rm", "hoangndst/mcp-server-danchoicloud:v0.1.0"]
      }
    }
}

Get me a random image of sieu nhan.