What is Easymcp

EasyMCP is a high-performance client SDK for the Model Context Protocol (MCP), completely rewritten in Python to enhance usability and performance.

Use cases

Use cases include managing multiple MCP servers for applications like time servers, search engines, and any service that requires tool invocation and resource management in a concurrent environment.

How to use

To use EasyMCP, install it via the command ‘uv add easymcp’. Then, create a ClientManager instance to manage multiple MCP servers, configure them using StdioServerParameters, and utilize the high-level API to perform actions such as listing servers, adding or removing servers, and calling tools.

Key features

Key features include out-of-the-box caching for tools/resources/prompts, automatic cache invalidation, support for parallel requests, full lifecycle management of servers, dynamic server management, namespaced tools/resources/prompts, and a lightweight asyncio native implementation.

Where to use

EasyMCP can be used in various fields that require efficient communication with multiple MCP servers, such as web services, data processing applications, and real-time systems.

EasyMCP

EasyMCP is a complete rewrite of the model context protocol (MCP) in Python.

Installation

uv add easymcp

Usage

The high level API exposes a ClientManager class that can be used to manage multiple MCP servers.

import asyncio
from easymcp.client.ClientManager import ClientManager
from easymcp.client.transports.stdio import StdioServerParameters

mgr = ClientManager()

searxng = StdioServerParameters(
    command="uvx",
    args=["mcp-searxng"],
)

timeserver = StdioServerParameters(
    command="uvx",
    args=["mcp-timeserver"],
)

servers = {
    "searxng": searxng,
    "timeserver": timeserver,
}

async def main():
    # initialize the client manager
    await mgr.init(servers=servers)

    # list servers
    print(mgr.list_servers())

    # remove a server
    await mgr.remove_server("searxng")

    # add a server
    await mgr.add_server("searxng", searxng)

    # list tools - these are namespaced by server name automatically
    # {server name}.{tool name}
    print(await mgr.list_tools())

    # call tool
    print(await mgr.call_tool("timeserver.get-current-time", {}))

    # list resources - these are namespaced by server name automatically
    # mcp-{server name}+{resource uri}
    print(await mgr.list_resources())

    # read resource
    print(await mgr.read_resource("mcp-timeserver+datetime://Africa/Algiers/now"))

    await asyncio.Future()

asyncio.run(main())

Core Features

• list tools/resources/prompts caching out of the box
• automatic cache invalidation on tool/resource/prompt change notifications
• out of the box support for parallel requests to servers
• full lifecycle management of servers
• dynamic server addition/removal
• namespaced tools/resources/prompts
• lightweight asyncio native implementation

Why namespace tools?

Namespaced tools remove need to perform a lookup to find the correct tool. This means:

• faster tool calls
• tool calls can be routed across many MCP hosts at scale
• mcp servers do not need globally unique tool names

Why namespace resources?

Resources are namespaced in a way that makes it easy to make a resource URI to a specific server. You can:

• check if a URL needs to be resolved via mcp by checking if it starts with mcp
• check what server to resolve the URI with
• ingest resources into a search system like elastic search without having to store metadata about the server
• completely eliminate the need to map URIs to servers via a database or lookup table

Comparison of classes to other MCP libraries

License

This project is licensed under the MIT License - see the LICENSE file for details.