https://glama.ai/client/mcpFaqs-D4U9Hl-X.js

1import{t as e}from"./convertMarkdownToHtml-rF6emT_D.js";var t=[{answer:`An **MCP server** is a small program that exposes **tools**, **resources**, and **prompts** to an AI client over the [Model Context Protocol](https://modelcontextprotocol.io). It speaks \`JSON-RPC 2.0\` over \`stdio\`, Server-Sent Events, or **Streamable HTTP** – and once connected, the AI can call any tool the server defines.
2
3MCP-compatible clients include **Claude Desktop**, **Claude Code**, **ChatGPT**, **Cursor**, **Windsurf**, **VS Code**, **Zed**, and **JetBrains IDEs**. One MCP server works across all of them – you install it once, every client can use it.
4
5**Glama indexes [every MCP server in the ecosystem](/mcp/servers)** – browse by category, [search across every tool](/mcp/tools) they expose, or deploy a [hosted connector](/mcp/connectors) in one click.`,question:`What is an MCP server?`,questionMarkdown:`What is an [MCP server](/mcp/servers)?`,slug:`what-is-an-mcp-server`},{answer:'Open *Cursor Settings → Features → MCP → **+ Add New MCP Server***, or edit `~/.cursor/mcp.json` directly. Each server takes a `command`, an `args` array, and an optional `env` map – for example, `command: "npx"` with `args: ["-y", "@example/mcp-server"]`.\n\nPick any server from [the Glama registry](/mcp/servers) – each server page shows the exact JSON block to paste, pre-filled for Cursor, Claude Desktop, Claude Code, and VS Code. To test a remote server before adding it, use [the Glama MCP Inspector](/mcp/inspector) – no install required.',question:`How do I add an MCP server to Cursor?`,slug:`add-mcp-server-to-cursor`},{answer:"In **Claude Desktop**, open *Settings → Developer → Edit Config* – that opens `claude_desktop_config.json`. Add your server under the `mcpServers` key using the same `command`/`args`/`env` structure Cursor uses, then quit and relaunch Claude Desktop.\n\nIn **Claude Code**, run `claude mcp add <name> <command>` from your terminal – it writes the entry to your project's MCP config directly.\n\nEvery server on [the Glama registry](/mcp/servers) ships with a pre-filled config block for both clients – copy it, paste it, done. To test a server remotely before wiring it up, open [the Glama MCP Inspector](/mcp/inspector) and point it at the server URL.",question:`How do I add an MCP server to Claude Desktop or Claude Code?`,slug:`add-mcp-server-to-claude`},{answer:'Three causes account for almost every *"MCP server won\'t connect"* report:\n\n- **Missing `-y` flag** – `npx` refuses to auto-install without it. Change `"args": ["@example/mcp-server"]` to `"args": ["-y", "@example/mcp-server"]`.\n- **Windows path escaping** – inside `claude_desktop_config.json`, use forward slashes (`C:/Users/...`) or doubled backslashes. Single backslashes break JSON parsing.\n- **`spawn ENOENT`** – the client can\'t find the binary. Give `command` an absolute path, or make sure the binary is on `PATH` for the shell the client launches from – 

5Claude Desktop launches *without* your login shell\'s `PATH`.\n\nIf the handshake completes but individual tool calls fail, open [the Glama MCP Inspector](/mcp/inspector) and point it at the server URL – it shows raw JSON-RPC requests and responses so you can see exactly where the error originates.',question:`Why won't my MCP server start?`,slug:`mcp-server-wont-start`},{answer:`**MCP** is an [open-source standard](https://modelcontextprotocol.io) introduced by **Anthropic** in **November 2024** that standardizes how AI applications connect to external tools and data sources. Think of it as **USB-C for AI** – one protocol replaces custom integrations between every AI app and every tool.
6
7Before MCP, every AI application needed custom code to talk to every tool – an **N×M integration problem**. MCP reduces it to **N+M**: each app implements MCP once, each tool implements MCP once.
8
9An MCP setup has three roles:
10
11- The **host** – the AI application (Claude Desktop, ChatGPT, Cursor, VS Code)
12- A **client** – the host's internal connection to one specific server
13- An **MCP server** – exposes three primitives to the client:
14  - **tools** – functions the model can call (like *"send email"* or *"query Postgres"*)
15  - **resources** – data the model can read (like a config file or database schema)
16  - **prompts** – templated messages the user can pick from
17
18Servers speak to clients over \`stdio\`, Server-Sent Events, or the modern **Streamable HTTP** transport using \`JSON-RPC 2.0\`.
19
20**Glama sits at the infrastructure layer.** We index every [MCP server](/mcp/servers) and [hosted connector](/mcp/connectors) in the ecosystem, [search every tool](/mcp/tools) they expose, and proxy every call through a gateway that logs inputs and outputs, enforces per-tool access control, and manages OAuth credentials – so your agents get the MCP ecosystem plus production-grade observability.`,question:`What is the Model Context Protocol (MCP)?`,slug:`what-is-model-context-protocol`},{answer:`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.
21
22Without 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:
23
24- **Authenticates** – one identity in front of every connected server
25- **Injects credentials** – OAuth tokens and API keys stored once, refreshed automatically
26- **Controls tool access** – enable or disable individual tools per connection
27- **Manages sessions** – \`Mcp-Session-Id\` tracking across reconnects
28- **Logs every call** – full JSON-RPC audit trail
29
30**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. [Read the full Gateway overview →](/mcp/gateway)`,question:`What is an MCP Gateway?`,slug:`what-is-an-mcp-gateway`},{answer:`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.
31
32An **MCP Gateway** includes a proxy *and* adds the control plane on top:
33
34- **Access control** – enable or disable individual tools per connection
35- **Credential management** – encrypted OAuth storage and automatic token refresh
36- **Session lifecycle** – \`Mcp-Session-Id\` tracking across reconnects
37- **Usage analytics** – aggregated tool call counts, latency, cost attribution
38- **Full call logging** – every JSON-RPC message persisted for audit
39
40Use 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.`,question:`What is an MCP Proxy, and how is it different from an MCP Gateway?`,slug:`mcp-proxy-vs-gateway`},{answer:`An **MCP connector** is a pre-configured MCP server you can plug into an AI client in one step. In [Claude](https://support.claude.com/en/articles/11175166-get-started-with-custom-connectors-using-remote-mcp), ChatGPT, and other clients, any remote MCP server a user has added to their account shows up as a "connector".
41
42**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.`,question:`What are MCP connectors?`,questionMarkdown:`What are [MCP connectors](/mcp/connectors)?`,slug:`what-are-mcp-connectors`},{answer:`**MCP hosting** is a managed service that runs an MCP server for you on infrastru

42cture you don't have to provision. You get a public URL with TLS, OAuth and credential management, health checks, monitoring, and scaling – without running the server yourself.
43
44Most MCP hosting platforms – **Cloudflare Workers**, **Google Cloud Run**, **Azure Functions**, **AWS Bedrock AgentCore**, **Heroku** – require you to bring your own server code. You write the MCP server, they run it.
45
46**Glama is different.** We host open-source MCP servers from [the registry](/mcp/servers) directly: pick a server someone else already published, click deploy, and get a \`streamable-http\` endpoint fronted by the Glama Gateway – **without writing a line of code yourself**. Full call logging, per-tool access control, and managed OAuth credentials come out of the box.`,question:`What is MCP hosting?`,questionMarkdown:`What is [MCP hosting](/mcp/hosting)?`,slug:`what-is-mcp-hosting`},{answer:`Every JSON-RPC message – **request**, **response**, and **SSE server event** – is persisted to Glama's database with the full payload, including:
47
48- \`tool\` name
49- Input arguments
50- Output result
51- Timestamps and session IDs
52
53Call logs are **scoped to the connection profile owner** – workspace members with the right role can view shared logs.
54
55**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.
56
57**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.
58
59*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.`,question:`How does Glama's MCP Gateway log tool calls and control tool access?`,slug:`glama-gateway-call-logging-and-access-control`},{answer:`**Credentials.** Glama stores OAuth access tokens, refresh tokens, and API keys encrypted with **AES-256-GCM** – each value gets its own random 16-byte IV and authentication tag, and the 256-bit key is held server-side only. 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.
60
61**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.`,question:`Where are MCP credentials and call logs stored?`,slug:`where-mcp-credentials-and-call-logs-stored`},{answer:`Use the [**Glama MCP Inspector**](/mcp/inspector) – an in-browser tool that connects to any MCP server URL and lets you:
62
63- List tools, resources, and prompts
64- Call them with structured inputs
65- See raw JSON-RPC responses
66- Handle **OAuth flows**, bearer tokens, and custom headers
67- Exercise advanced spec features – **tasks**, **elicitations**, **sampling**, **progress notifications**, **audio**, and **images**
68
69All 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.
70
71The official reference inspector ([\`@modelcontextprotocol/inspector\`](https://github.com/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.`,question:`How do I test or debug an MCP server?`,slug:`test-or-debug-mcp-server`},{answer:"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.\n\nGlama indexes every tool exposed by every server in [its registry](/mcp/tools) – 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:\n\n- `query Postgres` – find every database-query tool\n- `send email` – find every email-sending tool\n- `generate Figma component` – find every Figma-integration tool\n\nOnce 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.**",question:`Can I search for a specific MCP tool, not just a server?`,slug:`search-for-specific-mcp-tool`},{answer:`A Glama connector URL works across every MCP-compatible client. Depending on your client:
72
73- **Claude** – *Customize → Connectors* → click **+** → *Add custom connector*
74- **ChatGPT** – *Settings → Apps & Connectors → Create* (Developer Mode must be enabled)
75- **Cursor** – *Settings → Features → MCP* → **+ Add New MCP Server**, or edit \`~/.cursor/mcp.json\`
76- **VS Code** – Command Palette → \`MCP: Add Server\`, or edit \`.vscode/mcp.json\` in y

76our workspace
77
78For other MCP-compatible clients (Windsurf, Zed, JetBrains IDEs, Replit, …), setup is client-specific – check your client's MCP configuration docs. **Any client that speaks MCP will accept a Glama connector URL** – one connector, every agent.`,question:`How do I add a Glama connector to Claude, ChatGPT, or Cursor?`,slug:`add-glama-connector-to-client`},{answer:`Submit open-source MCP servers to [the Glama registry](/mcp/servers) straight from a GitHub repository. On the servers page, click **Add MCP Server** and fill in:
79
80- The **GitHub repository URL** for your server
81- A **display name** and **short description**
82
83Glama 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.
84
85**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](/discord).`,question:`How do I submit an MCP server?`,slug:`submit-mcp-server`},{answer:`Connectors are remote MCP servers you've already deployed somewhere with a public endpoint. On [the connectors page](/mcp/connectors), click **Add MCP Server → Connector** and provide:
86
87- A **name** and **short description**
88- The **server URL** – must be HTTPS and speak the \`streamable-http\` transport
89- Optional **private test credentials** (API keys, OAuth details) so Glama can verify the connector is reachable
90
91If your server implements OAuth 2.1 **dynamic client registration** (RFC 7591), you can skip the test credentials – Glama will register automatically.
92
93**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.`,question:`How do I submit an MCP connector?`,slug:`submit-mcp-connector`},{answer:"**The auth method on your connector's test profile is what sets the `auth:` badge.** A maintainer's declaration is what the badge reflects wherever there is one; where there is not, Glama falls back to what it can detect – a server that advertises OAuth metadata and refuses unauthenticated traffic is listed as `auth:oauth2` automatically. Nothing else is inferred, because a connector that lets anyone list tools looks identical to one that needs no auth at all.\n\nTo set it, [claim your connector](/mcp/connectors) and open its page, then create or edit the **test profile** and pick the authentication method your server actually requires – **No Auth**, **API Key**, **Basic Auth**, or **OAuth 2.0**. That choice becomes the connector's primary auth method and updates the badge. Until a test profile declares one, a connector reads as `auth:none`.\n\n**Open discovery with authenticated calls is a common shape** – `tools/list` is left open so directories can index and health-check the server, while every `tools/call` requires a key and returns `401` with `WWW-Authenticate`. Declare the method the *calls* need, since that is what someone integrating the connector has to provide. Set the test profile to **API Key**, add a test credential so health checks exercise the authenticated path, and describe the open-discovery behaviour in your connector description.\n\n**Selecting No Auth will not clear a badge your server contradicts.** If the last health check was refused with a `401`, the test profile still switches to connecting without credentials, but the connector stays listed as it was – publishing `auth:none` for a server that turns away unauthenticated callers would tell integrators they need no key when they do. Health-checking a server without credentials is not the same claim as the server being open.\n\n**The badge carries one method.** If your server accepts more than one – say an API key or OAuth – set the test profile to the one most integrators will use and document the rest in the description. Declaring a method also overrides the automatic OAuth detection above, so a server that speaks both is listed the way its maintainer describes it.",question:`How does Glama decide my connector's authentication badge?`,slug:`connector-authentication-badge`},{answer:`Claiming proves that you control a remote MCP connector. It does not move, proxy, or interrupt the server.
94
95You verify the domain or GitHub account a connector belongs to, not each connector separately. One verification covers every connector under it – including connectors published or imported later – so a publisher with many connectors verifies once.
96
971. Open the [connector listing](/mcp/connectors), choose **Claim ownership**, and sign in to Glama.
982. Complete one verification:
99   - **Your domain.** For a connector listed in the official MCP Registry under a domain namespace, verify the domain the namespace is named after: \`com.example/server\` is verified through \`example.com\`. This works even when the connector runs on someone else's platform, such as a hosting provider. For any other connector, verify the domain it is served from. Add the TXT record Glama shows at \`_glama-claim.<domain>

99\`, or publish the JSON Glama shows at \`https://<domain>/.well-known/glama.json\`, then choose **Check**.
100   - **GitHub identity.** For a namespace such as \`io.github.alice/server\`, link the matching GitHub user, then choose **Claim with GitHub**. An organization namespace such as \`io.github.acme/server\` also needs that organization to have installed the [Glama AI GitHub App](https://github.com/apps/glama-ai) and approved its permissions, because GitHub discloses organization membership only to apps it has installed.
1013. Glama emails you for each connector the verification covers and gives you access to listing details, thumbnails, health checks, and analytics.
102
103The HTTP ownership file has this structure:
104
105\`\`\`json
106{
107  "$schema": "https://glama.ai/mcp/schemas/connector.json",
108  "claim": "glama_claim_..."
109}
110\`\`\`
111
112When several Glama accounts verify the same domain, \`claim\` may be a list of tokens.
113
114Your claim token is opaque, stable, and bound to your Glama account – the same token works for every domain you verify. It contains no email address or other personal information. Never publish an email address, Glama session token, GitHub token, or connector credential as ownership proof.
115
116Glama re-checks domain verifications daily. If it can no longer find your token, it emails you and starts a seven-day grace period before removing access. Restore the same token during that period to keep ownership.
117
118When both a connector's registry publisher and the owner of its hosting domain have verified, the registry publisher manages the listing. If the publisher's verification later lapses, the hosting domain's owner manages it again.
119
120If verification fails, confirm that you copied the current token exactly. The HTTP file must be public, served over HTTPS, and must not redirect to another domain. DNS changes may need more time to propagate.
121
122For a connector linked to the official MCP Registry, registry updates continue to replace its name, description, and URL by default. After claiming, open **Manage connector** and enable **Use Glama listing details as the source of truth** if edits made on Glama should be preserved. Categories and thumbnails are always managed on Glama; registry linkage and technical connection settings continue to sync.`,question:`How do I claim an MCP connector?`,slug:`claim-mcp-connector`},{answer:`The following AI clients support MCP natively or via adapter:
123
124- **Claude Desktop**, **Claude Code**
125- **ChatGPT**
126- **Cursor**, **Windsurf**, **Zed**
127- **VS Code** (with the MCP extension)
128- **JetBrains IDEs**
129- **Replit**
130- **Sourcegraph** (via Cody)
131
132Glama tracks every MCP-compatible client with its supported features listed in [the client directory](/mcp/clients).`,question:`Which AI clients support MCP?`,slug:`which-ai-clients-support-mcp`},{answer:`The [**official MCP Registry**](https://registry.modelcontextprotocol.io) is a vendor-neutral index of MCP server metadata maintained by the MCP steering group – the canonical source of truth for publicly published servers.
133
134**Glama builds on top of it** with much deeper per-connector data and a full control plane:
135
136- **Rich metadata** on every connector – health checks, quality scores, security audits, tool schemas with annotations, usage telemetry, license info, and maintainer notes
137- **One-click hosting** on managed infrastructure
138- **Full observability and control** over every call – JSON-RPC logging, per-tool access control, managed OAuth credentials, and usage analytics
139
140Use the official registry for vendor-neutral metadata. Use Glama when you need **depth, observability, and control** over production MCP traffic. See [our indexing methodology](/mcp/methodology) for the full technical description of how every server in the Glama registry is built, introspected, audited, and scored.`,question:`How is Glama different from the official MCP registry?`,slug:`glama-vs-official-mcp-registry`}].map(t=>({...t,answerHtml:e(t.answer),questionHtml:e(t.questionMarkdown??t.question).replace(/^<p>/u,``).replace(/<\/p>$/u,``)}));export{t};
141//# sourceMappingURL=mcpFaqs-D4U9Hl-X.js.map