Skip to content

Local UI to run and train LLMs and diffusion models. Supports GGUF, MLX, Qwen3.8, DeepSeek-V4.1, MiniMax-H3, Gemma 4, FLUX and more.

Studio: let managed accounts use local MCP servers when allowed (#16044)

Nilay082ad75155a4
diff --git a/studio/backend/core/inference/mcp_client.py b/studio/backend/core/inference/mcp_client.py
index 6990abc726a..bfc1e4a11e1 100644
--- a/studio/backend/core/inference/mcp_client.py
+++ b/studio/backend/core/inference/mcp_client.py
@@ -63,9 +63,15 @@ def _account_key(value):
return current_account_id(), value
-def _public_mcp_address(url: str) -> str:
+def _public_mcp_addresses(url: str) -> list[str]:
from fastapi import HTTPException
+ from core.inference.providers import _metadata_address, _metadata_host, managed_private_url_hint
+ from utils.managed_provider_url_settings import get_managed_private_provider_urls_allowed
+
+ private_allowed = get_managed_private_provider_urls_allowed()
detail = "Managed accounts may only use public-network HTTP MCP servers."
+ if not private_allowed:
+ detail += managed_private_url_hint()
try:
parsed = urlsplit(url)
if parsed.scheme not in ("http", "https") or not parsed.hostname:
@@ -75,6 +81,8 @@ def _public_mcp_address(url: str) -> str:
host = parsed.hostname
if "%" in host:
raise ValueError("Scoped addresses are not public")
+ if _metadata_host(host):
+ raise ValueError("Cloud metadata address")
port = parsed.port or (443 if parsed.scheme == "https" else 80)
addresses = socket.getaddrinfo(host, port, type = socket.SOCK_STREAM)
if not addresses:
@@ -82,9 +90,13 @@ def _public_mcp_address(url: str) -> str:
for *_, sockaddr in addresses:
address = ipaddress.ip_address(sockaddr[0])
address = getattr(address, "ipv4_mapped", None) or address
+ if _metadata_address(str(address)):
+ raise ValueError("Cloud metadata address")
+ if private_allowed:
+ continue
if not address.is_global or address.is_multicast or address.is_reserved:
raise ValueError("Non-public address")
- return addresses[0][4][0]
+ return list(dict.fromkeys(sockaddr[0] for *_, sockaddr in addresses))
except (OSError, ValueError, UnicodeError) as exc:
raise HTTPException(status_code = 400, detail = detail) from exc
@@ -99,7 +111,7 @@ def validate_mcp_address(url: str) -> None:
status_code = 400,
detail = "Only the installation owner may register local-command MCP servers.",
)
- _public_mcp_address(url)
+ _public_mcp_addresses(url)
def _public_http_client_factory(**kwargs):
@@ -115,18 +127,24 @@ def _public_http_client_factory(**kwargs):
self.transports = {}
async def handle_async_request(self, request):
- address = await asyncio.to_thread(_public_mcp_address, str(request.url))
+ addresses = await asyncio.to_thread(_public_mcp_addresses, str(request.url))
origin = (request.url.scheme, request.url.host, request.url.port)
if origin not in self.transports:
self.transports[origin] = http.AsyncHTTPTransport(trust_env = False)
- pinned = http.Request(
- method = request.method,
- url = request.url.copy_with(host = address),
- headers = request.headers,
- stream = request.stream,
- extensions = {**request.extensions, "sni_hostname": request.url.host},
- )
- return await self.transports[origin].handle_async_request(pinned)
+ # localhost answers ::1 first while most local servers bind 127.0.0.1 only.
+ for index, address in enumerate(addresses):
+ pinned = http.Request(
+ method = request.method,
+ url = request.url.copy_with(host = address),
+ headers = request.headers,
+ stream = request.stream,
+ extensions = {**request.extensions, "sni_hostname": request.url.host},
+ )
+ try:
+ return await self.transports[origin].handle_async_request(pinned)
+ except (http.ConnectError, http.ConnectTimeout):
+ if index == len(addresses) - 1:
+ raise
async def aclose(self):
for transport in self.transports.values():
diff --git a/studio/backend/tests/test_account_tool_isolation.py b/studio/backend/tests/test_account_tool_isolation.py
index f82001c1da4..071c2169e2a 100644
--- a/studio/backend/tests/test_account_tool_isolation.py
+++ b/studio/backend/tests/test_account_tool_isolation.py
@@ -17,6 +17,7 @@ from auth import policy
from core.inference import mcp_client, tools
from state import tool_policy
from storage import mcp_servers_db
+from utils import managed_provider_url_settings
from utils.account_context import OWNER, AccountContext, arun_as, current_account_id, run_as
ALICE = AccountContext("alice-id", "alice")
@@ -349,6 +350,110 @@ def test_mcp_dns_rejects_mixed_public_and_private_answers(monkeypatch):
run_as(ALICE, mcp_client.validate_mcp_address, "https://mixed.example/mcp")
+def _resolve_literal(host, port, **kwargs):
+ return [(socket.AF_INET, socket.SOCK_STREAM, 6, "", (host, port))]
+
+
+ "url", ["http://127.0.0.1:8321/mcp", "http://[::1]:8321/mcp", "http://192.168.1.20/mcp"]
+)
+def test_mcp_private_urls_follow_the_owners_local_connections_switch(monkeypatch, url):
+ monkeypatch.setattr(socket, "getaddrinfo", _resolve_literal)
+ switch = {"on": False}
+ monkeypatch.setattr(
+ managed_provider_url_settings,
+ "get_managed_private_provider_urls_allowed",
+ lambda: switch["on"],
+ )
+ with pytest.raises(HTTPException) as refusal:
+ run_as(ALICE, mcp_servers_db.create_server, id = "off", display_name = "Local", url = url)
+ assert "Settings > Accounts" in refusal.value.detail
+ switch["on"] = True
+ run_as(ALICE, mcp_servers_db.create_server, id = "on", display_name = "Local", url = url)
+ assert run_as(ALICE, mcp_servers_db.get_server, "on")["url"] == url
+
+
+ "url",
+ [
+ "http://169.254.169.254/mcp",
+ "http://metadata.google.internal/mcp",
+ "http://user:[email protected]/mcp",
+ "python local.py",
+ ],
+)
+def test_mcp_switch_never_opens_metadata_credentials_or_stdio(monkeypatch, url):
+ monkeypatch.setattr(socket, "getaddrinfo", _resolve_literal)
+ monkeypatch.setattr(
+ managed_provider_url_settings, "get_managed_private_provider_urls_allowed", lambda: True
+ )
+ with pytest.raises(HTTPException):
+ run_as(ALICE, mcp_client.validate_mcp_address, url)
+
+
+def test_mcp_public_transport_dials_loopback_once_the_owner_allows_it(monkeypatch):
+ seen = []
+ monkeypatch.setattr(
+ managed_provider_url_settings, "get_managed_private_provider_urls_allowed", lambda: True
+ )
+
+ async def check():
+ client = mcp_client._public_http_client_factory()
+ http = sys.modules[type(client).__module__.split(".")[0]]
+
+ async def send(transport, request):
+ seen.append(str(request.url))
+ if request.url.path == "/mcp":
+ return http.Response(302, headers = {"location": "http://169.254.169.254/x"})
+ return http.Response(200)
+
+ monkeypatch.setattr(http.AsyncHTTPTransport, "handle_async_request", send)
+ monkeypatch.setattr(socket, "getaddrinfo", _resolve_literal)
+ async with client:
+ with pytest.raises(HTTPException):
+ await client.get("http://127.0.0.1:8321/mcp")
+
+ asyncio.run(check())
+ assert seen == ["http://127.0.0.1:8321/mcp"]
+
+
+def test_mcp_public_transport_falls_back_to_the_next_localhost_address(monkeypatch):
+ import http.server
+
+ class NoContent(http.server.BaseHTTPRequestHandler):
+ def do_GET(self):
+ self.send_response(204)
+ self.end_headers()
+
+ server = http.server.HTTPServer(("127.0.0.1", 0), NoContent)
+ port = server.server_address[1]
+ threading.Thread(target = server.serve_forever, daemon = True).start()
+ resolve = socket.getaddrinfo
+
+ def localhost_ipv6_first(host, *args, **kwargs):
+ if host == "localhost":
+ return [
+ (socket.AF_INET6, socket.SOCK_STREAM, 6, "", ("::1", port, 0, 0)),
+ (socket.AF_INET, socket.SOCK_STREAM, 6, "", ("127.0.0.1", port)),
+ ]
+ return resolve(host, *args, **kwargs)
+
+ monkeypatch.setattr(socket, "getaddrinfo", localhost_ipv6_first)
+ monkeypatch.setattr(
+ managed_provider_url_settings, "get_managed_private_provider_urls_allowed", lambda: True
+ )
+
+ async def check():
+ async with mcp_client._public_http_client_factory() as client:
+ return (await client.get(f"http://localhost:{port}/mcp")).status_code
+
+ try:
+ assert asyncio.run(check()) == 204
+ finally:
+ server.shutdown()
+ server.server_close()
+
+
def test_mcp_cache_and_failure_cooloffs_are_private():
for account in ACCOUNTS:
run_as(account, mcp_client.cache_tools, "same", [{"name": account.username}])