Files
connpy/connpy/mcp_client.py
T

232 lines
8.9 KiB
Python

import asyncio
import logging
import os
import threading
from contextlib import suppress
from typing import Any, ClassVar
try:
from mcp import ClientSession
from mcp.client.sse import sse_client
MCP_AVAILABLE = True
except ImportError:
MCP_AVAILABLE = False
# Silence noisy MCP and HTTP internal logging
logging.getLogger("mcp").setLevel(logging.CRITICAL)
logging.getLogger("httpx").setLevel(logging.CRITICAL)
logging.getLogger("httpcore").setLevel(logging.CRITICAL)
class MCPClientManager:
"""Manages MCP SSE client connections for connpy."""
_instances: ClassVar[dict[Any, "MCPClientManager"]] = {}
_instance: ClassVar["MCPClientManager | None"] = None
_lock = threading.Lock()
@classmethod
def _resolve_scope_key(cls, config=None, *args, **kwargs) -> Any:
cfg = config
if cfg is None and "config" in kwargs:
cfg = kwargs["config"]
if cfg is not None:
defaultdir = getattr(cfg, "defaultdir", None)
if defaultdir:
return os.path.abspath(str(defaultdir))
return id(cfg)
return "default"
def __new__(cls, config=None, *args, **kwargs):
key = cls._resolve_scope_key(config, *args, **kwargs)
with cls._lock:
if cls._instance is None and cls._instances:
cls._instances.clear()
if key not in cls._instances:
instance = super().__new__(cls)
instance._initialized = False
instance._scope_key = key
cls._instances[key] = instance
cls._instance = cls._instances[key]
return cls._instances[key]
def __init__(self, config=None):
if config is not None:
self.config = config
if getattr(self, "_initialized", False):
return
if not hasattr(self, "config"):
self.config = config
self.sessions: dict[str, dict[str, Any]] = {} # name -> {session, stack}
self.tool_cache: dict[str, list[dict[str, Any]]] = {}
self._server_configs: dict[str, dict[str, Any]] = {}
self._connecting: dict[str, asyncio.Future] = {}
self._initialized = True
async def get_tools_for_llm(self, os_filter: str | None = None) -> list[dict[str, Any]]:
"""Fetches tools from enabled MCP servers that match the OS filter."""
if not MCP_AVAILABLE:
return []
all_llm_tools = []
try:
if hasattr(self.config, "get_effective_setting"):
mcp_config = self.config.get_effective_setting("ai", {}).get("mcp_servers", {})
else:
mcp_config = self.config.config.get("ai", {}).get("mcp_servers", {}) if hasattr(self.config, "config") else {}
except Exception: # noqa: BLE001
return []
if not isinstance(mcp_config, dict):
mcp_config = {}
# Invalidate cache and reconnect if server configuration changed or server was removed
current_names = set(mcp_config.keys())
for old_name in list(self._server_configs.keys()):
if old_name not in current_names:
self.tool_cache.pop(old_name, None)
old_data = self.sessions.pop(old_name, None)
if old_data and old_data.get("stack"):
with suppress(Exception):
await old_data["stack"].aclose()
self._server_configs.pop(old_name, None)
for name, cfg in mcp_config.items():
cached_cfg = self._server_configs.get(name)
if cached_cfg is not None and cached_cfg != cfg:
self.tool_cache.pop(name, None)
old_data = self.sessions.pop(name, None)
if old_data and old_data.get("stack"):
with suppress(Exception):
await old_data["stack"].aclose()
self._server_configs[name] = dict(cfg) if isinstance(cfg, dict) else cfg
async def _fetch(name, cfg):
if not isinstance(cfg, dict) or not cfg.get("enabled", True):
return []
# Filter by OS if specified in config (primarily used for copilot strict matching)
auto_os = cfg.get("auto_load_on_os")
if os_filter is not None and auto_os and os_filter.lower() != auto_os.lower():
return []
with suppress(Exception):
session = await self._ensure_connected(name, cfg)
if session:
if name in self.tool_cache:
return self.tool_cache[name]
llm_tools = await self._fetch_tools_as_openai(name, session)
self.tool_cache[name] = llm_tools
return llm_tools
return []
tasks = [_fetch(name, cfg) for name, cfg in mcp_config.items()]
if tasks:
results = await asyncio.gather(*tasks)
for tools in results:
all_llm_tools.extend(tools)
return all_llm_tools
async def _ensure_connected(self, name: str, cfg: dict[str, Any]) -> Any | None:
if not MCP_AVAILABLE:
return None
if name in self.sessions and self.sessions[name].get("session"):
return self.sessions[name]["session"]
url = cfg.get("url")
if not url:
return None
if name in self._connecting:
try:
return await asyncio.wait_for(asyncio.shield(self._connecting[name]), timeout=10.0)
except Exception: # noqa: BLE001
return None
loop = asyncio.get_running_loop()
fut = loop.create_future()
self._connecting[name] = fut
try:
from contextlib import AsyncExitStack
stack = AsyncExitStack()
async def _do_connect():
read, write = await stack.enter_async_context(sse_client(url))
session = await stack.enter_async_context(ClientSession(read, write))
await session.initialize()
return session
session = await asyncio.wait_for(_do_connect(), timeout=15.0)
self.sessions[name] = {"session": session, "stack": stack}
fut.set_result(session)
return session
except Exception: # noqa: BLE001
fut.set_result(None)
return None
finally:
if name in self._connecting:
del self._connecting[name]
async def _fetch_tools_as_openai(self, server_name: str, session: Any) -> list[dict[str, Any]]:
try:
result = await asyncio.wait_for(session.list_tools(), timeout=5.0)
openai_tools = []
for tool in result.tools:
prefixed_name = f"mcp_{server_name}__{tool.name}"
openai_tools.append({
"type": "function",
"function": {
"name": prefixed_name,
"description": f"[{server_name}] {tool.description}",
"parameters": tool.inputSchema,
},
})
return openai_tools
except Exception: # noqa: BLE001
return []
async def call_tool(self, full_tool_name: str, arguments: dict[str, Any]) -> Any:
"""Calls an MCP tool and returns text result."""
if not MCP_AVAILABLE:
return "Error: MCP SDK is not installed."
if "__" not in full_tool_name:
return f"Error: Tool {full_tool_name} is not a valid MCP tool."
clean_name = full_tool_name.removeprefix("mcp_")
server_name, tool_name = clean_name.split("__", 1)
if server_name not in self.sessions:
return f"Error: MCP server {server_name} is not connected."
session = self.sessions[server_name]["session"]
try:
result = await asyncio.wait_for(session.call_tool(tool_name, arguments), timeout=60.0)
text_outputs = [content.text for content in result.content if hasattr(content, "text")]
return "\n".join(text_outputs) if text_outputs else str(result)
except Exception as e: # noqa: BLE001
return f"Error calling tool {tool_name} on {server_name}: {e!s}"
async def shutdown(self):
"""Close all SSE connections and clean up resources."""
for data in list(self.sessions.values()):
stack = data.get("stack")
if stack:
with suppress(Exception):
await stack.aclose()
self.sessions.clear()
self.tool_cache.clear()
self._server_configs.clear()
for fut in list(self._connecting.values()):
if not fut.done():
fut.cancel()
self._connecting.clear()
with self._lock:
if hasattr(self, "_scope_key") and self._scope_key in self._instances:
del self._instances[self._scope_key]
self._initialized = False