Backtestslitellmrun-20261019-033420#44831

Issue #44831 Merged fix PR #46225 Run 19 Oct 2026 · run-20261019-033420 BerriAI/litellm

[Bug]: MCP tools/call with an unprefixed tool name on /{server_name}/mcp resolves via the global tool-name mapping, not the server in the path (404 when cold, 403 when another server has a tool with the same name)

Better

Our patch was judged better than the merged fix.

In this judgment, Patch B = our agent, Patch A = the merged fix.

Both patches fix the root cause the same way: when the request is scoped to exactly one server (path or x-mcp-servers), pass that server as requested_server_id so execute_mcp_tool resolves the bare name against it instead of the process-wide tool_name_to_mcp_server_name_mapping. Both pass all five independent tests. The differences favor B. (1) Robustness: A passes requested_server_id as an explicit keyword alongside **kwargs; if any caller already forwards requested_server_id through kwargs, call_mcp_tool raises a duplicate-keyword TypeError. B pops it from kwargs first and only falls back to the scoped server, which is safe either way and respects an explicitly supplied id. (2) Coverage: B also applies the scoping in tool_search.handle_mcp_tool_call, the virtual-MCP tool-call path that calls execute_mcp_tool directly; A leaves that path resolving through the global mapping, so the same 403/404 symptom would persist there. (3) Tests: B's tests drive GatewayOperations().execute with a real MCPServerManager and a seeded mapping, covering cold mapping, collision in both directions, the unscoped /mcp endpoint still using the mapping, and the tool_search path. A's tests mock out listing and dispatch and cover cold plus the ambiguous-scope case, but A also rewrites two existing tests (27 lines removed) to swap the server-resolution mock for server_exposes_tool and change their assertions, which is more churn and weakens the existing mapping-path coverage; B merely drops the mcp_servers arg so those tests keep exercising the mapping path they were written for. A's stricter len(mcp_servers)==1 check is a reasonable conservative choice but not enough to offset B's broader, safer fix.

Four judges ruled on this ticket in parallel, and the verdict comes from counting their votes. Each saw the issue and the two patches, labelled A and B in random order (two of them saw ours as A), with issue links and version numbers removed. Where tests could check the fix, they also saw the results of tests a separate agent wrote for the issue, run on both patches. None was told which patch was ours. The reasoning above is one judge's, shown verbatim.

Solve

46m 33s

Wall-clock time in the container

Full test suite

Not run

The harness did not reach the test stage

Contamination audit

Clean

No sign the agent saw the real fix

Patch size

118vs 139 merged

Changed lines, ours vs merged

Description

On a single-server MCP endpoint (/{server_name}/mcp), a tools/call with an unprefixed tool name is not resolved against the server in the URL path. LiteLLM resolves it through the process-wide tool_name_to_mcp_server_name_mapping, which is keyed by the unprefixed tool name, filled only by tools/list, and overwritten by whichever server was listed last. So the outcome depends on what any caller listed before:

  1. Cold mapping → 404. If nobody has listed the server since startup (or since another server was deleted, which removes its entries), the call returns Error: Tool '<tool>' not found. This still happens on v1.104.0, which already includes #42072 (_list_tools_before_first_call). The prefixed name works on the same cold worker.
  2. Name collision → 403. If two servers expose a tool with the same name, the mapping points to the server listed last. Calling the tool on the other server's endpoint returns Error: User not allowed to call this tool., even though the key can access the server in the path. Listing the second server flips it, and the first server starts returning 403.

One caller's tools/list changes how another caller's tools/call resolves. In our deployment, several servers share tool names (they are instances of the same MCP app, and all of them expose a common get_task_result tool), so calls fail intermittently depending on traffic.

The prefixed name (<alias>-<tool>) always works.

Config

Kubernetes, 1 replica, DB-managed MCP servers (store_model_in_db: true), virtual keys

LiteLLM Version

v1.104.0

Steps to Repro

Setup:

  • Single replica and single worker.
  • Two DB-managed MCP servers, server_a and server_b, created through POST /v1/mcp/server with transport: http and auth_type: none. Both expose a tool with the same name, list_items.
  • $KEY is a virtual key with access to both servers.
  • The proxy has just been restarted.

Helper used in the steps below:

H=http://localhost:4000
call() {
  curl -s -X POST "$H/$1/mcp" \
    -H "Authorization: Bearer $KEY" \
    -H "Accept: application/json, text/event-stream" \
    -H "Content-Type: application/json" \
    -d "{\"jsonrpc\":\"2.0\",\"id\":1,\"method\":\"$2\",\"params\":$3}"
}

1. Cold mapping, unprefixed name → 404. It keeps failing on retries.

call server_b tools/call '{"name":"list_items","arguments":{}}'
{"jsonrpc":"2.0","id":1,"result":{"content":[{"type":"text","text":"Error: Tool 'list_items' not found"}],"isError":true}}

2. Same call with the prefixed name → OK.

call server_b tools/call '{"name":"server_b-list_items","arguments":{}}'

3. List server_a, then call server_b unprefixed → 403.

call server_a tools/list '{}'
call server_b tools/call '{"name":"list_items","arguments":{}}'
{"jsonrpc":"2.0","id":1,"result":{"content":[{"type":"text","text":"Error: User not allowed to call this tool."}],"isError":true}}

4. List server_b → server_b works, but server_a now returns 403.

call server_b tools/list '{}'
call server_b tools/call '{"name":"list_items","arguments":{}}'   # OK
call server_a tools/call '{"name":"list_items","arguments":{}}'   # 403
{"jsonrpc":"2.0","id":1,"result":{"content":[{"type":"text","text":"Error: User not allowed to call this tool."}],"isError":true}}

5. Delete server_b → unprefixed calls to server_a return 404 until server_a is listed again.

curl -s -X DELETE "$H/v1/mcp/server/<server_b_id>" -H "Authorization: Bearer $MASTER_KEY"
call server_a tools/call '{"name":"list_items","arguments":{}}'
{"jsonrpc":"2.0","id":1,"result":{"content":[{"type":"text","text":"Error: Tool 'list_items' not found"}],"isError":true}}

Expected behaviour

On /{server_name}/mcp, an unprefixed tool name should resolve against the server in the path. The result should not depend on which servers any caller listed earlier, and two servers exposing the same tool name should not affect each other.

Relevant code (v1.104.0, litellm/proxy/_experimental/mcp_server/)

  • mcp_server_manager.py (~6536): after listing, tool_name_to_mcp_server_name_mapping[original_name] = server.name. The key is the unprefixed name, so the last server listed wins.
  • mcp_server_manager.py (~6553): resolution checks that mapping first.
  • operations.py (~1890): first_call_target uses requested_server for unprefixed names. Since we still get 404 for unprefixed calls on /{server_name}/mcp, requested_server seems not to be set from the URL path on the MCP protocol route; #42655 points at the same thing. I haven't traced it further.
  • operations.py (~1965): when the mapping points to a server outside the ones allowed for the request path, the call returns User not allowed to call this tool.
  • mcp_server_manager.py (~2823-2846): deleting a server removes its mapping entries, which re-colds tools that other servers share.

Related

  • #42655 / #42072: single-server endpoint does not use the server in the path. Fixed for the cold-worker case in v1.104.0-rc.1, but unprefixed names on /{server_name}/mcp still fail.
  • #44373, #39751, #24089: cold or empty tool_name_to_mcp_server_name_mapping → 404.
  • None of these cover the cross-server collision (403) case.

Relevant log output

LiteLLM:ERROR: server.py - HTTPException in MCP tool call: 404: Tool 'list_items' not found
LiteLLM:ERROR: server.py - HTTPException in MCP tool call: 403: User not allowed to call this tool.

Which part of LiteLLM is this about?

MCP: servers, tools, OAuth

How are you deploying?

Docker

The two patches

Our patch+114 −4
litellm/proxy/_experimental/mcp_server/operations.pyindex 5087bc6df0..7677b45cd1 100644@@ -216,6 +216,7 @@ __all__ = (     "mcp_get_prompt",     "mcp_read_resource",     "raise_denied_scoped_mcp_access",+    "scoped_single_server_id", )  @@ -573,6 +574,20 @@ async def _get_allowed_mcp_servers_from_mcp_server_names(     return allowed_mcp_servers  +def scoped_single_server_id(+    mcp_servers: Sequence[str] | None,+    scoped_mcp_servers: Sequence[MCPServer],+) -> str | None:+    """The server a path- or header-scoped request targets when its scope resolves to exactly one server.++    Unprefixed tool names on ``/{server_name}/mcp`` must route to that server rather than through+    the process-wide tool-name mapping, which the last listed server overwrites.+    """+    if mcp_servers is None or len(scoped_mcp_servers) != 1:+        return None+    return scoped_mcp_servers[0].server_id++ def _http_detail_message(detail: object) -> str:     return str(detail.get("error")) if isinstance(detail, dict) and detail.get("error") else str(detail) @@ -2512,6 +2527,10 @@ async def call_mcp_tool(                 detail="User not allowed to call this tool.",             ) +        requested_server_id: Final[str | None] = kwargs.pop("requested_server_id", None) or scoped_single_server_id(+            mcp_servers, allowed_mcp_servers+        )+         # Delegate to execute_mcp_tool for execution         response = await execute_mcp_tool(             name=name,@@ -2528,6 +2547,7 @@ async def call_mcp_tool(             input_responses=input_responses,             request_state=request_state,             incoming_bearer_token=incoming_bearer_token,+            requested_server_id=requested_server_id,             **kwargs,         )     except Exception as e:litellm/proxy/_experimental/mcp_server/tool_search.pyindex 23a63c00bd..333192e96b 100644@@ -688,6 +688,7 @@ async def handle_mcp_tool_call(         _get_allowed_mcp_servers,         execute_mcp_tool,         raise_denied_scoped_mcp_access,+        scoped_single_server_id,     )      allowed_mcp_servers: Final = await _get_allowed_mcp_servers(@@ -722,7 +723,7 @@ async def handle_mcp_tool_call(         raw_headers=raw_headers,         client_ip=client_ip,         litellm_logging_obj=litellm_logging_obj,-        requested_server_id=requested_server_id,+        requested_server_id=requested_server_id or scoped_single_server_id(mcp_servers, allowed_mcp_servers),         guardrail_context=guardrail_context,         incoming_bearer_token=incoming_bearer_token,     )tests/unit/proxy/_experimental/mcp_server/test_mcp_server.pyindex 3345683517..e07728055b 100644@@ -3024,7 +3024,6 @@ async def test_call_mcp_tool_uses_manager_permission_lookup():         result = await call_mcp_tool(             name=f"{mock_server.name}/gmail_send_email",             arguments={"body": "hello"},-            mcp_servers=["test_server"],         )      assert result == expected_response@@ -3097,11 +3096,11 @@ async def test_call_mcp_tool_resolves_unprefixed_tool_name_and_checks_permission         mock_tool_registry.get_tool.return_value = None         mock_handle_managed.return_value = expected_response -        # Call with UNPREFIXED tool name; server should be resolved via mapping+        # Call with UNPREFIXED tool name on the unscoped /mcp endpoint; server should be+        # resolved via mapping (a path-scoped endpoint routes to the path server instead)         result = await call_mcp_tool(             name="gmail_send_email",             arguments={"body": "hello"},-            mcp_servers=["test_server"],         )      assert result == expected_responsetests/unit/proxy/_experimental/mcp_server/test_operations.pyindex dcc4eb1a57..c44a41f0c9 100644@@ -1590,3 +1590,93 @@ async def test_guardrail_context_never_recovers_a_previous_request_bearer(         assert capture.data["incoming_bearer_token"] is None     finally:         auth_context_var.reset(previous)+++def _scoped_endpoint_manager(monkeypatch: pytest.MonkeyPatch, mapping: dict[str, str]) -> AsyncMock:+    """Two servers exposing ``list_items``; returns the double standing in for the upstream call."""+    from mcp.types import CallToolResult, TextContent++    from litellm.proxy import proxy_server+    from litellm.proxy._experimental.mcp_server.mcp_server_manager import MCPServerManager++    manager: Final = MCPServerManager()+    manager.config_mcp_servers = {+        f"id-{name}": MCPServer(+            server_id=f"id-{name}", name=name, server_name=name, alias=name, transport=MCPTransport.http+        )+        for name in ("server_a", "server_b")+    }+    manager.tool_name_to_mcp_server_name_mapping = dict(mapping)+    upstream: Final = AsyncMock(+        side_effect=lambda server_name, **_: CallToolResult(content=[TextContent(type="text", text=server_name)])+    )+    monkeypatch.setattr(proxy_server, "prisma_client", None)+    monkeypatch.setattr(operations, "global_mcp_server_manager", manager)+    monkeypatch.setattr(manager, "get_allowed_mcp_servers", AsyncMock(return_value=["id-server_a", "id-server_b"]))+    monkeypatch.setattr(manager, "server_exposes_tool", lambda server, tool_name: True)+    monkeypatch.setattr(manager, "call_tool", upstream)+    return upstream+++@pytest.mark.asyncio+@pytest.mark.parametrize(+    ("mapping", "path_server"),+    [+        pytest.param({}, "server_b", id="cold-mapping"),+        pytest.param({"list_items": "server_a"}, "server_b", id="mapping-points-at-other-server-b"),+        pytest.param({"list_items": "server_b"}, "server_a", id="mapping-points-at-other-server-a"),+    ],+)+async def test_unprefixed_tools_call_on_single_server_endpoint_routes_to_path_server(+    monkeypatch: pytest.MonkeyPatch, mapping: dict[str, str], path_server: str+) -> None:+    from mcp.types import CallToolRequest, CallToolRequestParams++    upstream: Final = _scoped_endpoint_manager(monkeypatch, mapping)++    result: Final = await GatewayOperations().execute(+        CallToolRequest(params=CallToolRequestParams(name="list_items", arguments={})),+        prepare_context(mcp_servers=[path_server]),+    )++    assert result.is_error is not True, result+    assert [block.text for block in result.content] == [path_server]+    upstream.assert_awaited_once()+    assert upstream.await_args.kwargs["server_name"] == path_server+    assert upstream.await_args.kwargs["name"] == "list_items"+++@pytest.mark.asyncio+async def test_unprefixed_virtual_mcp_tool_call_on_single_server_endpoint_routes_to_path_server(+    monkeypatch: pytest.MonkeyPatch,+) -> None:+    from litellm.proxy._experimental.mcp_server.tool_search import handle_mcp_tool_call++    upstream: Final = _scoped_endpoint_manager(monkeypatch, {"list_items": "server_a"})++    result: Final = await handle_mcp_tool_call(+        tool_name="list_items",+        arguments={},+        user_api_key_dict=UserAPIKeyAuth(api_key="sk-scoped"),+        mcp_servers=["server_b"],+    )++    assert result.is_error is not True, result+    assert upstream.await_args.kwargs["server_name"] == "server_b"+++@pytest.mark.asyncio+async def test_unprefixed_tools_call_without_path_scope_still_resolves_through_mapping(+    monkeypatch: pytest.MonkeyPatch,+) -> None:+    from mcp.types import CallToolRequest, CallToolRequestParams++    upstream: Final = _scoped_endpoint_manager(monkeypatch, {"list_items": "server_a"})++    result: Final = await GatewayOperations().execute(+        CallToolRequest(params=CallToolRequestParams(name="list_items", arguments={})),+        prepare_context(),+    )++    assert result.is_error is not True, result+    assert upstream.await_args.kwargs["server_name"] == "server_a" 
Merged fix · PR #46225+112 −27
litellm/proxy/_experimental/mcp_server/operations.pyindex 5087bc6df09..889ca709eb9 100644@@ -2451,6 +2451,20 @@ async def fire_mcp_tool_call_failure_logging(     )  +def _single_scoped_server(+    mcp_servers: Sequence[str] | None, allowed_mcp_servers: Sequence[MCPServer]+) -> MCPServer | None:+    """The one server a ``/{server_name}/mcp`` path or ``x-mcp-servers`` header scoped this call to.++    A bare tool name on such a request resolves against that server, the way a REST ``server_id``+    does, instead of against the per-process tool-name map, which stays empty for a server whose+    upstream only lists tools with the caller's own credentials until this process has listed it.+    """+    if mcp_servers is None or len(mcp_servers) != 1 or len(allowed_mcp_servers) != 1:+        return None+    return allowed_mcp_servers[0]++ @client @catalog_operation(lambda: global_mcp_server_manager) async def call_mcp_tool(@@ -2512,6 +2526,7 @@ async def call_mcp_tool(                 detail="User not allowed to call this tool.",             ) +        scoped_server: Final = _single_scoped_server(mcp_servers, allowed_mcp_servers)         # Delegate to execute_mcp_tool for execution         response = await execute_mcp_tool(             name=name,@@ -2528,6 +2543,7 @@ async def call_mcp_tool(             input_responses=input_responses,             request_state=request_state,             incoming_bearer_token=incoming_bearer_token,+            requested_server_id=scoped_server.server_id if scoped_server is not None else None,             **kwargs,         )     except Exception as e:tests/unit/proxy/_experimental/mcp_server/test_mcp_server.pyindex 3345683517b..de711d737d0 100644@@ -3000,11 +3000,7 @@ async def test_call_mcp_tool_uses_manager_permission_lookup():             "get_mcp_server_by_id",             return_value=mock_server,         ),-        patch.object(-            global_mcp_server_manager,-            "get_mcp_server_from_tool_name",-            return_value=mock_server,-        ) as mock_get_server,+        patch.object(global_mcp_server_manager, "server_exposes_tool", return_value=True),         patch(             "litellm.proxy._experimental.mcp_server.operations.global_mcp_tool_registry"         ) as mock_tool_registry,@@ -3029,24 +3025,18 @@ async def test_call_mcp_tool_uses_manager_permission_lookup():      assert result == expected_response     mock_get_allowed.assert_awaited_once()-    # We call `_get_mcp_server_from_tool_name` multiple times:-    # - for logging/metadata-    # - for resolving the server during dispatch-    # - and inside `call_tool` for guardrails/hooks-    # The exact count isn't important, only that it is used.-    assert mock_get_server.call_count >= 2-    # First call should use the prefixed tool name-    assert (-        mock_get_server.call_args_list[0][0][0]-        == f"{mock_server.name}/gmail_send_email"-    )+    # The request names exactly one server, so that server is the dispatch target+    # and the tool name reaches it untouched (the "/" is not a LiteLLM prefix).+    mock_handle_managed.assert_awaited_once()+    assert mock_handle_managed.await_args.kwargs["server_name"] == mock_server.name+    assert mock_handle_managed.await_args.kwargs["name"] == f"{mock_server.name}/gmail_send_email"   @pytest.mark.asyncio async def test_call_mcp_tool_resolves_unprefixed_tool_name_and_checks_permissions():     """-    Ensure `call_mcp_tool` correctly resolves the MCP server for an unprefixed tool-    name and enforces server-level permissions using that resolved server.+    Ensure `call_mcp_tool` resolves an unprefixed tool name on a request scoped to+    one server against that server and enforces server-level permissions with it.     """     from litellm.proxy._experimental.mcp_server.server import (         call_mcp_tool,@@ -3076,11 +3066,7 @@ async def test_call_mcp_tool_resolves_unprefixed_tool_name_and_checks_permission             "get_mcp_server_by_id",             return_value=mock_server,         ),-        patch.object(-            global_mcp_server_manager,-            "get_mcp_server_from_tool_name",-            return_value=mock_server,-        ) as mock_get_server,+        patch.object(global_mcp_server_manager, "server_exposes_tool", return_value=True),         patch(             "litellm.proxy._experimental.mcp_server.operations.global_mcp_tool_registry"         ) as mock_tool_registry,@@ -3097,7 +3083,7 @@ async def test_call_mcp_tool_resolves_unprefixed_tool_name_and_checks_permission         mock_tool_registry.get_tool.return_value = None         mock_handle_managed.return_value = expected_response -        # Call with UNPREFIXED tool name; server should be resolved via mapping+        # Call with UNPREFIXED tool name; the single server the request names is the target         result = await call_mcp_tool(             name="gmail_send_email",             arguments={"body": "hello"},@@ -3106,11 +3092,12 @@ async def test_call_mcp_tool_resolves_unprefixed_tool_name_and_checks_permission      assert result == expected_response     mock_get_allowed.assert_awaited_once()-    # We should resolve the server at least once using the unprefixed name-    assert mock_get_server.call_count >= 1-    assert mock_get_server.call_args_list[0][0][0] == "gmail_send_email"+    mock_handle_managed.assert_awaited_once()+    assert mock_handle_managed.await_args.kwargs["server_name"] == mock_server.name+    assert mock_handle_managed.await_args.kwargs["name"] == "gmail_send_email"     # Permissions check should be invoked with the resolved server name     mock_is_allowed.assert_called_once()+    assert mock_is_allowed.call_args.kwargs["server_name"] == mock_server.name   @pytest.mark.asynciotests/unit/proxy/_experimental/mcp_server/test_operations.pyindex dcc4eb1a570..af547ebf6c7 100644@@ -565,6 +565,88 @@ async def test_tools_call_warmup_does_not_consume_mcp_server_rpm() -> None:     assert [tool.name for tool in listing.tools] == ["echo"]  ++def _scoped_rig(+    monkeypatch: pytest.MonkeyPatch,+) -> tuple[MCPServer, MCPServer, AsyncMock, AsyncMock]:+    """Two config servers that both expose a bare ``list_rules`` on a manager that has listed neither."""+    from mcp.types import CallToolResult, TextContent++    from litellm.proxy import proxy_server+    from litellm.proxy._experimental.mcp_server.mcp_server_manager import MCPServerManager++    manager: Final = MCPServerManager()+    memory: Final = MCPServer(+        server_id="id-memory", name="memory_server", server_name="memory_server", transport=MCPTransport.http+    )+    other: Final = MCPServer(+        server_id="id-other", name="other_server", server_name="other_server", transport=MCPTransport.http+    )+    manager.config_mcp_servers = {server.server_id: server for server in (memory, other)}+    monkeypatch.setattr(proxy_server, "prisma_client", None)+    monkeypatch.setattr(operations, "global_mcp_server_manager", manager)+    monkeypatch.setattr(+        manager, "get_allowed_mcp_servers", AsyncMock(return_value=[memory.server_id, other.server_id])+    )+    monkeypatch.setattr(global_mcp_tool_registry, "published_tools", {})+    listing: Final = AsyncMock()+    monkeypatch.setattr(operations, "_get_tools_from_mcp_servers", listing)+    handled: Final = AsyncMock(+        return_value=CallToolResult(content=[TextContent(type="text", text="ok")], isError=False)+    )+    monkeypatch.setattr(operations, "_handle_managed_mcp_tool", handled)+    return memory, other, listing, handled+++@pytest.mark.asyncio+@pytest.mark.parametrize("scope", ["memory_server", "other_server"])+async def test_bare_tool_name_on_a_single_server_scope_routes_to_that_server_cold(+    monkeypatch: pytest.MonkeyPatch, scope: str+) -> None:+    """``/{server_name}/mcp`` (or ``x-mcp-servers`` naming one server) with the upstream's bare tool name+    must list and call the scoped server on a process whose tool-name map has never seen it, and when two+    servers share the bare name the scope decides (BerriAI/litellm#44831)."""+    memory, other, listing, handled = _scoped_rig(monkeypatch)+    expected: Final = memory if scope == "memory_server" else other++    async with operations.global_mcp_server_manager.catalog.operation():+        result: Final = await operations.call_mcp_tool(+            name="list_rules",+            arguments={},+            user_api_key_auth=UserAPIKeyAuth(api_key="sk-scoped"),+            mcp_servers=[scope],+        )++    assert result.is_error is False+    assert listing.await_args.kwargs["mcp_servers"] == [expected.server_id]+    assert handled.await_args.kwargs["server_name"] == expected.name+    assert handled.await_args.kwargs["name"] == "list_rules"+++@pytest.mark.asyncio+@pytest.mark.parametrize("mcp_servers", [None, ["memory_server", "other_server"]])+async def test_bare_tool_name_without_a_single_server_scope_is_still_unresolved_cold(+    monkeypatch: pytest.MonkeyPatch, mcp_servers: list[str] | None+) -> None:+    """The scope shortcut only applies when the request names exactly one server; an ambiguous bare name+    keeps today's answer rather than being guessed onto the first allowed server."""+    from fastapi import HTTPException++    _memory, _other, listing, handled = _scoped_rig(monkeypatch)++    async with operations.global_mcp_server_manager.catalog.operation():+        with pytest.raises(HTTPException) as unresolved:+            await operations.call_mcp_tool(+                name="list_rules",+                arguments={},+                user_api_key_auth=UserAPIKeyAuth(api_key="sk-scoped"),+                mcp_servers=mcp_servers,+            )++    assert unresolved.value.status_code == 404+    listing.assert_not_awaited()+    handled.assert_not_awaited()+ @pytest.mark.asyncio async def test_tools_call_pre_call_check_enforces_mcp_server_rpm() -> None:     from litellm.proxy._experimental.mcp_server.mcp_server_manager import MCPServerManager