mcpsdk 0.1.0__tar.gz

mcpsdk-0.1.0/PKG-INFO

@@ -0,0 +1,129 @@
+Metadata-Version: 2.4
+Name: mcpsdk
+Version: 0.1.0
+Summary: The simplest way to build and connect MCP servers and clients.
+License: MIT
+Project-URL: Homepage, https://github.com/yourname/mcpeasy
+Project-URL: Bug Tracker, https://github.com/yourname/mcpeasy/issues
+Keywords: mcp,ai,agent,llm,tools,model-context-protocol
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+Requires-Dist: mcp>=1.0.0
+Requires-Dist: httpx>=0.27.0
+
+# MCPeasy
+
+The simplest way to build and connect MCP (Model Context Protocol) servers and clients in Python.
+
+No async. No boilerplate. Just define your tools and go.
+
+## Install
+
+```bash
+pip install mcpeasy
+```
+
+## Quickstart
+
+### Build a server
+
+```python
+from mcpeasy import MCPServer
+
+server = MCPServer("my-server")
+
+@server.tool
+def get_weather(city: str) -> str:
+    """Get the current weather for a city."""
+    return f"Sunny in {city}, 22C"
+
+@server.tool
+def calculate(expression: str) -> str:
+    """Evaluate a math expression."""
+    return str(eval(expression))
+
+server.run()              # stdio (default)
+server.run(mode="sse")    # SSE on http://0.0.0.0:8000
+```
+
+### Connect a client
+
+```python
+from mcpeasy import MCPClient
+
+# SSE — server already running
+with MCPClient.from_sse("http://localhost:8000/sse") as client:
+    tools  = client.list_tools()
+    result = client.call_tool("get_weather", {"city": "Tokyo"})
+    print(result)
+
+# stdio — client spawns the server
+with MCPClient.from_stdio("python", ["server.py"]) as client:
+    tools  = client.list_tools()
+    result = client.call_tool("calculate", {"expression": "12 * 7"})
+    print(result)
+```
+
+### Use with any LLM
+
+`list_tools()` returns raw MCP format — convert to your LLM's format yourself:
+
+```python
+from mcpeasy import MCPClient
+
+with MCPClient.from_sse("http://localhost:8000/sse") as client:
+    tools = client.list_tools()
+    # tools → [{ "name", "description", "parameters" }]
+
+    # Anthropic
+    anthropic_tools = [{"name": t["name"], "description": t["description"], "input_schema": t["parameters"]} for t in tools]
+
+    # OpenAI
+    openai_tools = [{"type": "function", "function": {"name": t["name"], "description": t["description"], "parameters": t["parameters"]}} for t in tools]
+
+    # when LLM picks a tool:
+    result = client.call_tool(tool_name, params)
+```
+
+## API
+
+### MCPServer
+
+| Method | Description |
+|---|---|
+| `MCPServer(name)` | Create a server |
+| `@server.tool` | Register a function as a tool |
+| `server.run(mode, host, port)` | Start the server (`mode="stdio"` or `"sse"`) |
+
+### MCPClient
+
+| Method | Description |
+|---|---|
+| `MCPClient.from_sse(url)` | Create client for remote SSE server |
+| `MCPClient.from_stdio(command, args)` | Create client for local stdio server |
+| `client.connect()` | Open connection |
+| `client.disconnect()` | Close connection |
+| `client.list_tools()` | Get all tools from server |
+| `client.call_tool(name, params)` | Call a tool, get result as string |
+| `client.tool_info(name)` | Get details of one tool |
+
+## Transport modes
+
+| | stdio | SSE |
+|---|---|---|
+| Where | Same machine | Anywhere |
+| Server startup | Client spawns it | Already running |
+| Connect with | `from_stdio(cmd, args)` | `from_sse(url)` |
+| Best for | Local tools | Remote / shared servers |
+
+## License
+
+MIT

mcpsdk-0.1.0/README.md

@@ -0,0 +1,108 @@
+# MCPeasy
+
+The simplest way to build and connect MCP (Model Context Protocol) servers and clients in Python.
+
+No async. No boilerplate. Just define your tools and go.
+
+## Install
+
+```bash
+pip install mcpeasy
+```
+
+## Quickstart
+
+### Build a server
+
+```python
+from mcpeasy import MCPServer
+
+server = MCPServer("my-server")
+
+@server.tool
+def get_weather(city: str) -> str:
+    """Get the current weather for a city."""
+    return f"Sunny in {city}, 22C"
+
+@server.tool
+def calculate(expression: str) -> str:
+    """Evaluate a math expression."""
+    return str(eval(expression))
+
+server.run()              # stdio (default)
+server.run(mode="sse")    # SSE on http://0.0.0.0:8000
+```
+
+### Connect a client
+
+```python
+from mcpeasy import MCPClient
+
+# SSE — server already running
+with MCPClient.from_sse("http://localhost:8000/sse") as client:
+    tools  = client.list_tools()
+    result = client.call_tool("get_weather", {"city": "Tokyo"})
+    print(result)
+
+# stdio — client spawns the server
+with MCPClient.from_stdio("python", ["server.py"]) as client:
+    tools  = client.list_tools()
+    result = client.call_tool("calculate", {"expression": "12 * 7"})
+    print(result)
+```
+
+### Use with any LLM
+
+`list_tools()` returns raw MCP format — convert to your LLM's format yourself:
+
+```python
+from mcpeasy import MCPClient
+
+with MCPClient.from_sse("http://localhost:8000/sse") as client:
+    tools = client.list_tools()
+    # tools → [{ "name", "description", "parameters" }]
+
+    # Anthropic
+    anthropic_tools = [{"name": t["name"], "description": t["description"], "input_schema": t["parameters"]} for t in tools]
+
+    # OpenAI
+    openai_tools = [{"type": "function", "function": {"name": t["name"], "description": t["description"], "parameters": t["parameters"]}} for t in tools]
+
+    # when LLM picks a tool:
+    result = client.call_tool(tool_name, params)
+```
+
+## API
+
+### MCPServer
+
+| Method | Description |
+|---|---|
+| `MCPServer(name)` | Create a server |
+| `@server.tool` | Register a function as a tool |
+| `server.run(mode, host, port)` | Start the server (`mode="stdio"` or `"sse"`) |
+
+### MCPClient
+
+| Method | Description |
+|---|---|
+| `MCPClient.from_sse(url)` | Create client for remote SSE server |
+| `MCPClient.from_stdio(command, args)` | Create client for local stdio server |
+| `client.connect()` | Open connection |
+| `client.disconnect()` | Close connection |
+| `client.list_tools()` | Get all tools from server |
+| `client.call_tool(name, params)` | Call a tool, get result as string |
+| `client.tool_info(name)` | Get details of one tool |
+
+## Transport modes
+
+| | stdio | SSE |
+|---|---|---|
+| Where | Same machine | Anywhere |
+| Server startup | Client spawns it | Already running |
+| Connect with | `from_stdio(cmd, args)` | `from_sse(url)` |
+| Best for | Local tools | Remote / shared servers |
+
+## License
+
+MIT

mcpsdk-0.1.0/mcpeasy/__init__.py

@@ -0,0 +1,7 @@
+# mcpeasy/__init__.py
+
+from .server import MCPServer
+from .client import MCPClient
+
+__all__ = ["MCPServer", "MCPClient"]
+__version__ = "0.1.0"

mcpsdk-0.1.0/mcpeasy/client.py

@@ -0,0 +1,168 @@
+# easymcp2/client.py
+
+import asyncio
+import threading
+import queue
+
+
+class MCPClient:
+    """
+    A simple MCP client. Connect to a server, list tools, call them.
+
+    Usage — SSE (remote or local server already running):
+        with MCPClient.from_sse("http://localhost:8000/sse") as client:
+            print(client.list_tools())
+            print(client.call_tool("get_weather", {"city": "Tokyo"}))
+
+    Usage — stdio (client spawns the server as a subprocess):
+        with MCPClient.from_stdio("python", ["server.py"]) as client:
+            print(client.list_tools())
+            print(client.call_tool("get_weather", {"city": "Tokyo"}))
+    """
+
+    def __init__(self, transport: str, **kwargs):
+        self._transport    = transport
+        self._kwargs       = kwargs
+        self._session      = None
+        self._loop         = None
+        self._thread       = None
+        self._ready        = threading.Event()
+        self._stop         = threading.Event()
+        self._error        = None
+        self._tools_cache  = None
+
+    @classmethod
+    def from_sse(cls, url: str) -> "MCPClient":
+        return cls(transport="sse", url=url)
+
+    @classmethod
+    def from_stdio(cls, command: str, args: list = None) -> "MCPClient":
+        return cls(transport="stdio", command=command, args=args or [])
+
+    # ── Lifecycle ─────────────────────────────────────────────
+
+    def connect(self):
+        self._ready = threading.Event()
+        self._stop  = threading.Event()
+        self._error = None
+
+        def run():
+            self._loop = asyncio.new_event_loop()
+            asyncio.set_event_loop(self._loop)
+            self._loop.run_until_complete(self._run_session())
+
+        self._thread = threading.Thread(target=run, daemon=True)
+        self._thread.start()
+        self._ready.wait()
+        if self._error:
+            raise self._error
+
+    def disconnect(self):
+        if self._stop:
+            self._stop.set()
+        if self._thread:
+            self._thread.join(timeout=5)
+        self._loop   = None
+        self._thread = None
+
+    def __enter__(self):
+        self.connect()
+        return self
+
+    def __exit__(self, *_):
+        self.disconnect()
+
+    # ── Public API ────────────────────────────────────────────
+
+    def list_tools(self) -> list[dict]:
+        self._ensure_connected()
+        if self._tools_cache is None:
+            self._tools_cache = self._call(self._async_list_tools())
+        return self._tools_cache
+
+    def call_tool(self, tool_name: str, params: dict = None) -> str:
+        self._ensure_connected()
+        return self._call(self._async_call_tool(tool_name, params or {}))
+
+    def tool_info(self, tool_name: str) -> dict | None:
+        return next((t for t in self.list_tools() if t["name"] == tool_name), None)
+
+    # ── Internal ──────────────────────────────────────────────
+
+    def _call(self, coro):
+        """Submit coroutine to background loop, block until done."""
+        result_q = queue.Queue()
+
+        async def runner():
+            try:
+                result_q.put(("ok", await coro))
+            except Exception as e:
+                result_q.put(("err", e))
+
+        asyncio.run_coroutine_threadsafe(runner(), self._loop)
+        tag, value = result_q.get()
+        if tag == "err":
+            raise value
+        return value
+
+    async def _run_session(self):
+        """
+        Opens transport + session in ONE continuous async context.
+        Signals ready, then stays alive until disconnect() is called.
+        This is required by anyio — open and close must be in same task.
+        """
+        from mcp import ClientSession
+
+        try:
+            if self._transport == "sse":
+                from mcp.client.sse import sse_client
+                cm = sse_client(self._kwargs["url"])
+            elif self._transport == "stdio":
+                from mcp import StdioServerParameters
+                from mcp.client.stdio import stdio_client
+                cm = stdio_client(StdioServerParameters(
+                    command=self._kwargs["command"],
+                    args=self._kwargs["args"],
+                ))
+            else:
+                raise ValueError(f"Unknown transport: {self._transport!r}")
+
+            async with cm as (read, write):
+                async with ClientSession(read, write) as session:
+                    await session.initialize()
+                    self._session = session
+                    self._ready.set()        # unblock connect()
+
+                    # stay alive until disconnect() fires
+                    while not self._stop.is_set():
+                        await asyncio.sleep(0.05)
+
+        except Exception as e:
+            self._error = e
+            self._ready.set()              # unblock connect() so it raises
+        finally:
+            self._session = None
+
+    async def _async_list_tools(self) -> list[dict]:
+        response = await self._session.list_tools()
+        return [
+            {
+                "name":        t.name,
+                "description": t.description or "",
+                "parameters":  t.inputSchema or {},
+            }
+            for t in response.tools
+        ]
+
+    async def _async_call_tool(self, tool_name: str, params: dict) -> str:
+        result = await self._session.call_tool(tool_name, params)
+        return "\n".join(
+            block.text for block in result.content if hasattr(block, "text")
+        )
+
+    def _ensure_connected(self):
+        if self._session is None:
+            raise RuntimeError(
+                "Not connected. Call client.connect() first, "
+                "or use:  with MCPClient.from_sse(...) as client: ..."
+            )

mcpsdk-0.1.0/mcpeasy/server.py

@@ -0,0 +1,55 @@
+# easymcp2/server.py
+
+from mcp.server.fastmcp import FastMCP
+
+
+class MCPServer:
+    """
+    A simple MCP server. Define tools on it, then run it.
+
+    Usage:
+        server = MCPServer("my-server")
+
+        @server.tool
+        def get_weather(city: str) -> str:
+            \"\"\"Get weather for a city.\"\"\"
+            return f"Sunny in {city}"
+
+        server.run()             # stdio (default)
+        server.run(mode="sse")   # SSE on http://0.0.0.0:8000
+    """
+
+    def __init__(self, name: str = "mcp-server"):
+        self._mcp = FastMCP(name)
+        self.name = name
+
+    def tool(self, fn):
+        """
+        Decorator to register a function as an MCP tool.
+
+        Example:
+            @server.tool
+            def add(a: int, b: int) -> str:
+                \"\"\"Add two numbers.\"\"\"
+                return str(a + b)
+        """
+        self._mcp.tool()(fn)
+        return fn
+
+    def run(self, mode: str = "stdio", host: str = "0.0.0.0", port: int = 8000):
+        """
+        Start the server.
+
+        Args:
+            mode: "stdio" (default) or "sse"
+            host: host to bind to in SSE mode (default 0.0.0.0)
+            port: port to listen on in SSE mode (default 8000)
+
+        stdio → client spawns this process directly
+        sse   → server runs independently, clients connect via HTTP
+        """
+        if mode == "sse":
+            print(f"[{self.name}] running in SSE mode on http://{host}:{port}/sse")
+            self._mcp.run(transport="sse", host=host, port=port)
+        else:
+            self._mcp.run()

mcpsdk-0.1.0/mcpsdk.egg-info/PKG-INFO

@@ -0,0 +1,129 @@
+Metadata-Version: 2.4
+Name: mcpsdk
+Version: 0.1.0
+Summary: The simplest way to build and connect MCP servers and clients.
+License: MIT
+Project-URL: Homepage, https://github.com/yourname/mcpeasy
+Project-URL: Bug Tracker, https://github.com/yourname/mcpeasy/issues
+Keywords: mcp,ai,agent,llm,tools,model-context-protocol
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+Requires-Dist: mcp>=1.0.0
+Requires-Dist: httpx>=0.27.0
+
+# MCPeasy
+
+The simplest way to build and connect MCP (Model Context Protocol) servers and clients in Python.
+
+No async. No boilerplate. Just define your tools and go.
+
+## Install
+
+```bash
+pip install mcpeasy
+```
+
+## Quickstart
+
+### Build a server
+
+```python
+from mcpeasy import MCPServer
+
+server = MCPServer("my-server")
+
+@server.tool
+def get_weather(city: str) -> str:
+    """Get the current weather for a city."""
+    return f"Sunny in {city}, 22C"
+
+@server.tool
+def calculate(expression: str) -> str:
+    """Evaluate a math expression."""
+    return str(eval(expression))
+
+server.run()              # stdio (default)
+server.run(mode="sse")    # SSE on http://0.0.0.0:8000
+```
+
+### Connect a client
+
+```python
+from mcpeasy import MCPClient
+
+# SSE — server already running
+with MCPClient.from_sse("http://localhost:8000/sse") as client:
+    tools  = client.list_tools()
+    result = client.call_tool("get_weather", {"city": "Tokyo"})
+    print(result)
+
+# stdio — client spawns the server
+with MCPClient.from_stdio("python", ["server.py"]) as client:
+    tools  = client.list_tools()
+    result = client.call_tool("calculate", {"expression": "12 * 7"})
+    print(result)
+```
+
+### Use with any LLM
+
+`list_tools()` returns raw MCP format — convert to your LLM's format yourself:
+
+```python
+from mcpeasy import MCPClient
+
+with MCPClient.from_sse("http://localhost:8000/sse") as client:
+    tools = client.list_tools()
+    # tools → [{ "name", "description", "parameters" }]
+
+    # Anthropic
+    anthropic_tools = [{"name": t["name"], "description": t["description"], "input_schema": t["parameters"]} for t in tools]
+
+    # OpenAI
+    openai_tools = [{"type": "function", "function": {"name": t["name"], "description": t["description"], "parameters": t["parameters"]}} for t in tools]
+
+    # when LLM picks a tool:
+    result = client.call_tool(tool_name, params)
+```
+
+## API
+
+### MCPServer
+
+| Method | Description |
+|---|---|
+| `MCPServer(name)` | Create a server |
+| `@server.tool` | Register a function as a tool |
+| `server.run(mode, host, port)` | Start the server (`mode="stdio"` or `"sse"`) |
+
+### MCPClient
+
+| Method | Description |
+|---|---|
+| `MCPClient.from_sse(url)` | Create client for remote SSE server |
+| `MCPClient.from_stdio(command, args)` | Create client for local stdio server |
+| `client.connect()` | Open connection |
+| `client.disconnect()` | Close connection |
+| `client.list_tools()` | Get all tools from server |
+| `client.call_tool(name, params)` | Call a tool, get result as string |
+| `client.tool_info(name)` | Get details of one tool |
+
+## Transport modes
+
+| | stdio | SSE |
+|---|---|---|
+| Where | Same machine | Anywhere |
+| Server startup | Client spawns it | Already running |
+| Connect with | `from_stdio(cmd, args)` | `from_sse(url)` |
+| Best for | Local tools | Remote / shared servers |
+
+## License
+
+MIT

mcpsdk-0.1.0/mcpsdk.egg-info/SOURCES.txt

@@ -0,0 +1,10 @@
+README.md
+pyproject.toml
+mcpeasy/__init__.py
+mcpeasy/client.py
+mcpeasy/server.py
+mcpsdk.egg-info/PKG-INFO
+mcpsdk.egg-info/SOURCES.txt
+mcpsdk.egg-info/dependency_links.txt
+mcpsdk.egg-info/requires.txt
+mcpsdk.egg-info/top_level.txt

mcpsdk-0.1.0/mcpsdk.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

mcpsdk-0.1.0/mcpsdk.egg-info/requires.txt

@@ -0,0 +1,2 @@
+mcp>=1.0.0
+httpx>=0.27.0

mcpsdk-0.1.0/mcpsdk.egg-info/top_level.txt

@@ -0,0 +1 @@
+mcpeasy

mcpsdk-0.1.0/pyproject.toml

@@ -0,0 +1,35 @@
+[build-system]
+requires = ["setuptools>=68", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "mcpsdk"
+version = "0.1.0"
+description = "The simplest way to build and connect MCP servers and clients."
+readme = "README.md"
+requires-python = ">=3.11"
+license = { text = "MIT" }
+keywords = ["mcp", "ai", "agent", "llm", "tools", "model-context-protocol"]
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+    "Intended Audience :: Developers",
+    "Topic :: Software Development :: Libraries :: Python Modules",
+]
+
+dependencies = [
+    "mcp>=1.0.0",
+    "httpx>=0.27.0",
+]
+
+[project.urls]
+Homepage = "https://github.com/yourname/mcpeasy"
+"Bug Tracker" = "https://github.com/yourname/mcpeasy/issues"
+
+[tool.setuptools.packages.find]
+where = ["."]
+include = ["mcpeasy*"]

mcpsdk-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+