Set up Atlan MCP

Requires Claude Code installed and available in your terminal.

Set up Claude Code (Plugin)

Install the Atlan plugin with a single command, with no API keys, JSON, or manual MCP setup:

claude plugin install atlan@claude-plugins-official

When prompted, your browser opens the Atlan OAuth page. Sign in with your Atlan credentials, and the plugin's tools are ready to use in Claude Code.

Set up Claude Code (Manual)

OAuth
API key

Sign in with your Atlan account, using your own permissions.

In your terminal, add the OAuth-based Atlan MCP server:

claude mcp add --transport http atlan-oauth https://mcp.atlan.com/mcp

Start Claude Code:
```
claude
```
In the Claude Code terminal, type /mcp.
When prompted, complete the OAuth flow in your browser. The Atlan MCP server is then available in Claude Code.

Authenticate with a static API token, best for automation.

In Atlan, generate an API key from Admin Settings → API Keys / Tokens and copy it securely.

Add the API key-based Atlan MCP server:

claude mcp add-json atlan-api-key '{"type":"http","url":"https://<your-tenant>.atlan.com/mcp/api-key","headers":{"Authorization":"Bearer <API_KEY>"}}'

Start Claude Code with claude, type /mcp, and confirm the Atlan MCP server is listed and connected.

Requires OpenAI Codex (desktop app, CLI, or both).

Set up Codex (Plugin)

Register Atlan's marketplace with Codex:

codex plugin marketplace add https://github.com/atlanhq/agent-toolkit

Install the Atlan plugin:
```
codex plugin add atlan@atlan
```
The atlan@atlan slug follows Codex's <plugin-name>@<marketplace-name> convention.
Register the MCP server. This performs the actual registration and launches the OAuth flow with mcp.atlan.com, so complete the sign-in in your browser:
```
codex mcp add atlan --url https://mcp.atlan.com/mcp
```
Quit and relaunch Codex so the server loads (Cmd+Q for the desktop app, or restart the CLI). The plugin appears under Plugins → Manage.
Inside a Codex session, run /mcp to inspect connected servers, then ask anything Atlan-related.

Set up Codex (Manual)

OAuth runs automatically with mcp.atlan.com, so no API key is required.

Add the Atlan MCP server. This appends [mcp_servers.atlan] to ~/.codex/config.toml and launches the OAuth flow, so complete the sign-in in your browser:
```
codex mcp add atlan --url https://mcp.atlan.com/mcp
```
Exit and re-run the Codex CLI so the server loads, then run /mcp to verify it's connected.

Requires Cursor installed and updated to the latest version.

Set up Cursor (Plugin)

The plugin registers Atlan's hosted MCP server (https://mcp.atlan.com/mcp) with Cursor, with no API key or JSON editing required.

Install in one click:

Open in Cursor marketplace

Select Install on the marketplace page, then sign in on first use.

Or add it from inside Cursor:

Press Cmd+Shift+J (macOS) or Ctrl+Shift+J (Windows/Linux) to open settings, then go to Plugins.
Search for Atlan and click Install.
Open any chat and trigger an Atlan tool (for example, "search Atlan for the customers table"). On first use, Cursor opens the Atlan login page (SSO supported). After you log in, Cursor connects using your Atlan roles and permissions.
To verify, go to Features → Model Context Protocol in Cursor settings. The atlan server appears in the list.

note

The Atlan plugin lives in Cursor's plugin marketplace (used to register MCP servers and agents), not the extension marketplace in the sidebar.

Set up Cursor (Manual)

OAuth
API key

Sign in with your Atlan account, using your own permissions. Requires Cursor installed on this device.

Install in one click:

Add to Cursor

Or add it manually in Settings → Cursor Settings → Tools and Integration → New MCP Server:

{
  "mcpServers": {
    "atlan": {
      "type": "http",
      "url": "https://mcp.atlan.com/mcp"
    }
  }
}

After saving, Cursor prompts you to log in with your Atlan account (SSO supported), then connects using your roles and permissions.

Authenticate with a static API token, best for automation.

In Atlan, generate an API key under Admin Settings → API Keys / Tokens.

In Cursor, go to Settings → Cursor Settings → Tools and Integration, click New MCP Server, and add:

{
  "mcpServers": {
    "Atlan MCP Remote API Key": {
      "url": "https://<your-tenant>.atlan.com/mcp/api-key",
      "headers": {
        "Authorization": "<your-api-key>"
      }
    }
  }
}

Save the configuration. Cursor connects to Atlan with API key authentication.

Requires VS Code. The extension also works in Cursor and Windsurf via VSIX.

Set up VS Code (Extension)

Install the Atlan extension from the VS Code Marketplace, or open the Extensions view (Cmd+Shift+X / Ctrl+Shift+X), search for Atlan, and click Install.
Click the Atlan icon in the Activity Bar to open the sidebar.
Sign in with your Atlan workspace when prompted (SSO supported). To use an API key instead, open the Command Palette (Cmd+Shift+P / Ctrl+Shift+P) and run Atlan: Configure Connection (API Key).
The extension registers the Atlan MCP server automatically on first activation. To re-register later, run Atlan: Setup MCP Server.
Open GitHub Copilot Chat (or any MCP-aware assistant) and trigger an Atlan tool, for example: "search Atlan for the customers table".

Set up VS Code (Manual)

OAuth
API key

Sign in with your Atlan account, using your own permissions. Requires VS Code installed on this device.

Install in one click:

Install in VS Code

Or add it manually: open the Command Palette (Cmd+Shift+P / Ctrl+Shift+P), run MCP: Open User Configuration, and add this configuration to mcp.json:

{
  "servers": {
    "atlan-oauth": {
      "url": "https://mcp.atlan.com/mcp",
      "type": "http"
    }
  },
  "inputs": []
}

Save the file and click Start for MCP. A login prompt appears; after login, VS Code connects using your Atlan roles and permissions.

Authenticate with a static API token, best for automation.

In Atlan, generate an API key under Admin Settings → API access → Tokens.
Open the Command Palette (Cmd+Shift+P / Ctrl+Shift+P) and run MCP: Open User Configuration.

In the mcp.json file, add (replace <your-api-key> with your key):

{
  "servers": {
    "atlan-api-key": {
      "url": "https://<your-tenant>.atlan.com/mcp/api-key",
      "type": "http",
      "headers": {
        "Authorization": "<your-api-key>"
      }
    }
  },
  "inputs": []
}

Save the file and click Start for MCP. VS Code connects to Atlan with API key authentication.

Requires Windsurf. API key authentication only.

Set up Windsurf

In Atlan, generate an API key under Admin Settings → API Keys / Tokens and copy it securely.

In Windsurf, open the MCP configuration file and add:

{
  "mcpServers": {
    "Atlan MCP Remote": {
      "serverUrl": "https://<your-tenant>.atlan.com/mcp/api-key",
      "headers": {
        "Authorization": "<your-api-key>"
      }
    }
  }
}

Save the configuration. Windsurf is now connected to Atlan MCP with API key authentication.

Requires permission to add Databricks Marketplace connections, your Atlan domain, and an Atlan OAuth client ID and secret. Generate the client under Settings (Admin) → API access → OAuth → Generate new → Generate OAuth Client. For more information, see OAuth clients.

Set up Databricks

In Databricks, open Marketplace, search for MCP, then select Atlan.
Select Install to open the wizard. Enter a Connection name and your Atlan OAuth client ID and client secret, then select Install.
Go to Catalog → Connect → Connections, select your Atlan MCP connection, and select Login.
Enter your Atlan domain name (the part before .atlan.com), select Sign in, and complete the Atlan sign-in flow. On the confirmation page, select Open in MCP Client to return to Databricks.
To verify, go to AI/ML → Playground, select Tools → Add tool → UC connection, choose your Atlan connection, and prompt the agent to find an asset or trace its lineage. You can review the server anytime under AI Gateway → MCPs.

Requires Snowflake Cortex Code v1.0.61+ (check with cortex --version).

Set up Snowflake Cortex Code

OAuth
API key

Add the OAuth-based Atlan MCP server. Cortex Code writes it to ~/.snowflake/cortex/mcp.json:
```
cortex mcp add atlan https://mcp.atlan.com/mcp --transport http
```
Start the MCP servers (or just start a cortex session, where configured servers initialize automatically):
```
cortex mcp start
```
When prompted, complete the OAuth flow in your browser. The token is stored under ~/.snowflake/cortex/mcp_oauth/.
Confirm the connection with cortex mcp list (outside a session) or /mcp (inside a session). On success, Cortex Code reports the connected server and tool count.

In Atlan, generate an API key under Admin Settings → API Keys / Tokens and copy it securely.

Add the API key-based server (replace <API_KEY> with your key). Cortex Code writes it to ~/.snowflake/cortex/mcp.json:

cortex mcp add atlan-api-key https://mcp.atlan.com/mcp/api-key --transport http -H "Authorization: Bearer <API_KEY>"

Start the MCP servers:
```
cortex mcp start
```
Because this uses a static token, it usually connects immediately. Confirm with cortex mcp list or /mcp.

tip

Pair Atlan's governance tools with Cortex Analyst: Cortex Analyst generates and runs the SQL, while Atlan supplies the certified definitions, ownership, and lineage that confirm you're querying the right data.

Requires a ChatGPT account and your Atlan domain. OAuth only.

Set up ChatGPT

Open in one click:

Open Atlan in ChatGPT

Or find it manually: in ChatGPT, go to Settings → Apps → Add more, search for Atlan, and select it.

Once the Atlan app is open, complete the sign-in:

Select Sign in with Atlan.
Enter your Atlan domain name (just the name, since the .atlan.com suffix is already added), then select Sign in:
```
your-tenant
```
Complete the OAuth login flow. ChatGPT redirects back and the Atlan app is ready to use.
Start using Atlan MCP tools in chat. For example:
```
show downstream assets for DIM_CUSTOMER
```

Connect Claude on the web (claude.ai) or in the Claude Desktop app.

Set up Claude

Claude.ai (web) adds Atlan as a custom connector. OAuth only, on a plan that supports connectors, and an org admin must add the connector once.
Claude Desktop configures the connection locally through the mcp-remote bridge (Node.js required, for npx). OAuth or API key.

Claude.ai (web)
Claude Desktop (OAuth)
Claude Desktop (API key)

In Claude, go to Settings → Connectors → Organisation Connector → Add custom connector and provide the MCP server URL. This must be done by an administrator.
```
https://mcp.atlan.com/mcp
```
Save the connector.
In the chat UI, go to Search and Tools → Add Custom Connector → Your Connector.
Select the Atlan connector and complete the OAuth login flow. Once authenticated, the connector is ready.

Open Claude Desktop and go to Settings → Developer → Edit Config.

Add the following configuration:

{
  "mcpServers": {
    "atlan": {
      "command": "npx",
      "args": [
        "mcp-remote",
        "https://mcp.atlan.com/mcp"
      ]
    }
  }
}

Restart Claude Desktop. A login prompt appears. After login, Claude Desktop connects using your Atlan roles and permissions.

In Atlan, generate an API key under Admin Settings → API Keys / Tokens and copy it securely.

Open Claude Desktop, go to Settings → Developer → Edit Config, and add:

{
  "mcpServers": {
    "atlan": {
      "command": "npx",
      "args": [
        "mcp-remote",
        "https://<your-tenant>.atlan.com/mcp/api-key",
        "--header",
        "Authorization: <your-api-key>"
      ]
    }
  }
}

Restart Claude Desktop. The server is available with API key authentication.

Requires Node.js 18+. Install the CLI with npm install -g @google/gemini-cli, run gemini once to sign in, then add the config below to ~/.gemini/settings.json (create it with mkdir -p ~/.gemini && touch ~/.gemini/settings.json if it doesn't exist).

Set up Gemini CLI

OAuth
API key

Add (or merge) this into ~/.gemini/settings.json. Don't include headers or tokens, since Gemini handles the OAuth flow:

{
  "mcpServers": {
    "Atlan OAuth Server": {
      "httpUrl": "https://mcp.atlan.com/mcp",
      "oauth": {
        "enabled": true
      }
    }
  }
}

Save and restart Gemini CLI with gemini. The server appears but isn't authorized yet.
In your session, run /mcp auth Atlan OAuth Server. A browser window opens, where you sign in, and Gemini stores the tokens locally.
Verify with /mcp. The server shows as CONNECTED.

Generate an API key under Admin Settings → API Keys / Tokens.

Add (or merge) this into ~/.gemini/settings.json, replacing <your-tenant> and <atlan_api_key_here>:

{
  "mcpServers": {
    "Atlan API Key Server": {
      "httpUrl": "https://<your-tenant>.atlan.com/mcp/api-key",
      "headers": {
        "Authorization": "Bearer <atlan_api_key_here>"
      }
    }
  }
}

Save and restart Gemini CLI with gemini. Because this uses static headers, it usually works immediately. Verify with /mcp.

Glean acts as an MCP host. Requires a Glean admin account with access to Admin Console → Platform → Actions, and network reachability from Glean to the Atlan MCP endpoint.

Set up Glean

OAuth
API key

In Glean, go to Admin Console → Platform → Actions and select Import tools from MCP server.
Enter the connection details:
- MCP server name: a recognizable name, for example Atlan.
- MCP server URL: the OAuth endpoint https://mcp.atlan.com/mcp.
- Transport type: Streaming HTTP (or SSE if required).
- Authentication method: OAuth User, so each user authenticates with their own Atlan account. Glean supports PKCE.
Provide the OAuth configuration (authorization URL, token URL, client ID, scopes) from your Atlan tenant's OAuth settings. Glean doesn't support the client-credentials flow, so use an authorization-code (user) flow. If you're unsure of the values, contact Atlan Support.
Save the connection. Glean discovers the tools and makes them available to publish as actions. Publish the tools you want, applying role-based access for sensitive or write tools.

In Atlan, generate an API key under Admin Settings → API Keys / Tokens and copy it securely.
In Glean, go to Admin Console → Platform → Actions and select Import tools from MCP server.
Enter the connection details:
- MCP server name: a recognizable name, for example Atlan.
- MCP server URL: the API key endpoint https://<your-tenant>.atlan.com/mcp/api-key.
- Transport type: Streaming HTTP (or SSE if required).
- Authentication method: API Key, with the header Authorization: Bearer <API_KEY>.
Save the connection, then publish the tools you want to expose.

OAuth only. Requires Node.js 18+ (for the mcp-remote bridge) and the Google ADK package (pip install google-adk for Python or npm install @google/adk for TypeScript).

Set up Google ADK

Python
TypeScript

Create an agent file (for example, agent.py):

from google.adk.agents import Agent
from google.adk.tools.mcp_tool import McpToolset
from google.adk.tools.mcp_tool.mcp_session_manager import StdioConnectionParams
from mcp import StdioServerParameters

root_agent = Agent(
    model="gemini-flash-latest",
    name="atlan_agent",
    instruction="Help users search, explore, and govern data assets in Atlan",
    tools=[
        McpToolset(
            connection_params=StdioConnectionParams(
                server_params=StdioServerParameters(
                    command="npx",
                    args=[
                        "-y",
                        "mcp-remote",
                        "https://mcp.atlan.com/mcp",
                    ]
                ),
                timeout=30,
            ),
        )
    ],
)

Run your agent with adk run agent.py.
On first run, a browser window opens for OAuth approval. Sign in with your Atlan account. (If it doesn't open, copy the authorization URL printed in the terminal.) The agent then connects using your roles and permissions.

Create an agent file (for example, agent.ts):

import { LlmAgent, MCPToolset } from "@google/adk";

const rootAgent = new LlmAgent({
  model: "gemini-flash-latest",
  name: "atlan_agent",
  instruction: "Help users search, explore, and govern data assets in Atlan",
  tools: [
    new MCPToolset({
      type: "StdioConnectionParams",
      serverParams: {
        command: "npx",
        args: [
          "-y",
          "mcp-remote",
          "https://mcp.atlan.com/mcp",
        ],
      },
    }),
  ],
});

export { rootAgent };

Run your agent with adk run agent.ts.
On first run, a browser window opens for OAuth approval. Sign in with your Atlan account. (If it doesn't open, copy the authorization URL printed in the terminal.) The agent then connects using your roles and permissions.

Requires Microsoft Copilot Studio access with permissions to create agents and tools.

Set up Microsoft Copilot Studio

OAuth
API key

In Copilot Studio, go to Agents, create a new agent (name and description), then select Create.
Open the agent, go to the Tools tab, and select New tool. In the wizard, select Model Context Protocol as the tool type.
Add a name and description, then set Server URL to:
```
https://mcp.atlan.com/mcp
```
Under Authentication, select OAuth 2.0, and for Type select Dynamic discovery. Copilot Studio registers the client and discovers the endpoints automatically, with no client ID, secret, or URLs needed. Select Create.
On Add tool, next to Connection, select Create new connection and sign in with your Atlan account. When the status shows Connected, select Add and configure.
Open the chat panel and run a query, such as Search for tables in Atlan.

note

If your first query returns a system error, run it again. The initial tool call can occasionally fail on the first attempt.

In Copilot Studio, go to Agents, create a new agent, then Create.
Open the agent, go to the Tools tab, select New tool, and choose Model Context Protocol as the tool type.
Add a name and description. For Authentication type, choose API key, and set the Server URL to:
```
https://<your-tenant>.atlan.com/mcp/api-key
```
For authentication type choose Header and set Header name to APIKEY. Click Create.
Enter the Atlan API key you generated under Admin Settings → API Keys / Tokens, then click Create to finish adding the tool. Open the Chatbot panel and run a query.

Requires n8n. API key authentication only.

Set up n8n

n8n AI Agent node and LiteLLM

n8n doesn't include a native LiteLLM node for the Agent chat model. Community LiteLLM nodes may fail. If you need LiteLLM models, use the OpenAI Chat Model node with the Atlan gateway as the base URL and your Atlan API key.

In Atlan, generate an API key under Admin Settings → API Keys / Tokens.
In n8n, create a new Workflow and add an MCP Client node.
In the MCP Client node, choose the action List Tools to test the connection.
Under Credentials, select Create New Credentials and fill in:
- HTTP Stream URL: https://<your-tenant>.atlan.com/mcp/api-key
- HTTP Connection Timeout: 60000
- Additional Headers: Authorization = Bearer <your-api-key>
Save the credentials and execute the node with List Tools to see all MCP tools in your tenant. To run a tool, change Operation to Execute Tool, select the tool (for example, semantic_search), and fill in its parameters.

Set up Claude Code (Plugin)

Set up Claude Code (Manual)

Set up Codex (Plugin)

Set up Codex (Manual)

Set up Cursor (Plugin)

Set up Cursor (Manual)

Set up VS Code (Extension)

Set up VS Code (Manual)

Set up Windsurf

Set up Databricks

Set up Snowflake Cortex Code

Set up ChatGPT

Set up Claude

Set up Gemini CLI

Set up Glean

Set up Google ADK

Set up Microsoft Copilot Studio

Set up n8n

Next steps

Need help?

Set up Claude Code (Plugin)

Set up Claude Code (Manual)

Set up Codex (Plugin)

Set up Codex (Manual)

Set up Cursor (Plugin)

Set up Cursor (Manual)

Set up VS Code (Extension)

Set up VS Code (Manual)

Set up Windsurf

Set up Databricks

Set up Snowflake Cortex Code

Set up ChatGPT

Set up Claude

Set up Gemini CLI

Set up Glean

Set up Google ADK

Set up Microsoft Copilot Studio

Set up n8n

Next steps​

Need help?​

Next steps

Need help?