The Model Context Protocol registry, hosting, and gateway.

MCP is an open protocol introduced by Anthropic in November 2024 that standardizes how AI applications connect to external tools, data sources, and workflows. Think of it as USB-C for AI — one protocol replaces custom integrations between every AI app and every tool.

An MCP setup has three roles: the host (the AI application), a client (the host's connection to one server), and the server (which exposes tools, resources, and prompts over JSON-RPC 2.0). Clients like Claude, ChatGPT, and Cursor speak MCP natively.

An MCP Gateway is a reverse proxy that sits between AI clients and MCP servers. It appears as an MCP server to the client while acting as an MCP client to the backend.

Without a gateway, every agent manages its own connections to every server — a tangled point-to-point mess that breaks at enterprise scale. A gateway consolidates all of that into one control plane that:

• Authenticates — one identity in front of every connected server
• Injects credentials — OAuth tokens and API keys stored once, refreshed automatically
• Controls tool access — enable or disable individual tools per connection
• Manages sessions — Mcp-Session-Id tracking across reconnects
• Logs every call — full JSON-RPC audit trail

Glama's MCP Gateway turns the open MCP ecosystem into a production-grade control plane — every connector in the registry is fronted by the gateway, so every call your agents make is visible, auditable, and revocable.

An MCP Proxy is a thin pass-through — it takes a JSON-RPC request from a client, forwards it to an upstream MCP server, and returns the response. Nothing else.

An MCP Gateway includes a proxy and adds the control plane on top:

• Access control — enable or disable individual tools per connection
• Credential management — encrypted OAuth storage and automatic token refresh
• Session lifecycle — Mcp-Session-Id tracking across reconnects
• Usage analytics — aggregated tool call counts, latency, cost attribution
• Full call logging — every JSON-RPC message persisted for audit

Use a proxy when you need basic routing for a single upstream server. Use a gateway when you are running MCP at enterprise scale and need governance. Glama is a full gateway — not a roll-your-own routing layer.

An MCP connector is a pre-configured MCP server you can plug into an AI client in one step. In Claude, ChatGPT, and other clients, any remote MCP server a user has added to their account shows up as a "connector".

A Glama connector goes further. It adds hosting, managed credentials, and per-tool access control on top of the underlying server — so you don't have to run the server, store the tokens, or touch any config. Paste the Glama URL into Claude, ChatGPT, or Cursor, and the Glama Gateway does the rest.

MCP open-source server hosting is a managed service that takes an open-source MCP server — someone else's code, published on GitHub — and runs it on infrastructure you don't have to provision. You get:

• A public URL with TLS
• OAuth and credential management
• Health checks, monitoring, and scaling
• No code of your own

Glama hosts open-source MCP servers from its registry: for any server with a valid build spec, you can deploy it in one click and get a streamable-http endpoint fronted by the Glama Gateway.

Every JSON-RPC message — request, response, and SSE server event — is persisted to Glama's database with the full payload, including:

• tool name
• Input arguments
• Output result
• Timestamps and session IDs

Call logs are scoped to the connection profile owner — workspace members with the right role can view shared logs.

Per-tool access control is a per-connection on/off flag. Disable a tool and the gateway returns a JSON-RPC error to the client without ever forwarding the request upstream — the tool author never knows the call was attempted.

OAuth credentials are stored encrypted and automatically refreshed, so your client never holds the tokens. Revoking access is one click — no credential rotation required on the client side.

Heads up: the gateway captures full JSON-RPC payloads, so tool arguments containing sensitive data (API keys, PII, customer data) are visible in the audit log. For sensitive workloads, mask those arguments at the client side before calling.

Credentials. Glama stores OAuth access tokens, refresh tokens, and API keys in encrypted form. They are decrypted in memory only at the moment of making an upstream request, and automatically refreshed before expiration. Your client never sees the raw credentials — only the Glama Gateway does.

Call logs. Full JSON-RPC payloads — including tool name, input arguments, and upstream output — are stored per connection profile so you can audit exactly what your agents did, with timestamps and session IDs for traceability.

Usage aggregates. Separately from the raw audit trail, Glama computes aggregated analytics (tool call counts, latency, cost attribution) that can be queried without reading individual call payloads — useful for dashboards and anomaly detection.

Use the Glama MCP Inspector — an in-browser tool that connects to any MCP server URL and lets you:

• List tools, resources, and prompts
• Call them with structured inputs
• See raw JSON-RPC responses
• Handle OAuth flows, bearer tokens, and custom headers
• Exercise advanced spec features — tasks, elicitations, sampling, progress notifications, audio, and images

All state is encoded in the URL so you can share or bookmark a debug session. No install, no login, no local MCP client required — paste a URL, click inspect, and you're debugging.

The official reference inspector (@modelcontextprotocol/inspector) is an npm-installed local tool. Glama's is web-based — it works against remote MCP servers directly, and requests go from your browser to the MCP server without Glama ever logging them.

Yes. When you know what capability you need but don't know which server provides it, tool-level search gets you there in one query.

Glama indexes every tool exposed by every server in its registry — names, descriptions, input schemas, and the MCP annotation hints (readOnlyHint, destructiveHint, idempotentHint) that tell you whether a tool is safe to run in automated agent loops. You can search for capabilities like:

• query Postgres — find every database-query tool
• send email — find every email-sending tool
• generate Figma component — find every Figma-integration tool

Once you've found a matching tool, you can either install the underlying server yourself or plug in the Glama-hosted connector for that server in one click. Few other MCP directories index at the tool level.

A Glama connector URL works across every MCP-compatible client. Depending on your client:

• Claude — Customize → Connectors → add a custom connector
• ChatGPT — Settings → Apps & Connectors → Create (Developer Mode must be enabled)
• Cursor / VS Code — add the URL to the MCP configuration in settings
• Windsurf / Zed / JetBrains — add the URL to the client's MCP server list

The same URL works everywhere — one connector, every agent.

Submit open-source MCP servers to the Glama registry straight from a GitHub repository. On the servers page, click Add MCP Server and fill in:

• The GitHub repository URL for your server
• A display name and short description

Glama runs automated quality checks (license detection, security scan, health test) during indexing. Most submissions pass automatically within minutes and become discoverable through Glama's search, category pages, and recommendation feeds.

Control how your server is indexed by adding a glama.json metadata file to your repo — it lets you set the display name, description, category, environment variables, and build spec. Servers must be on GitHub today; for other sources, reach out on Discord.

Connectors are remote MCP servers you've already deployed somewhere with a public endpoint. On the connectors page, click Add MCP Server → Connector and provide:

• A name and short description
• The server URL — must be HTTPS and speak the streamable-http transport
• Optional private test credentials (API keys, OAuth details) so Glama can verify the connector is reachable

If your server implements OAuth 2.1 dynamic client registration (RFC 7591), you can skip the test credentials — Glama will register automatically.

Only healthy connectors are indexed for search. Unhealthy connectors stay in pending state until they become reachable. Submitted connectors are public by default and discoverable immediately once healthy. You can mark a connector as deprecated later if you're retiring the upstream server — users browsing Glama will see a notice.

The following AI clients support MCP natively or via adapter:

• Claude Desktop, Claude Code
• ChatGPT
• Cursor, Windsurf, Zed
• VS Code (with the MCP extension)
• JetBrains IDEs
• Replit
• Sourcegraph (via Cody)

Glama tracks every MCP-compatible client with its supported features listed in the client directory.

The official MCP Registry is a vendor-neutral index of MCP server metadata maintained by the MCP steering group — the canonical source of truth for publicly published servers.

Glama builds on top of it with much deeper per-connector data and a full control plane:

• Rich metadata on every connector — health checks, quality scores, security audits, tool schemas with annotations, usage telemetry, license info, and maintainer notes
• One-click hosting on managed infrastructure
• Full observability and control over every call — JSON-RPC logging, per-tool access control, managed OAuth credentials, and usage analytics

Use the official registry for vendor-neutral metadata. Use Glama when you need depth, observability, and control over production MCP traffic.