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.
Python agentaichatgptdeepseekfine-tuninggemmaimage-generationllamallmllmsopenaipythonqwenreinforcement-learningself-hostedstable-diffusiontext-to-speechttsuiunsloth
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.pyindex 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.hostnameif "%" 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:+ continueif 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:+ raiseasync 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.pyindex 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 policyfrom core.inference import mcp_client, toolsfrom state import tool_policyfrom storage import mcp_servers_db+from utils import managed_provider_url_settingsfrom utils.account_context import OWNER, AccountContext, arun_as, current_account_id, run_asALICE = 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}])