## Set up Atlan MCP

URL: https://docs.atlan.com/product/capabilities/atlan-ai/how-tos/remote-mcp-overview

> Connect Claude, Cursor, ChatGPT, VS Code, Copilot, Gemini, Snowflake, Databricks, and other AI clients to the Atlan MCP server. One page, pick your client, get step-by-step setup.

# Set up Atlan MCP

The Atlan MCP server makes your context layer callable by any AI tool—search enterprise context, traverse end-to-end lineage, read governed definitions, and run SQL, every answer grounded in trusted metadata.

Connect your AI tools to the **Atlan MCP server** to search and discover enterprise context, traverse end-to-end lineage, access governed data definitions and glossaries, execute SQL, curate your metadata graph, and maintain data quality. Every answer is grounded in trusted organizational context and governed by the permissions you've already set in Atlan. Atlan MCP is hosted and enabled for all Atlan tenants, with nothing to install or run.

## Set up Claude Code

Requires [Claude Code](https://claude.ai/download) installed and available in your terminal.

### Plugin

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

```bash
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.

### Manual

### OAuth

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

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

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

2. Start Claude Code:

 ```bash
 claude
 ```

3. In the Claude Code terminal, type `/mcp`.

4. When prompted, complete the OAuth flow in your browser. The Atlan MCP server is then available in Claude Code.

### API key

Authenticate with a static API token, best for automation.

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

2. Add the API key-based Atlan MCP server:

 ```bash
 claude mcp add-json atlan-api-key '{"type":"http","url":"https://mcp.atlan.com/mcp","headers":{"Authorization":"Bearer "}}'
 ```

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

## Set up Codex

Requires [OpenAI Codex](https://developers.openai.com/codex) (desktop app, CLI, or both).

### Plugin

1. Register Atlan's marketplace with Codex:

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

2. Install the Atlan plugin:

 ```bash
 codex plugin add atlan@atlan
 ```

 The `atlan@atlan` slug follows Codex's `<plugin-name>@<marketplace-name>` convention.

3. 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:

 ```bash
 codex mcp add atlan --url https://mcp.atlan.com/mcp
 ```

4. Quit and relaunch Codex so the server loads (Cmd+Q for the desktop app, or restart the CLI). The plugin appears under **Plugins → Manage**.

5. Inside a Codex session, run `/mcp` to inspect connected servers, then ask anything Atlan-related.

### Manual

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

1. 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:

 ```bash
 codex mcp add atlan --url https://mcp.atlan.com/mcp
 ```

2. Exit and re-run the Codex CLI so the server loads, then run `/mcp` to verify it's connected.

## Set up Cursor

Requires [Cursor](https://docs.cursor.com/en/tools/mcp) installed and updated to the latest version.

### 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](https://cursor.com/marketplace/atlan)

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

Or add it from inside Cursor:

1. Press `Cmd+Shift+J` (macOS) or `Ctrl+Shift+J` (Windows/Linux) to open settings, then go to **Plugins**.

2. Search for **Atlan** and click **Install**.

3. 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.

4. 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.
:::

### Manual

### OAuth

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

Install in one click:

[Add to Cursor](cursor://anysphere.cursor-deeplink/mcp/install?name=atlan&config=eyJ1cmwiOiJodHRwczovL21jcC5hdGxhbi5jb20vbWNwIiwidHlwZSI6Imh0dHAifQ==)

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

```json
{
 "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.

### API key

Authenticate with a static API token, best for automation.

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

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

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

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

## Set up VS Code

Requires [VS Code](https://code.visualstudio.com/). The extension also works in Cursor and Windsurf via VSIX.

### Extension

1. Install the [Atlan extension from the VS Code Marketplace](https://marketplace.visualstudio.com/items?itemName=atlan.atlan), or open the **Extensions** view (`Cmd+Shift+X` / `Ctrl+Shift+X`), search for **Atlan**, and click **Install**.

2. Click the **Atlan** icon in the Activity Bar to open the sidebar.

3. 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)**.

4. The extension registers the Atlan MCP server automatically on first activation. To re-register later, run **Atlan: Setup MCP Server**.

5. Open GitHub Copilot Chat (or any MCP-aware assistant) and trigger an Atlan tool, for example: "search Atlan for the customers table".

### Manual

### OAuth

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](vscode:mcp/install?%7B%22name%22%3A%22atlan%22%2C%22url%22%3A%22https%3A%2F%2Fmcp.atlan.com%2Fmcp%22%2C%22type%22%3A%22http%22%7D)

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`:

```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.

### API key

Authenticate with a static API token, best for automation.

1. In Atlan, generate an API key under **Admin Settings → API access → Tokens**.

2. Open the Command Palette (`Cmd+Shift+P` / `Ctrl+Shift+P`) and run **MCP: Open User Configuration**.

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

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

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

## Set up Windsurf

Requires [Windsurf](https://docs.windsurf.com/windsurf/getting-started). API key authentication only.

### Manual

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

2. In Windsurf, open the MCP configuration file and add:

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

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

## Set up Databricks

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](https://docs.atlan.com/llms/platform/get-started/oauth-clients/llms.txt).

### Marketplace

1. In Databricks, open **Marketplace**, search for **MCP**, then select **Atlan**.

2. Select **Install** to open the wizard. Enter a **Connection name** and your Atlan **OAuth client ID** and **client secret**, then select **Install**.

3. Go to **Catalog → Connect → Connections**, select your Atlan MCP connection, and select **Login**.

4. 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.

5. 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**.

## Set up Snowflake

Connect from the Snowflake UI so CoWork agents can use Atlan tools, or register the server with the Cortex Code CLI.

### CoWork agents

Requires access to **Agents settings** in Snowflake CoWork.

:::note
The setup uses Dynamic Client Registration (DCR), so no OAuth client ID or secret is needed.
:::

1. In Snowflake CoWork, go to **Agents settings → Tools and connectors** and select **Add custom**.

2. In the **Add MCP Connector** dialog, choose a **Location** and enter a **Name** (for example, `Atlan`) and a **Description**.

3. Under **API Integration**, select **Dynamic Client Registration (DCR)** and enter:

 - **Server URL**: `https://mcp.atlan.com/mcp`
 - **Scopes**: `mcp`

4. Select **Add**. When prompted, complete the OAuth sign-in with your Atlan account (SSO supported). The connector then uses your Atlan roles and permissions.

5. To verify, open a CoWork chat and ask an Atlan question, for example: "How many dashboards do I have in Atlan?" The agent answers using your governed Atlan metadata.

:::note
To use a pre-created OAuth client instead, select **Standard OAuth** in the dialog and supply the client ID, client secret, and endpoints from an Atlan OAuth client, generated under **Settings (Admin) → API access → OAuth**. For more information, see [OAuth clients](https://docs.atlan.com/llms/platform/get-started/oauth-clients/llms.txt). For most teams, Dynamic Client Registration is the simpler path.
:::

### Cortex CLI

Requires [Snowflake Cortex Code](https://docs.snowflake.com/en/user-guide/cortex-code/cortex-code) v1.0.61+ (check with `cortex --version`).

### OAuth

1. Add the OAuth-based Atlan MCP server. Cortex Code writes it to `~/.snowflake/cortex/mcp.json`:

 ```bash
 cortex mcp add atlan https://mcp.atlan.com/mcp --transport http
 ```

2. Start the MCP servers (or just start a `cortex` session, where configured servers initialize automatically):

 ```bash
 cortex mcp start
 ```

3. When prompted, complete the OAuth flow in your browser. The token is stored under `~/.snowflake/cortex/mcp_oauth/`.

4. 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.

### API key

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

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

 ```bash
 cortex mcp add atlan-api-key https://mcp.atlan.com/mcp --transport http -H "Authorization: Bearer "
 ```

3. Start the MCP servers:

 ```bash
 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.
:::

## Set up ChatGPT

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

### ChatGPT app

Open in one click:

[Open Atlan in ChatGPT](https://chatgpt.com/apps/atlan/asdk_app_6a204b2923fc8191bcbd87ec6dc9d382)

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:

1. Select **Sign in with Atlan**.

2. Enter your **Atlan domain** name (just the name, since the `.atlan.com` suffix is already added), then select **Sign in**:

 ```
 your-tenant
 ```

3. Complete the OAuth login flow. ChatGPT redirects back and the Atlan app is ready to use.

4. Start using Atlan MCP tools in chat. For example:

 ```
 show downstream assets for DIM_CUSTOMER
 ```

## Set up Claude

Connect Claude on the web ([claude.ai](https://claude.ai)) or in the Claude Desktop app.

### Connector

- **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](https://nodejs.org/) required, for `npx`). OAuth or API key.

### Claude.ai (web)

1. 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
 ```

2. Save the connector.

3. In the chat UI, go to **Search and Tools → Add Custom Connector → Your Connector**.

4. Select the Atlan connector and complete the OAuth login flow. Once authenticated, the connector is ready.

### Claude Desktop (OAuth)

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

2. Add the following configuration:

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

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

### Claude Desktop (API key)

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

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

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

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

## Set up Gemini CLI

Requires [Node.js 18+](https://nodejs.org/). 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).

### Manual

### OAuth

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

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

2. Save and restart Gemini CLI with `gemini`. The server appears but isn't authorized yet.

3. In your session, run `/mcp auth Atlan OAuth Server`. A browser window opens, where you sign in, and Gemini stores the tokens locally.

4. Verify with `/mcp`. The server shows as `CONNECTED`.

### API key

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

2. Add (or merge) this into `~/.gemini/settings.json`, replacing `<atlan_api_key_here>`:

 ```json
 {
 "mcpServers": {
 "Atlan API Key Server": {
 "httpUrl": "https://mcp.atlan.com/mcp",
 "headers": {
 "Authorization": "Bearer <atlan_api_key_here>"
 }
 }
 }
 }
 ```

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

## Set up Glean

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.

### Glean Actions

### OAuth

1. In Glean, go to **Admin Console → Platform → Actions** and select **Import tools from MCP server**.

2. 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.

3. 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](https://docs.atlan.com/support/submit-request).

4. 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.

### API key

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

2. In Glean, go to **Admin Console → Platform → Actions** and select **Import tools from MCP server**.

3. Enter the connection details:

 - **MCP server name**: a recognizable name, for example `Atlan`.
 - **MCP server URL**: the hosted endpoint `https://mcp.atlan.com/mcp`.
 - **Transport type**: **Streaming HTTP** (or **SSE** if required).
 - **Authentication method**: **API Key**, with the header `Authorization: Bearer `.

4. Save the connection, then publish the tools you want to expose.

## Set up Google ADK

OAuth only. Requires [Node.js 18+](https://nodejs.org/) (for the [`mcp-remote`](https://www.npmjs.com/package/mcp-remote) bridge) and the [Google ADK](https://google.github.io/adk-docs/) package (`pip install google-adk` for Python or `npm install @google/adk` for TypeScript).

### ADK agent

### Python

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

 ```python
 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,
 ),
 )
 ],
 )
 ```

2. Run your agent with `adk run agent.py`.

3. 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.

### TypeScript

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

 ```typescript
 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 };
 ```

2. Run your agent with `adk run agent.ts`.

3. 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.

## Set up Microsoft Copilot Studio

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

### Copilot Studio

### OAuth

1. In Copilot Studio, go to **Agents**, create a new agent (name and description), then select **Create**.

2. Open the agent, go to the **Tools** tab, and select **New tool**. In the wizard, select **Model Context Protocol** as the tool type.

3. Add a **name** and **description**, then set **Server URL** to:

 ```
 https://mcp.atlan.com/mcp
 ```

4. 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**.

5. 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**.

6. 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.
:::

### API key

1. In Copilot Studio, go to **Agents**, create a new agent, then **Create**.

2. Open the agent, go to the **Tools** tab, select **New tool**, and choose **Model Context Protocol** as the tool type.

3. Add a **name** and **description**. For **Authentication type**, choose **API key**, and set the **Server URL** to:

 ```
 https://mcp.atlan.com/mcp
 ```

4. For authentication type choose **Header** and set **Header name** to `Authorization`. Click **Create**.

5. 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.

## Set up n8n

Requires [n8n](https://docs.n8n.io/). API key authentication only.

### Manual

:::info 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.
:::

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

2. In n8n, create a new **Workflow** and add an **MCP Client** node.

3. In the MCP Client node, choose the action **List Tools** to test the connection.

4. Under **Credentials**, select **Create New Credentials** and fill in:

 - **HTTP Stream URL**: `https://mcp.atlan.com/mcp`
 - **HTTP Connection Timeout**: `60000`
 - **Additional Headers**: `Authorization = Bearer <your-api-key>`

5. 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.

## Next steps

Once you're connected, see [**What you can do with Atlan MCP**](https://docs.atlan.com/product/capabilities/atlan-ai/use-cases/mcp-use-cases) for ready-to-run prompts and workflows across discovery, lineage, governance, data engineering, and catalog adoption.

For deeper reference, browse the [full list of MCP tools](https://docs.atlan.com/llms/governance/atlan-mcp-overview/mcp-tools/llms.txt) or review [Atlan MCP security](https://docs.atlan.com/llms/governance/atlan-mcp-overview/mcp-security/llms.txt) (read-only mode, data handling, authentication, and audit logging).

## Need help?

If you have any issues connecting your client, contact [**Atlan Support**](https://docs.atlan.com/support/submit-request) for assistance.

---