Optional init (#26)

* solve test

* remove legacy functions

Author: hieutrtr

examples/with_config/test.py renamed to examples/test.py

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "mcphub"
-version = "0.1.7"
+version = "0.1.8"
 description = "A Python package for managing and integrating Model Context Protocol (MCP) servers with AI frameworks like OpenAI Agents, LangChain, and Autogen"
 readme = "README.md"
 authors = [

examples/without_config/test.py

@@ -0,0 +1,21 @@
+try:
+    from typing import List
+
+    from autogen_ext.tools.mcp import StdioMcpToolAdapter
+
+    from .base import MCPBaseAdapter
+
+    class MCPAutogenAdapter(MCPBaseAdapter):
+        async def create_adapters(self, mcp_name: str) -> List[StdioMcpToolAdapter]:
+            server_params = self.get_server_params(mcp_name)
+            async with self.create_session(mcp_name) as session:
+                tools = await session.list_tools()
+                return [
+                    await StdioMcpToolAdapter.from_server_params(server_params, tool.name)
+                    for tool in tools.tools
+                ]
+                
+except ImportError:
+    class MCPAutogenAdapter:  # type: ignore
+        def __init__(self, *args, **kwargs):
+            raise ImportError("Autogen dependencies not found. Install with: pip install mcphub[autogen]") 

pyproject.toml

@@ -0,0 +1,44 @@
+from abc import ABC
+from contextlib import asynccontextmanager
+from typing import AsyncGenerator, List, Tuple, Any
+
+from mcp import ClientSession, StdioServerParameters, Tool
+from mcp.client.stdio import stdio_client
+from ..mcp_servers.params import MCPServersParams, MCPServerConfig
+from ..mcp_servers.exceptions import ServerConfigNotFoundError
+
+class MCPBaseAdapter(ABC):
+    def __init__(self, servers_params: MCPServersParams):
+        self.servers_params = servers_params
+
+    def get_server_config(self, mcp_name: str) -> MCPServerConfig:
+        """Get server configuration or raise error if not found"""
+        server_config = self.servers_params.retrieve_server_params(mcp_name)
+        if not server_config:
+            raise ServerConfigNotFoundError(f"Server configuration not found for '{mcp_name}'")
+        return server_config
+
+    def get_server_params(self, mcp_name: str) -> StdioServerParameters:
+        """Convert server config to StdioServerParameters"""
+        server_config = self.get_server_config(mcp_name)
+        return StdioServerParameters(
+            command=server_config.command,
+            args=server_config.args,
+            env=server_config.env,
+            cwd=server_config.cwd
+        )
+    
+    async def get_tools(self, mcp_name: str) -> List[Tool]:
+        """Get tools from the server"""
+        async with self.create_session(mcp_name) as session:
+            tools = await session.list_tools()
+            return tools.tools
+
+    @asynccontextmanager
+    async def create_session(self, mcp_name: str) -> AsyncGenerator[ClientSession, None]:
+        """Create and initialize a client session for the given MCP server"""
+        server_params = self.get_server_params(mcp_name)
+        async with stdio_client(server_params) as (read, write):
+            async with ClientSession(read, write) as session:
+                await session.initialize()
+                yield session

src/mcphub/adapters/autogen.py

@@ -0,0 +1,19 @@
+
+
+try:
+    from typing import List
+
+    from langchain_core.tools import BaseTool
+    from langchain_mcp_adapters.tools import load_mcp_tools
+
+    from .base import MCPBaseAdapter
+
+    class MCPLangChainAdapter(MCPBaseAdapter):
+        async def create_tools(self, mcp_name: str) -> List[BaseTool]:
+            async with self.create_session(mcp_name) as session:
+                return await load_mcp_tools(session)
+
+except ImportError:
+    class MCPLangChainAdapter:  # type: ignore
+        def __init__(self, *args, **kwargs):
+            raise ImportError("LangChain dependencies not found. Install with: pip install mcphub[langchain]") 

src/mcphub/adapters/base.py

@@ -0,0 +1,21 @@
+try:
+    from agents.mcp import MCPServerStdio, MCPServerStdioParams
+    from .base import MCPBaseAdapter
+
+    class MCPOpenAIAgentsAdapter(MCPBaseAdapter):
+        def create_server(self, mcp_name: str, cache_tools_list: bool = True) -> MCPServerStdio:
+            server_config = self.get_server_config(mcp_name)
+            server_params = MCPServerStdioParams(
+                command=server_config.command,
+                args=server_config.args,
+                env=server_config.env,
+                cwd=server_config.cwd
+            )
+            return MCPServerStdio(
+                params=server_params,
+                cache_tools_list=cache_tools_list
+            )
+except ImportError:
+    class MCPOpenAIAgentsAdapter:  # type: ignore
+        def __init__(self, *args, **kwargs):
+            raise ImportError("OpenAI Agents dependencies not found. Install with: pip install mcphub[openai]") 

src/mcphub/adapters/langchain.py

@@ -14,6 +14,7 @@ class MCPServerConfig:
     command: str
     args: List[str]
     env: Dict[str, str]
+    server_name: Optional[str] = None
     description: Optional[str] = None
     tags: Optional[List[str]] = None
     repo_url: Optional[str] = None
@@ -28,7 +29,11 @@ def __init__(self, config_path: Optional[str]):
     @property
     def servers_params(self) -> List[MCPServerConfig]:
         """Return the list of server parameters."""
-        return list(self._servers_params.values())
+        server_configs = []
+        for server_name, server_params in self._servers_params.items():
+            server_params.server_name = server_name
+            server_configs.append(server_params)
+        return server_configs
 
     def _load_user_config(self) -> Dict:
         """Load user configuration from JSON file."""
@@ -60,70 +65,51 @@ def _load_servers_params(self) -> Dict[str, MCPServerConfig]:
         predefined_servers_params = self._load_predefined_servers_params()
         servers = {}
 
-        # If we have user configuration, process it normally
-        if config:
-            for mcp_name, server_config in config.items():
-                package_name = server_config.get("package_name")
-                
-                # Check if command and args are configured in user config
-                if "command" in server_config and "args" in server_config:
-                    # Use configuration directly from .mcphub.json
-                    servers[mcp_name] = MCPServerConfig(
-                        package_name=package_name,
-                        command=server_config["command"],
-                        args=server_config["args"],
-                        env=server_config.get("env", {}),
-                        description=server_config.get("description"),
-                        tags=server_config.get("tags"),
-                        repo_url=server_config.get("repo_url"),
-                        setup_script=server_config.get("setup_script")
-                    )
-                # Fallback to predefined configuration
-                elif package_name and predefined_servers_params.get("mcpServers", {}).get(package_name):
-                    cmd_info = predefined_servers_params["mcpServers"][package_name]
-                    servers[mcp_name] = MCPServerConfig(
-                        package_name=package_name,
-                        command=cmd_info.get("command"),
-                        args=cmd_info.get("args", []),
-                        env=server_config.get("env", {}),
-                        description=cmd_info.get("description"),
-                        tags=cmd_info.get("tags"),
-                        repo_url=cmd_info.get("repo_url"),
-                        setup_script=cmd_info.get("setup_script")
-                    )
-                else:
-                    raise ServerConfigNotFoundError(
-                        f"Server '{package_name}' must either have command and args configured in .mcphub.json "
-                        f"or be defined in mcphub_preconfigured_servers.json"
-                    )
+        for mcp_name, server_config in config.items():
+            package_name = server_config.get("package_name")
+            
+            # Check if command and args are configured in user config
+            if "command" in server_config and "args" in server_config:
+                # Use configuration directly from .mcphub.json
+                servers[mcp_name] = MCPServerConfig(
+                    package_name=package_name,
+                    command=server_config["command"],
+                    args=server_config["args"],
+                    env=server_config.get("env", {}),
+                    description=server_config.get("description"),
+                    tags=server_config.get("tags"),
+                    repo_url=server_config.get("repo_url"),
+                    setup_script=server_config.get("setup_script")
+                )
+            # Fallback to predefined configuration
+            elif package_name and predefined_servers_params.get("mcpServers", {}).get(package_name):
+                cmd_info = predefined_servers_params["mcpServers"][package_name]
+                servers[mcp_name] = MCPServerConfig(
+                    package_name=package_name,
+                    command=cmd_info.get("command"),
+                    args=cmd_info.get("args", []),
+                    env=server_config.get("env", {}),
+                    description=cmd_info.get("description"),
+                    tags=cmd_info.get("tags"),
+                    repo_url=cmd_info.get("repo_url"),
+                    setup_script=cmd_info.get("setup_script")
+                )
+            else:
+                raise ServerConfigNotFoundError(
+                    f"Server '{package_name}' must either have command and args configured in .mcphub.json "
+                    f"or be defined in mcphub_preconfigured_servers.json"
+                )
 
         return servers
 
+    def list_servers(self) -> List[MCPServerConfig]:
+        return self.servers_params
+    
     def retrieve_server_params(self, server_name: str) -> MCPServerConfig:
         # First check in the loaded servers
         if server_name in self._servers_params:
             return self._servers_params[server_name]
-        
-        # If not found, check if it's a direct reference to a predefined server
-        predefined_servers = self._load_predefined_servers_params().get("mcpServers", {})
-        if server_name in predefined_servers:
-            # This is a predefined server being referenced directly by its name
-            cmd_info = predefined_servers[server_name]
-            server_config = MCPServerConfig(
-                package_name=server_name,
-                command=cmd_info.get("command"),
-                args=cmd_info.get("args", []),
-                env=cmd_info.get("env", {}),
-                description=cmd_info.get("description"),
-                tags=cmd_info.get("tags"),
-                repo_url=cmd_info.get("repo_url"),
-                setup_script=cmd_info.get("setup_script")
-            )
-            # Store it in loaded servers for future requests
-            self._servers_params[server_name] = server_config
-            return server_config
-            
-        return None
+        raise ServerConfigNotFoundError(f"Server '{server_name}' not found")
 
     def convert_to_stdio_params(self, server_name: str) -> StdioServerParameters:
         server_params = self.retrieve_server_params(server_name)