GL Connectors MCP Setup Guide

Cookbook

The best way to get started is by checking the Connector MCP Cookbook page, to see how to set up Connector MCP programmatically.

Authentication Types

To access an MCP Server, there are two types of authentication available. The method you choose depends on your client type and use case.

Method	Best For	User Interaction Required
Token-based	Headless clients, CI/CD, scripts, programmatic access	No
OAuth 2.1 Flow	Interactive clients (Claude Desktop, Cursor, etc.)	Yes

Token-based Authentication

Token-based authentication is designed for headless clients and scenarios where user interaction is not possible or is detrimental. This includes CI/CD pipelines, automated scripts, server-to-server communication, and any client that cannot open a browser for OAuth consent.

While headless clients can technically present an OAuth authorization link to users, the OAuth 2.1 Flow introduces significant operational challenges in non-interactive environments:

• Server stall — The MCP connection blocks while waiting for the OAuth callback to complete

• Timeout risks — Long waits for user interaction can cause connection timeouts or process hangs

Token-based authentication avoids these issues entirely by using pre-generated credentials that require no runtime user interaction.

Headers Required

Do not omit the Bearer prefix. Authorization: eyJ... will fail—it must be Authorization: Bearer eyJ...

Header	Description
X-Api-Key	Your Client API Key as listed above.
Authorization	Your User Token (JWT). Must include Bearer prefix

Headers Optional

Header	Description
X-Integration	Specifies which user integration to use.

Creating Your Tokens

Before using Token-based authentication, you must create your credentials separately. These are not automatically provisioned.

There are multiple ways to create the tokens required:

1. The easiest way utilizes Connectors Console, but it requires you to have @gdplabs.id email.

2. Via the CLI, you can authenticate following this guide Credentials. You can then retrieve the values via these two commands (on *Nix based systems):

   1. Client API Key: jq -r '.client_api_key' ~/.connector/config.json

   2. User Token: jq -r '.token' ~/.connector/config.json

3. Via the SDK, you can authenticate following In-Depth Setup using the code programmatically.

   from gl_connectors.connector import GLConnectors
   
   connectors = GLConnectors(api_key="YOUR_API_KEY")
   user = connectors.authenticate("username", "password")
   user_token = user.token  # Will resolve to `eyJ......` bearer token.

OAuth 2.1 Flow

It is important to note that because we utilize a special Client (tenant) for this authentication method, if you have created a user directly outside of the Playground or using the API, this user will not by synced (integrations, secret, etc). This user is synchronized with Connectors Console. If you've used Connector Console to get your account, you will not have any issues!

OAuth 2.1 Flow is the preferred method for interactive clients such as Claude Desktop, Cursor, and other MCP-compatible applications with a user interface. This flow handles all credential management automatically.

For users with GDP Labs email (@gdplabs.id), it's possible to directly authenticate into the MCP servers utilizing OAuth2 Flow:

• User creation, token exchange, and all authorization flows are managed automatically

• Simply connect your MCP client and authorize when prompted

This is preferred for you as an end-user as you do not need to deal with user creation and anything that entails. See Supported Clients clients below because not all clients are supported.

1

Configuration

Note that even with this authentication method, you may still use the optional headers to determine which integration you want to use via X-Integration header. Simply add a new headers section and adding the X-Integration value!

The configuration, once you deal with OAuth2, becomes as simple and as short as (check your IDE since the syntax may differ):

{
  "mcpServers": {
    "gmail": {
      "serverUrl": "https://connector.gdplabs.id/google_mail/mcp"
    }
  }
}

2

Authorization Step

If all goes well, you should be prompted with an Application Access Request. To continue with the authentication, please click Allow Access.

3

Authenticate Google Email

You need to then authenticate using your Google email. Please use your @gdplabs.id email, as you will be rejected access if you use other email domains.

Like before, you will be asked to authorize the application to access your Google Account (only the profile is requested). To continue, please give it the access.

4

You're done!

You can now check your MCP once you get the "Authorization Successful" screen. Your tools can now be used.

Disclaimer: You will still need to create an integration. However, we've made sure the MCP server now also provides tools that allow for easy URL generation for integration. Let the LLM decide for you when you need to do this! However, it is highly discouraged to do this on Custom Configuration because you may leak your configuration to the LLM!

Supported Clients

Not all clients support OAuth2 Flow. It is important to know that all headless clients cannot utilize this OAuth2 Flow because the MCP Specification requires a browser interaction (and does not support client credentials officially in the base specification). As such, the following clients are known to be supported:

• VSCode

• Windsurf

• Cursor (via MCP-Remote)

• AntiGravity (via MCP-Remote)

• Kiro (via MCP-Remote)

• ChatGPT Web (requires Plus or higher subscription, or if Business, requires administrative access)

Some clients do not entirely support this flow, including Claude Web because it sometimes works, and sometimes it doesn't. And clients like Cursor do not entirely support it because you are required to manually access the authentication URL instead of the IDE opening the browser for you. To circumvent this, we can use an STDIO MCP Server called MCP Remote that does it all for you. The following is an example configuration (please check your IDE documentation to be sure!)

Prerequisites

1. To utilize MCP Remote, you need to have NodeJS and NPM installed (we will utilize npx as the command).

   1. We recommend using the latest LTS, but at the very least NodeJS version 20 is recommended.

{
  "mcpServers": {
    "gmail": {
      "command": "npx",
      "args": ["-y", "mcp-remote", "https://connector.gdplabs.id/google_mail/mcp"]
    }
  }
}

The full command is npx -y mcp-remote {url}, where the URL can be obtained from Agentic Tools and Model Context Protocol (MCP). You will still need to follow the Authorization Step like above!

IDE Setup

Various IDEs and clients support MCPs, so this won't be a comprehensive list. Having said that, we have curated ways to add MCP Servers to popular MCP Clients.

Claude Desktop

Adding a Single Connector

You may need to restart your Claude client in order to load the changes in your MCP servers after editing the claude_desktop_config.json

Claude Desktop only supports STDIO-based MCP. Here is how you can do it:

1. Settings > Developer

2. Click edit config

3. You will be prompted to edit the file claude_desktop_config.json

4. After saving the file, you may need to restart Claude Desktop to load the changes to your MCP Servers list.

{
  "mcpServers": {
    "gdrive_oauth2": {
      "command": "npx",
      "args": [
        "-y",
        "mcp-remote",
        "https://connector.gdplabs.id/google_drive/mcp"
      ]
    },
    "gdocs_token": {
      "command": "npx",
      "args": [
        "-y",
        "mcp-remote",
        "https://connector.gdplabs.id/google_docs/mcp",
        "--header",
        "X-Api-Key: sk-client-...",
        "--header",
        "Authorization: Bearer eyJ...",
        "--header",
        "X-Integration: user..."
      ]
    }
  }
}

Cursor

Windsurf

VSCode

Using MCP Inspector

The MCP Inspector is a powerful tool that allows you to explore and understand the capabilities of each MCP server. You can use it to:

• List available tools for each connector

• Understand tool parameters and requirements

• Test tool functionality

• Debug connection issues

Installation and Usage

DANGEROUSLY_OMIT_AUTH=true is used to remove the need of proxies. Only to be used when you're doing things locally.

# Run mcp inspector
DANGEROUSLY_OMIT_AUTH=true npx @modelcontextprotocol/inspector

# after that you can open your localhost:6274

What You Can Inspect

• Available Tools: See all tools provided by the connector

• Tool Schemas: Understand required and optional parameters

• Resources: Check available resources and their types

• Prompts: View any pre-defined prompts

Programmatic Usage

You can also use Connector MCP servers programmatically in your Python applications using MCP Client.