> ## Documentation Index
> Fetch the complete documentation index at: https://docs.pleri.ai/llms.txt
> Use this file to discover all available pages before exploring further.

# MCP (AI Clients)

> Connect me to Claude Code, Claude Desktop, Cursor, VS Code, Windsurf, Zed, and more using the Model Context Protocol.

I now speak [Model Context Protocol (MCP)](https://modelcontextprotocol.io) — which means you can plug me directly into the AI tools your team already uses. Ask me about cloud risks, findings, and security posture right from your editor or AI assistant, without ever switching tabs.

## What you'll need

Before connecting an AI client, grab two things:

<Steps>
  <Step title="A Plerion API token">
    Head to **[Settings → API Keys](https://app.plerion.com/settings/api-keys)** in the Plerion dashboard and create a new API key.

    Your token will look like: `plerion_tak_...`

    <Warning>Treat your API key like a password. Don't commit it to source control or share it in chat.</Warning>
  </Step>

  <Step title="Your MCP endpoint URL">
    My MCP server runs at:

    ```
    https://{region}.api.plerion.com/pleri/mcp
    ```

    Replace `{region}` with your account region — typically `au`, `us`, or `eu`. If you're not sure, check the URL you use to access the Plerion dashboard.
  </Step>
</Steps>

***

## Connect your AI client

<Tabs>
  <Tab title="Claude Code">
    Claude Code supports remote HTTP MCP servers natively. The quickest way is the CLI:

    ```bash theme={"system"}
    claude mcp add --transport http pleri \
      https://{region}.api.plerion.com/pleri/mcp \
      --header "Authorization: Bearer plerion_tak_your_key_here"
    ```

    Or add it manually to your project's `.mcp.json` file (create it in your repo root if it doesn't exist):

    ```json theme={"system"}
    {
      "mcpServers": {
        "pleri": {
          "type": "http",
          "url": "https://{region}.api.plerion.com/pleri/mcp",
          "headers": {
            "Authorization": "Bearer plerion_tak_your_key_here"
          }
        }
      }
    }
    ```

    To add it globally (available in all projects), use `~/.claude.json` with the same structure under `mcpServers`.

    <Tip>Run `claude mcp list` to confirm Pleri is connected, and `claude mcp get pleri` to inspect the config.</Tip>
  </Tab>

  <Tab title="Claude Desktop">
    Claude Desktop connects to remote MCP servers via `mcp-remote` (Node.js required).

    **1. Open your config file:**

    * macOS: `~/Library/Application Support/Claude/claude_desktop_config.json`
    * Windows: `%APPDATA%\Claude\claude_desktop_config.json`

    **2. Add the Pleri MCP server:**

    ```json theme={"system"}
    {
      "mcpServers": {
        "pleri": {
          "command": "npx",
          "args": [
            "mcp-remote@latest",
            "https://{region}.api.plerion.com/pleri/mcp",
            "--header",
            "Authorization: Bearer ${PLERION_API_KEY}"
          ],
          "env": {
            "PLERION_API_KEY": "plerion_tak_your_key_here"
          }
        }
      }
    }
    ```

    **3. Restart Claude Desktop** — it must be fully quit and reopened to pick up config changes.

    Once connected, you'll see Pleri listed under the MCP tools icon in Claude Desktop.
  </Tab>

  <Tab title="Cursor">
    Cursor has native HTTP MCP support — no wrapper needed.

    **1. Open your MCP config:**

    * Global: `~/.cursor/mcp.json`
    * Project-scoped: `.cursor/mcp.json` in your repo root

    Or go to **Settings → Tools & Integrations → Add Custom MCP**.

    **2. Add the Pleri MCP server:**

    ```json theme={"system"}
    {
      "mcpServers": {
        "pleri": {
          "url": "https://{region}.api.plerion.com/pleri/mcp",
          "headers": {
            "Authorization": "Bearer ${PLERION_API_KEY}"
          },
          "env": {
            "PLERION_API_KEY": "plerion_tak_your_key_here"
          }
        }
      }
    }
    ```

    Cursor picks up config changes automatically — no restart needed.
  </Tab>

  <Tab title="VS Code">
    Supported via **GitHub Copilot** (native HTTP) or the **Cline** extension.

    **GitHub Copilot** — open or create `.vscode/mcp.json` in your workspace:

    ```json theme={"system"}
    {
      "servers": {
        "pleri": {
          "type": "http",
          "url": "https://{region}.api.plerion.com/pleri/mcp",
          "headers": {
            "Authorization": "Bearer plerion_tak_your_key_here"
          }
        }
      }
    }
    ```

    **Cline extension** — open Cline settings and add under MCP Servers:

    ```json theme={"system"}
    {
      "mcpServers": {
        "pleri": {
          "type": "streamableHttp",
          "url": "https://{region}.api.plerion.com/pleri/mcp",
          "headers": {
            "Authorization": "Bearer plerion_tak_your_key_here"
          }
        }
      }
    }
    ```

    <Tip>VS Code can auto-discover MCP servers from Claude Desktop if you've already set it up there. Enable **`chat.mcp.discovery.enabled`** in VS Code settings.</Tip>
  </Tab>

  <Tab title="Windsurf">
    **1. Open your MCP config:**

    * macOS: `~/.codeium/windsurf/mcp_config.json`
    * Windows: `%USERPROFILE%\.codeium\windsurf\mcp_config.json`

    **2. Add the Pleri MCP server:**

    ```json theme={"system"}
    {
      "mcpServers": {
        "pleri": {
          "serverUrl": "https://{region}.api.plerion.com/pleri/mcp",
          "headers": {
            "Authorization": "Bearer ${env:PLERION_API_KEY}"
          }
        }
      }
    }
    ```

    Set `PLERION_API_KEY` in your shell environment, or paste your token directly in place of `${env:PLERION_API_KEY}`.

    Windsurf auto-restarts the context server after config changes — no editor restart needed.
  </Tab>

  <Tab title="Zed">
    Zed uses `mcp-remote` as a bridge for HTTP servers (Node.js required).

    **1. Open Zed settings** (`Cmd+,`) and add to your `settings.json`:

    ```json theme={"system"}
    {
      "context_servers": {
        "pleri": {
          "source": "custom",
          "command": "npx",
          "args": [
            "-y",
            "mcp-remote",
            "https://{region}.api.plerion.com/pleri/mcp",
            "--header",
            "Authorization: Bearer ${PLERION_API_KEY}"
          ],
          "env": {
            "PLERION_API_KEY": "plerion_tak_your_key_here"
          }
        }
      }
    }
    ```

    Zed reloads settings automatically — no restart required.
  </Tab>
</Tabs>

***

## What you can ask me

Once connected, just talk to me naturally in your AI client. Here are some things I can help with:

* **"What are our top cloud security risks right now?"**\
  I'll pull live findings from your Plerion environment and explain what needs attention most.

* **"Are there any critical findings in our AWS account?"**\
  I'll surface high-severity issues, explain the risk, and suggest next steps.

* **"Show me recent security posture changes."**\
  I'll summarise what's improved, what's new, and what the team should look at.

* **"Help me write a fix for this misconfigured S3 bucket."**\
  I'll combine context from your cloud environment with the code in your editor.

* **"What compliance gaps do we have for SOC 2?"**\
  I'll map current findings to your compliance framework and flag what's missing.

***

<Tip>For the richest experience — where I can take action, file tickets, and work autonomously — use me via **[Slack](/tools/slack)** or the **[Chrome extension](/tools/chrome)**. MCP is perfect for bringing my cloud security context right into your AI workflow.</Tip>