vllm_mlx.mcp.manager

MCP Client Manager for handling multiple MCP server connections.

View the complete module source at #L1-L301.

API details

Each callable below includes its exact signature, type annotations, inputs, defaults, return contract, documented exceptions, implementation source, and parsed docstring sections when the source provides them.

vllm_mlx.mcp.manager

MCP Client Manager for handling multiple MCP server connections.

vllm_mlx.mcp.manager.logger module-attribute

logger = logging.getLogger(__name__)

vllm_mlx.mcp.manager.MCPClientManager

MCPClientManager(config: MCPConfig)

Manages multiple MCP server connections.

Provides a unified interface for: - Connecting to multiple MCP servers - Discovering and aggregating tools - Executing tool calls - Managing connection lifecycle

Initialize MCP Client Manager.

Parameters:

• config (MCPConfig) –

  MCP configuration with server definitions

Source code in vllm_mlx/mcp/manager.py

def __init__(self, config: MCPConfig):
    """
    Initialize MCP Client Manager.

    Args:
        config: MCP configuration with server definitions
    """
    self.config = config
    self._clients: Dict[str, MCPClient] = {}
    self._started = False
    self._lock = asyncio.Lock()

    # Create clients for each server
    for name, server_config in config.servers.items():
        self._clients[name] = MCPClient(server_config)

vllm_mlx.mcp.manager.MCPClientManager.config instance-attribute

config = config

vllm_mlx.mcp.manager.MCPClientManager._clients instance-attribute

_clients: Dict[str, MCPClient] = {}

vllm_mlx.mcp.manager.MCPClientManager._started instance-attribute

_started = False

vllm_mlx.mcp.manager.MCPClientManager._lock instance-attribute

_lock = asyncio.Lock()

vllm_mlx.mcp.manager.MCPClientManager.is_started property

is_started: bool

Check if manager has been started.

vllm_mlx.mcp.manager.MCPClientManager.start async

start()

Start the manager and connect to all enabled servers.

Connections are made in parallel for faster startup.

Source code in vllm_mlx/mcp/manager.py

async def start(self):
    """
    Start the manager and connect to all enabled servers.

    Connections are made in parallel for faster startup.
    """
    async with self._lock:
        if self._started:
            return

        logger.info(
            f"Starting MCP client manager with {len(self._clients)} servers"
        )

        # Connect to all servers in parallel
        tasks = [
            client.connect()
            for client in self._clients.values()
            if client.config.enabled
        ]

        if tasks:
            results = await asyncio.gather(*tasks, return_exceptions=True)

            # Log results
            for client, result in zip(
                [c for c in self._clients.values() if c.config.enabled],
                results,
            ):
                if isinstance(result, Exception):
                    logger.error(f"Failed to connect to '{client.name}': {result}")
                elif result:
                    logger.info(f"Connected to '{client.name}'")

        self._started = True

        # Log summary
        connected = sum(1 for c in self._clients.values() if c.is_connected)
        total_tools = sum(len(c.tools) for c in self._clients.values())
        logger.info(
            f"MCP manager started: {connected}/{len(self._clients)} servers, "
            f"{total_tools} tools available"
        )

vllm_mlx.mcp.manager.MCPClientManager.stop async

stop()

Stop the manager and disconnect from all servers.

Source code in vllm_mlx/mcp/manager.py

async def stop(self):
    """Stop the manager and disconnect from all servers."""
    async with self._lock:
        if not self._started:
            return

        logger.info("Stopping MCP client manager")

        # Disconnect from all servers in parallel
        tasks = [client.disconnect() for client in self._clients.values()]
        if tasks:
            await asyncio.gather(*tasks, return_exceptions=True)

        self._started = False
        logger.info("MCP client manager stopped")

vllm_mlx.mcp.manager.MCPClientManager.get_all_tools

get_all_tools() -> List[MCPTool]

Get all tools from all connected servers.

Returns:

• List[MCPTool] –

  List of MCPTool instances

Source code in vllm_mlx/mcp/manager.py

def get_all_tools(self) -> List[MCPTool]:
    """
    Get all tools from all connected servers.

    Returns:
        List of MCPTool instances
    """
    tools = []
    for client in self._clients.values():
        if client.is_connected:
            tools.extend(client.tools)
    return tools

vllm_mlx.mcp.manager.MCPClientManager.get_all_tools_openai

get_all_tools_openai() -> List[Dict[str, Any]]

Get all tools in OpenAI function calling format.

Returns:

• List[Dict[str, Any]] –

  List of OpenAI-compatible tool definitions

Source code in vllm_mlx/mcp/manager.py

def get_all_tools_openai(self) -> List[Dict[str, Any]]:
    """
    Get all tools in OpenAI function calling format.

    Returns:
        List of OpenAI-compatible tool definitions
    """
    return mcp_tools_to_openai(self.get_all_tools())

vllm_mlx.mcp.manager.MCPClientManager.get_merged_tools

get_merged_tools(user_tools: Optional[List[Dict[str, Any]]] = None) -> List[Dict[str, Any]]

Get MCP tools merged with user-provided tools.

User tools take precedence on name conflicts.

Parameters:

• user_tools (Optional[List[Dict[str, Any]]], default: None ) –

  Optional user-provided tools in OpenAI format

Returns:

• List[Dict[str, Any]] –

  Combined list of tools in OpenAI format

Source code in vllm_mlx/mcp/manager.py

def get_merged_tools(
    self,
    user_tools: Optional[List[Dict[str, Any]]] = None,
) -> List[Dict[str, Any]]:
    """
    Get MCP tools merged with user-provided tools.

    User tools take precedence on name conflicts.

    Args:
        user_tools: Optional user-provided tools in OpenAI format

    Returns:
        Combined list of tools in OpenAI format
    """
    return merge_tools(self.get_all_tools(), user_tools)

vllm_mlx.mcp.manager.MCPClientManager.get_server_status

get_server_status() -> List[MCPServerStatus]

Get status of all servers.

Returns:

• List[MCPServerStatus] –

  List of MCPServerStatus for each server

Source code in vllm_mlx/mcp/manager.py

def get_server_status(self) -> List[MCPServerStatus]:
    """
    Get status of all servers.

    Returns:
        List of MCPServerStatus for each server
    """
    return [client.get_status() for client in self._clients.values()]

vllm_mlx.mcp.manager.MCPClientManager.get_client

get_client(server_name: str) -> Optional[MCPClient]

Get client for a specific server.

Parameters:

• server_name (str) –

  Name of the server

Returns:

• Optional[MCPClient] –

  MCPClient instance or None if not found

Source code in vllm_mlx/mcp/manager.py

def get_client(self, server_name: str) -> Optional[MCPClient]:
    """
    Get client for a specific server.

    Args:
        server_name: Name of the server

    Returns:
        MCPClient instance or None if not found
    """
    return self._clients.get(server_name)

vllm_mlx.mcp.manager.MCPClientManager.execute_tool async

execute_tool(full_name: str, arguments: Dict[str, Any], timeout: Optional[float] = None) -> MCPToolResult

Execute a tool by its full name (server__tool).

Parameters:

• full_name (str) –

  Full tool name with server prefix

• arguments (Dict[str, Any]) –

  Tool arguments

• timeout (Optional[float], default: None ) –

  Optional timeout in seconds

Returns:

• MCPToolResult –

  MCPToolResult with the result or error

Source code in vllm_mlx/mcp/manager.py

async def execute_tool(
    self,
    full_name: str,
    arguments: Dict[str, Any],
    timeout: Optional[float] = None,
) -> MCPToolResult:
    """
    Execute a tool by its full name (server__tool).

    Args:
        full_name: Full tool name with server prefix
        arguments: Tool arguments
        timeout: Optional timeout in seconds

    Returns:
        MCPToolResult with the result or error
    """
    # Parse full name
    server_name, tool_name, _ = openai_call_to_mcp(
        {"function": {"name": full_name, "arguments": "{}"}}
    )

    # If no server prefix, try to find the tool
    if not server_name:
        server_name = self._find_tool_server(full_name)
        tool_name = full_name

    if not server_name:
        return MCPToolResult(
            tool_name=full_name,
            content=None,
            is_error=True,
            error_message=f"Tool '{full_name}' not found in any connected server",
        )

    # Get client
    client = self._clients.get(server_name)
    if not client:
        return MCPToolResult(
            tool_name=full_name,
            content=None,
            is_error=True,
            error_message=f"Server '{server_name}' not found",
        )

    if not client.is_connected:
        return MCPToolResult(
            tool_name=full_name,
            content=None,
            is_error=True,
            error_message=f"Server '{server_name}' is not connected",
        )

    # Execute tool
    return await client.call_tool(
        tool_name,
        arguments,
        timeout=timeout or self.config.default_timeout,
    )

vllm_mlx.mcp.manager.MCPClientManager.execute_tool_call async

execute_tool_call(tool_call: Dict[str, Any], timeout: Optional[float] = None) -> MCPToolResult

Execute a tool call from OpenAI format.

Parameters:

• tool_call (Dict[str, Any]) –

  OpenAI tool call object

• timeout (Optional[float], default: None ) –

  Optional timeout in seconds

Returns:

• MCPToolResult –

  MCPToolResult with the result or error

Source code in vllm_mlx/mcp/manager.py

async def execute_tool_call(
    self,
    tool_call: Dict[str, Any],
    timeout: Optional[float] = None,
) -> MCPToolResult:
    """
    Execute a tool call from OpenAI format.

    Args:
        tool_call: OpenAI tool call object
        timeout: Optional timeout in seconds

    Returns:
        MCPToolResult with the result or error
    """
    server_name, tool_name, arguments = openai_call_to_mcp(tool_call)

    if server_name:
        full_name = f"{server_name}__{tool_name}"
    else:
        full_name = tool_name

    return await self.execute_tool(full_name, arguments, timeout)

vllm_mlx.mcp.manager.MCPClientManager._find_tool_server

_find_tool_server(tool_name: str) -> Optional[str]

Find which server has a tool by name.

Parameters:

• tool_name (str) –

  Tool name (without server prefix)

Returns:

• Optional[str] –

  Server name or None if not found

Source code in vllm_mlx/mcp/manager.py

def _find_tool_server(self, tool_name: str) -> Optional[str]:
    """
    Find which server has a tool by name.

    Args:
        tool_name: Tool name (without server prefix)

    Returns:
        Server name or None if not found
    """
    for client in self._clients.values():
        if client.is_connected:
            for tool in client.tools:
                if tool.name == tool_name:
                    return client.name
    return None

vllm_mlx.mcp.manager.MCPClientManager.refresh_tools async

refresh_tools()

Refresh tools from all connected servers.

Source code in vllm_mlx/mcp/manager.py

async def refresh_tools(self):
    """Refresh tools from all connected servers."""
    tasks = [
        client.refresh_tools()
        for client in self._clients.values()
        if client.is_connected
    ]
    if tasks:
        await asyncio.gather(*tasks, return_exceptions=True)

vllm_mlx.mcp.manager.MCPClientManager.reconnect async

reconnect(server_name: Optional[str] = None)

Reconnect to server(s).

Parameters:

• server_name (Optional[str], default: None ) –

  Specific server to reconnect, or None for all

Source code in vllm_mlx/mcp/manager.py

async def reconnect(self, server_name: Optional[str] = None):
    """
    Reconnect to server(s).

    Args:
        server_name: Specific server to reconnect, or None for all
    """
    if server_name:
        client = self._clients.get(server_name)
        if client:
            await client.disconnect()
            await client.connect()
    else:
        # Reconnect all
        for client in self._clients.values():
            await client.disconnect()
            await client.connect()

Complete contract reference

Expand any definition for its exact inputs, annotations, defaults, return contract, directly raised exceptions, source-grounded behavior, and immutable line link. This section includes private and nested definitions that ordinary API generators omit.

vllm_mlx.mcp.manager.MCPClientManager · class

vllm_mlx.mcp.manager.MCPClientManager(config: MCPConfig)

Manages multiple MCP server connections.

Parameters

Name	Type	Required	Default	Description
config	MCPConfig	yes	none	MCP configuration with server definitions

Returns

• Constructs: vllm_mlx.mcp.manager.MCPClientManager

Exceptions and behavior

Class MCPClientManager declares 14 direct member(s). No direct raise statement appears in this definition.

View source #L22-L301.

vllm_mlx.mcp.manager.MCPClientManager.__init__ · method

vllm_mlx.mcp.manager.MCPClientManager.__init__(config: MCPConfig) -> not annotated

Initialize MCP Client Manager.

Parameters

Name	Type	Required	Default	Description
config	MCPConfig	yes	none	MCP configuration with server definitions

Returns

• Type: not annotated

Exceptions and behavior

Method MCPClientManager.__init__ updates self.config, self._clients, self._started, self._lock; calls asyncio.Lock, config.servers.items, MCPClient. No direct raise statement appears in this definition.

View source #L33-L47.

vllm_mlx.mcp.manager.MCPClientManager.is_started · method

vllm_mlx.mcp.manager.MCPClientManager.is_started() -> bool

Check if manager has been started.

Parameters

This callable has no explicit inputs.

Returns

• Type: bool
• Direct return expressions: self._started

Exceptions and behavior

Method MCPClientManager.is_started returns self._started. No direct raise statement appears in this definition.

View source #L50-L52.

vllm_mlx.mcp.manager.MCPClientManager.start · method

async vllm_mlx.mcp.manager.MCPClientManager.start() -> not annotated

Start the manager and connect to all enabled servers.

Parameters

This callable has no explicit inputs.

Returns

• Type: not annotated
• Direct return expressions: None

Exceptions and behavior

Method MCPClientManager.start updates self._started; calls logger.info, len, client.connect, self._clients.values; awaits asynchronous work; returns None. No direct raise statement appears in this definition.

View source #L54-L96.

vllm_mlx.mcp.manager.MCPClientManager.stop · method

async vllm_mlx.mcp.manager.MCPClientManager.stop() -> not annotated

Stop the manager and disconnect from all servers.

Parameters

This callable has no explicit inputs.

Returns

• Type: not annotated
• Direct return expressions: None

Exceptions and behavior

Method MCPClientManager.stop updates self._started; calls logger.info, client.disconnect, self._clients.values, asyncio.gather; awaits asynchronous work; returns None. No direct raise statement appears in this definition.

View source #L98-L112.

vllm_mlx.mcp.manager.MCPClientManager.get_all_tools · method

vllm_mlx.mcp.manager.MCPClientManager.get_all_tools() -> List[MCPTool]

Get all tools from all connected servers.

Parameters

This callable has no explicit inputs.

Returns

• Type: List[MCPTool]
• Direct return expressions: tools

Exceptions and behavior

Method MCPClientManager.get_all_tools calls self._clients.values, tools.extend; returns tools. No direct raise statement appears in this definition.

View source #L114-L125.

vllm_mlx.mcp.manager.MCPClientManager.get_all_tools_openai · method

vllm_mlx.mcp.manager.MCPClientManager.get_all_tools_openai() -> List[Dict[str, Any]]

Get all tools in OpenAI function calling format.

Parameters

This callable has no explicit inputs.

Returns

• Type: List[Dict[str, Any]]
• Direct return expressions: mcp_tools_to_openai(self.get_all_tools())

Exceptions and behavior

Method MCPClientManager.get_all_tools_openai calls mcp_tools_to_openai, self.get_all_tools; returns mcp_tools_to_openai(self.get_all_tools()). No direct raise statement appears in this definition.

View source #L127-L134.

vllm_mlx.mcp.manager.MCPClientManager.get_merged_tools · method

vllm_mlx.mcp.manager.MCPClientManager.get_merged_tools(user_tools: Optional[List[Dict[str, Any]]] = None) -> List[Dict[str, Any]]

Get MCP tools merged with user-provided tools.

Parameters

Name	Type	Required	Default	Description
user_tools	Optional[List[Dict[str, Any]]]	no	None	Optional user-provided tools in OpenAI format

Returns

• Type: List[Dict[str, Any]]
• Direct return expressions: merge_tools(self.get_all_tools(), user_tools)

Exceptions and behavior

Method MCPClientManager.get_merged_tools calls merge_tools, self.get_all_tools; returns merge_tools(self.get_all_tools(), user_tools). No direct raise statement appears in this definition.

View source #L136-L151.

vllm_mlx.mcp.manager.MCPClientManager.get_server_status · method

vllm_mlx.mcp.manager.MCPClientManager.get_server_status() -> List[MCPServerStatus]

Get status of all servers.

Parameters

This callable has no explicit inputs.

Returns

• Type: List[MCPServerStatus]
• Direct return expressions: [client.get_status() for client in self._clients.values()]

Exceptions and behavior

Method MCPClientManager.get_server_status calls client.get_status, self._clients.values; returns [client.get_status() for client in self._clients.values()]. No direct raise statement appears in this definition.

View source #L153-L160.

vllm_mlx.mcp.manager.MCPClientManager.get_client · method

vllm_mlx.mcp.manager.MCPClientManager.get_client(server_name: str) -> Optional[MCPClient]

Get client for a specific server.

Parameters

Name	Type	Required	Default	Description
server_name	str	yes	none	Name of the server

Returns

• Type: Optional[MCPClient]
• Direct return expressions: self._clients.get(server_name)

Exceptions and behavior

Method MCPClientManager.get_client calls self._clients.get; returns self._clients.get(server_name). No direct raise statement appears in this definition.

View source #L162-L172.

vllm_mlx.mcp.manager.MCPClientManager.execute_tool · method

async vllm_mlx.mcp.manager.MCPClientManager.execute_tool(full_name: str, arguments: Dict[str, Any], timeout: Optional[float] = None) -> MCPToolResult

Execute a tool by its full name (server__tool).

Parameters

Name	Type	Required	Default	Description
full_name	str	yes	none	Full tool name with server prefix
arguments	Dict[str, Any]	yes	none	Tool arguments
timeout	Optional[float]	no	None	Optional timeout in seconds

Returns

• Type: MCPToolResult
• Direct return expressions: MCPToolResult(tool_name=full_name, content=None, is_error=True, error_message=f"Tool '{full_name}' not found in any con…; MCPToolResult(tool_name=full_name, content=None, is_error=True, error_message=f"Server '{server_name}' not found"); MCPToolResult(tool_name=full_name, content=None, is_error=True, error_message=f"Server '{server_name}' is not connected…; await client.call_tool(tool_name, arguments, timeout=timeout or self.config.default_timeout)

Exceptions and behavior

Method MCPClientManager.execute_tool calls openai_call_to_mcp, self._find_tool_server, MCPToolResult, self._clients.get; awaits asynchronous work; has 4 explicit return paths. No direct raise statement appears in this definition.

View source #L174-L232.

vllm_mlx.mcp.manager.MCPClientManager.execute_tool_call · method

async vllm_mlx.mcp.manager.MCPClientManager.execute_tool_call(tool_call: Dict[str, Any], timeout: Optional[float] = None) -> MCPToolResult

Execute a tool call from OpenAI format.

Parameters

Name	Type	Required	Default	Description
tool_call	Dict[str, Any]	yes	none	OpenAI tool call object
timeout	Optional[float]	no	None	Optional timeout in seconds

Returns

• Type: MCPToolResult
• Direct return expressions: await self.execute_tool(full_name, arguments, timeout)

Exceptions and behavior

Method MCPClientManager.execute_tool_call calls openai_call_to_mcp, self.execute_tool; awaits asynchronous work; returns await self.execute_tool(full_name, arguments, timeout). No direct raise statement appears in this definition.

View source #L234-L256.

vllm_mlx.mcp.manager.MCPClientManager._find_tool_server · method

vllm_mlx.mcp.manager.MCPClientManager._find_tool_server(tool_name: str) -> Optional[str]

Find which server has a tool by name.

Parameters

Name	Type	Required	Default	Description
tool_name	str	yes	none	Tool name (without server prefix)

Returns

• Type: Optional[str]
• Direct return expressions: client.name; None

Exceptions and behavior

Method MCPClientManager._find_tool_server calls self._clients.values; has 2 explicit return paths. No direct raise statement appears in this definition.

View source #L258-L273.

vllm_mlx.mcp.manager.MCPClientManager.refresh_tools · method

async vllm_mlx.mcp.manager.MCPClientManager.refresh_tools() -> not annotated

Refresh tools from all connected servers.

Parameters

This callable has no explicit inputs.

Returns

• Type: not annotated

Exceptions and behavior

Method MCPClientManager.refresh_tools calls client.refresh_tools, self._clients.values, asyncio.gather; awaits asynchronous work. No direct raise statement appears in this definition.

View source #L275-L283.

vllm_mlx.mcp.manager.MCPClientManager.reconnect · method

async vllm_mlx.mcp.manager.MCPClientManager.reconnect(server_name: Optional[str] = None) -> not annotated

Reconnect to server(s).

Parameters

Name	Type	Required	Default	Description
server_name	Optional[str]	no	None	Specific server to reconnect, or None for all

Returns

• Type: not annotated

Exceptions and behavior

Method MCPClientManager.reconnect calls self._clients.get, client.disconnect, client.connect, self._clients.values; awaits asynchronous work. No direct raise statement appears in this definition.

View source #L285-L301.

Complete symbol map

This map also includes private definitions and nested helpers. The signature column exposes every explicit input even when an internal helper has no dedicated parameter prose.

Symbol	Kind	Signature and inputs	What it does	Source
MCPClientManager	class	MCPClientManager(config: MCPConfig)	Manages multiple MCP server connections.	#L22-L301
MCPClientManager.__init__	method	MCPClientManager.__init__(config: MCPConfig) -> not annotated	Initialize MCP Client Manager.	#L33-L47
MCPClientManager.is_started	method	MCPClientManager.is_started() -> bool	Check if manager has been started.	#L50-L52
MCPClientManager.start	method	async MCPClientManager.start() -> not annotated	Start the manager and connect to all enabled servers.	#L54-L96
MCPClientManager.stop	method	async MCPClientManager.stop() -> not annotated	Stop the manager and disconnect from all servers.	#L98-L112
MCPClientManager.get_all_tools	method	MCPClientManager.get_all_tools() -> List[MCPTool]	Get all tools from all connected servers.	#L114-L125
MCPClientManager.get_all_tools_openai	method	MCPClientManager.get_all_tools_openai() -> List[Dict[str, Any]]	Get all tools in OpenAI function calling format.	#L127-L134
MCPClientManager.get_merged_tools	method	MCPClientManager.get_merged_tools(user_tools: Optional[List[Dict[str, Any]]] = None) -> List[Dict[str, Any]]	Get MCP tools merged with user-provided tools.	#L136-L151
MCPClientManager.get_server_status	method	MCPClientManager.get_server_status() -> List[MCPServerStatus]	Get status of all servers.	#L153-L160
MCPClientManager.get_client	method	MCPClientManager.get_client(server_name: str) -> Optional[MCPClient]	Get client for a specific server.	#L162-L172
MCPClientManager.execute_tool	method	async MCPClientManager.execute_tool(full_name: str, arguments: Dict[str, Any], timeout: Optional[float] = None) -> MCPToolResult	Execute a tool by its full name (server__tool).	#L174-L232
MCPClientManager.execute_tool_call	method	async MCPClientManager.execute_tool_call(tool_call: Dict[str, Any], timeout: Optional[float] = None) -> MCPToolResult	Execute a tool call from OpenAI format.	#L234-L256
MCPClientManager._find_tool_server	method	MCPClientManager._find_tool_server(tool_name: str) -> Optional[str]	Find which server has a tool by name.	#L258-L273
MCPClientManager.refresh_tools	method	async MCPClientManager.refresh_tools() -> not annotated	Refresh tools from all connected servers.	#L275-L283
MCPClientManager.reconnect	method	async MCPClientManager.reconnect(server_name: Optional[str] = None) -> not annotated	Reconnect to server(s).	#L285-L301