Server profile

Unla MCP Gateway

Unla is a Go gateway that exposes existing APIs and MCP servers through MCP endpoints using configuration. It includes a management interface, recoverable sessions, multi-tenant support, and deployment options for containers or Kubernetes.

Server facts

Unla MCP Gateway

Tech

Runtime / language
nodeGo
Transports
stdio
Remote available
No
Authentication
Not specified

Activity

GitHub stars
2,241
Last commit
Data as of

Tags

  • Api Gateway
  • Configuration Management
  • Multi Tenant
  • Rest To Mcp

Overview

Unla MCP Gateway is a Go service for presenting existing REST APIs and MCP servers through MCP-compatible endpoints. Its configuration-driven approach uses YAML rather than requiring changes to the underlying applications. The README describes a management web interface for adding server definitions, as well as proxy paths for both APIs and existing MCP services. Supported responses can include text, images, and audio. This makes it relevant to teams that want to bring established services into an AI tooling environment while keeping the original service implementation intact.

Operational features include recoverable sessions, multi-tenant support, configuration history, and hot reloads. Configuration can be persisted on disk or through SQLite, PostgreSQL, or MySQL, with synchronization options based on operating-system signals, HTTP, or Redis PubSub. The project supports multiple replicas, Docker, Kubernetes, and Helm. Its quick start runs an all-in-one container, asks users to set administrator credentials and a JWT secret, and exposes both SSE and Streamable HTTP MCP URLs after configuration. OAuth pre-authentication is also listed. There are important boundaries: gRPC conversion, WebSocket conversion, and grouping or aggregation of MCP servers remain unchecked roadmap items. The README additionally warns that rapid development can bring compatibility changes and documentation lag, so upgrades need attention rather than assuming every release is interchangeable.

Install & configure

Requirements

  • Docker for the quick-start deployment
  • Administrator credentials and a JWT signing secret
  • An API or MCP server configuration to add in the management UI
Documented launch / install command
docker run -d --name unla -p 8080:80 -p 5234:5234 -p 5235:5235 -p 5335:5335 -p 5236:5236 -e ENV=production -e TZ=Asia/Shanghai -e 'APISERVER_JWT_SECRET_KEY=${APISERVER_JWT_SECRET_KEY}' -e 'SUPER_ADMIN_USERNAME=${SUPER_ADMIN_USERNAME}' -e 'SUPER_ADMIN_PASSWORD=${SUPER_ADMIN_PASSWORD}' --restart unless-stopped ghcr.io/amoylab/unla/allinone:latest

Export the environment variables before running the documented shell command so its substitutions resolve. Open http://localhost:8080/ to add a server configuration; the MCP URL is available after configuration. SSE is also supported.

Config file · macOS: ~/Library/Application Support/Claude/claude_desktop_config.json

Windows: %APPDATA%\Claude\claude_desktop_config.json

Use Settings → Developer → Edit Config when available. Do not assume a Linux configuration path; check the client documentation for your platform. Remote servers use the app’s connector flow when supported, not the local stdio file shown here. Merge this example with existing settings; do not overwrite unrelated servers.

A supported configuration example is not available for this client and transport. Check the client documentation for its connection flow; do not substitute an undocumented JSON format.

Read the Claude Desktop setup guide

Config file · Project: .cursor/mcp.json

User: ~/.cursor/mcp.json

The project path is relative to the workspace root. The tilde denotes your user home directory. Use Cursor’s MCP settings to confirm which configuration and scope your installed version is reading. Merge this example with existing settings; do not overwrite unrelated servers.

Cursor configuration
{
  "mcpServers": {
    "mcp-gateway": {
      "url": "http://localhost:5235/mcp/user/mcp"
    }
  }
}

Read the Cursor setup guide

Config file · Workspace: .vscode/mcp.json

For user scope, use the “MCP: Open User Configuration” command if available. Do not guess a user configuration path across operating systems, profiles, containers, or remote workspaces; check the client documentation. Merge this example with existing settings; do not overwrite unrelated servers.

VS Code configuration
{
  "servers": {
    "mcp-gateway": {
      "type": "http",
      "url": "http://localhost:5235/mcp/user/mcp"
    }
  }
}

Read the VS Code setup guide

Config file · macOS/Linux: ~/.codeium/windsurf/mcp_config.json

Windows: %USERPROFILE%\.codeium\windsurf\mcp_config.json

Open the MCP configuration through Windsurf’s settings when possible to confirm the active file. Paths can differ in managed or future releases; check the client documentation if this location is not present. Merge this example with existing settings; do not overwrite unrelated servers.

Windsurf configuration
{
  "mcpServers": {
    "mcp-gateway": {
      "serverUrl": "http://localhost:5235/mcp/user/mcp"
    }
  }
}

Read the Windsurf setup guide

Config file · Project scope: .mcp.json at the repository root

The project file uses mcpServers. For user scope, use claude mcp add --scope user rather than assuming .mcp.json in your home directory is the user configuration. Check the client documentation for managed settings and storage details. Merge this example with existing settings; do not overwrite unrelated servers.

Claude Code configuration
{
  "mcpServers": {
    "mcp-gateway": {
      "type": "http",
      "url": "http://localhost:5235/mcp/user/mcp"
    }
  }
}

Read the Claude Code setup guide

Examples are translated from the published configuration. Supply your own credentials and verify requirements in the upstream README. Remote connectors are shown only where a supported configuration format is known.

Tools

No individual tool names were confirmed in the source material. Check the repository for its current tool list.

Names, permissions, and defaults can change. Check the current upstream documentation before granting access.

Use cases

  • Expose an existing REST API as an MCP service using YAML.
  • Proxy existing MCP servers through managed endpoints.
  • Manage gateway definitions through a web interface.
  • Deploy a multi-tenant gateway with recoverable sessions.

Strengths

  • Converts REST APIs without changing their application code.
  • Includes configuration persistence, versioning, and hot reloads.
  • Supports multiple replicas and container or Kubernetes deployment.

Limitations

  • Backward compatibility is not guaranteed during rapid development.
  • gRPC and WebSocket conversion are roadmap items, not completed capabilities.
  • Server grouping and aggregation are not marked implemented.

Frequently asked questions

Yes. The README describes YAML-based conversion of existing REST APIs into MCP services.

The README identifies Unla as written in Go, despite the input runtime metadata listing node.

No. Both are unchecked items in the feature list.

The gateway supports SSE and Streamable HTTP, with quick-start endpoints for both.

Independent listing, not an affiliation or security review. Grant the least access needed and verify the upstream instructions before running code.

Related MCP servers

Supabase MCP Server

Databases

Connect AI assistants to Supabase projects for SQL, schema changes, debugging, and Edge Functions. Hosted HTTP setup supports project scoping, read-only access, and selectable feature groups.

Supergateway

MCP Gateways & Proxies

Supergateway bridges MCP transports so stdio servers can reach network clients and remote services can appear locally over stdio. It supports SSE, WebSockets, and Streamable HTTP modes through command-line configuration.

mcp-proxy

MCP Gateways & Proxies

mcp-proxy bridges MCP transport mismatches between clients and servers. It can connect a stdio client to a remote SSE or Streamable HTTP server, or expose local stdio servers through network endpoints.

mcpo

MCP Gateways & Proxies

mcpo makes MCP tools available through an OpenAPI-compatible HTTP server. It is for agents and applications that consume OpenAPI endpoints rather than communicating with MCP servers directly.

MCPHub

MCP Gateways & Proxies

Organize multiple MCP servers behind shared HTTP or SSE endpoints. MCPHub adds a management dashboard, group-level visibility controls, semantic routing, authentication, and a terminal interface.

ContextForge

MCP Gateways & Proxies

ContextForge registers and proxies tools, agents, and APIs behind a unified gateway. It targets teams that need discovery, authentication, observability, and policy controls across MCP, A2A, REST, and gRPC services.

MCP Proxy Server

MCP Gateways & Proxies

MCP Proxy Server combines multiple MCP backends behind one HTTP entrypoint. It aggregates tools, prompts, and resources while connecting to stdio, SSE, or streamable HTTP servers.

MCP Hub

MCP Gateways & Proxies

MCP Hub coordinates multiple MCP servers behind one client endpoint. It provides a REST management API and web UI, with server lifecycle controls, authentication handling, and live capability updates.