Server profile

MCP Gateway

Lasso Security’s MCP Gateway proxies MCP servers and filters requests and responses through configurable plugins. It combines server management with secret masking, optional PII controls, tracing, and pre-load security scanning.

Server facts

MCP Gateway

Tech

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

Activity

GitHub stars
396
Last commit
Data as of

Tags

  • Mcp Proxy
  • Pii
  • Secret Masking
  • Security Guardrails
  • Tracing

Overview

MCP Gateway from Lasso Security sits between an agent and its configured MCP servers. It reads client configuration, manages the underlying server lifecycles, and exposes a common discovery and execution interface. Its two named proxy tools let agents inspect available server metadata and invoke downstream capabilities. Requests and responses pass through enabled plugins, allowing the gateway to apply security processing independently of each backend's own implementation. The README presents this as a way to centralize sensitive-data controls and visibility rather than configuring equivalent safeguards separately for every server. Server definitions are nested beneath the gateway entry in the client configuration.

Plugin choice determines the protection provided. The basic plugin masks supported credential patterns, Presidio handles personal information, and the Lasso plugin adds API-backed checks for secrets, PII, prompt injection, harmful content, and custom policies. Presidio requires an extra installation, while Lasso requires an API key. Xetrack is an optional tracing integration with configurable database and log locations. A scanner can inspect server reputation and tool descriptions before loading backends, block risky entries, and write results into configuration. Its states include manual skipping, so scan results are controls to review rather than universal guarantees of safety. Installation is through pip, and the documented local command points to the MCP configuration and selects plugins. Docker setup is also described.

Install & configure

Requirements

  • Python and pip
  • The mcp-gateway package
  • Xetrack installed for this example
  • An MCP configuration containing nested server definitions
Documented launch / install command
mcp-gateway --mcp-json-path '~/.cursor/mcp.json' -p basic -p xetrack

Install with pip install mcp-gateway and pip install xetrack. Replace the configuration path if needed. This example enables basic masking and tracing; Lasso API credentials and Presidio extras are needed only for those plugins.

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.

Claude Desktop configuration
{
  "mcpServers": {
    "mcp-gateway-lasso-security": {
      "command": "mcp-gateway",
      "args": [
        "--mcp-json-path",
        "~/.cursor/mcp.json",
        "-p",
        "basic",
        "-p",
        "xetrack"
      ],
      "env": {}
    }
  }
}

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-lasso-security": {
      "command": "mcp-gateway",
      "args": [
        "--mcp-json-path",
        "~/.cursor/mcp.json",
        "-p",
        "basic",
        "-p",
        "xetrack"
      ],
      "env": {}
    }
  }
}

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-lasso-security": {
      "type": "stdio",
      "command": "mcp-gateway",
      "args": [
        "--mcp-json-path",
        "~/.cursor/mcp.json",
        "-p",
        "basic",
        "-p",
        "xetrack"
      ],
      "env": {}
    }
  }
}

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-lasso-security": {
      "command": "mcp-gateway",
      "args": [
        "--mcp-json-path",
        "~/.cursor/mcp.json",
        "-p",
        "basic",
        "-p",
        "xetrack"
      ],
      "env": {}
    }
  }
}

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-lasso-security": {
      "type": "stdio",
      "command": "mcp-gateway",
      "args": [
        "--mcp-json-path",
        "~/.cursor/mcp.json",
        "-p",
        "basic",
        "-p",
        "xetrack"
      ],
      "env": {}
    }
  }
}

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

Source: repository README. Tool descriptions are a documented snapshot, not a live capability check.

ToolWhat it does
get_metadataInspect available proxied servers and their capabilities.
run_toolInvoke a downstream capability with configured request and response filtering.

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

Use cases

  • Mask supported credentials in proxied tool exchanges
  • Apply PII filtering to connected server responses
  • Trace tool calls through the optional Xetrack plugin
  • Scan server reputation and tool descriptions before loading

Strengths

  • Applies request and response filtering across different MCP backends
  • Separates basic masking, PII, and API-backed policy plugins
  • Includes optional pre-load scanning and tracing

Limitations

  • Presidio and Xetrack require additional dependencies
  • Advanced Lasso guardrails need an API key and external API checks
  • Scanner results can be manually overridden

Frequently asked questions

The plugin table assigns token and secret masking to basic, not PII masking. Presidio or Lasso provides PII controls.

No. It is required for the Lasso plugin, not the documented basic masking setup.

It evaluates server reputation and tool descriptions for risky instructions or actions before loading servers.

Yes. The README describes writing scan results into the MCP configuration, including blocked and passed states.

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

Related MCP servers

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.

Unla MCP Gateway

MCP Gateways & Proxies

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.

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.