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

# Installation

> Step-by-step setup guide for integrating WISTX with Cursor, Claude Desktop, Windsurf, and other AI coding assistants

> Quick setup instructions to get WISTX running with your preferred AI coding assistant in minutes.

<Steps>
  <Step title="Complete Onboarding">
    Visit [wistx.ai/api-key](https://wistx.ai/api-key) and complete the onboarding process. Your API key will be automatically created.

    <Info>
      You'll get 3 free index jobs and 50 queries/month to start - no credit card required!
    </Info>
  </Step>

  <Step title="Choose Installation Method">
    WISTX supports two installation methods:

    **Remote Server (Recommended)** - Zero dependencies, always up-to-date, works on any machine
    **Local Server** - Requires Python 3.11+ and pipx/uvx

    <Info>
      **Remote Server is recommended** - no local installation needed, works immediately, always up-to-date.
    </Info>
  </Step>

  <Step title="Configure Your MCP Client">
    Choose your coding agent below for specific configuration steps. Each section includes both **Remote Server (Recommended)** and **Local Server** options.
  </Step>

  <Step title="Restart Your Coding Agent">
    Restart your coding assistant to load the new MCP server. The tools will be available immediately after restart.
  </Step>
</Steps>

## Quick Install (30 Seconds)

Don't want to configure manually? Use our automated setup script:

<CodeGroup>
  ```bash Remote Server (Recommended - No Dependencies) theme={null}
  curl -fsSL https://api.wistx.ai/v1/setup/script | bash -s -- YOUR_API_KEY cursor --remote
  ```

  ```bash Local Server theme={null}
  curl -fsSL https://api.wistx.ai/v1/setup/script | bash -s -- YOUR_API_KEY cursor
  ```
</CodeGroup>

**Supported IDEs:** `cursor`, `vscode`, `windsurf`, `cline`, `antigravity`, `trae`, `continue`, `claude-desktop`, `claude-code`, `codex`, `gemini-cli`, `factory`, `amp`, `warp`, `copilot-agent`, `copilot-cli`, `opencode`, `crush`, `amazon-q`, `augment`, `jetbrains`, `zed`, `roo-code`, `kilo-code`, `qodo-gen`, `qwen-coder`, `visual-studio`, `lm-studio`, `bolt-ai`, `perplexity`

## That's It!

You're ready to start using WISTX MCP! Check out the [Tools & Features](/integrations/tools-features) page to explore all available capabilities.

## Prerequisites

**For Remote Server (Recommended):**

* **Your WISTX API key** - Get it from [wistx.ai/api-key](https://wistx.ai/api-key) after completing onboarding
* **That's it!** No Python, no pipx, no local installation needed.

**For Local Server:**

* **Python 3.11 or higher** - Required for WISTX MCP server
* **pipx** (recommended) or **uvx** - For installing Python packages in isolated environments
* **Your WISTX API key** - Get it from [wistx.ai/api-key](https://wistx.ai/api-key) after completing onboarding

<Note>
  **Why Python 3.11+?** WISTX uses modern Python features and type hints that require Python 3.11 or higher for optimal performance and compatibility. This is only needed for local server installation.
</Note>

## Configuration by Coding Agent

WISTX MCP uses the standard MCP protocol, which means it should work with any MCP-compatible client. Below are configuration examples for the most popular coding agents.

<Note>
  **Tested & Verified:** Cursor, Windsurf, Claude Desktop, VS Code, Continue.dev, Claude Code, Codex, Cline, Google Antigravity, Gemini CLI, Factory, Amp, Warp, Copilot Agent, Copilot CLI, Opencode, Crush, Amazon Q Developer CLI, Augment Code, JetBrains IDEs, Zed, Roo Code, Kilo Code, Qodo Gen, Qwen Coder, Visual Studio, LM Studio, Bolt AI, Perplexity, Trae

  **Total Supported:** 30+ IDEs and AI coding tools

  If your coding agent supports MCP, it should work with WISTX. Configuration format may vary slightly between clients.

  **DevOps-Focused:** WISTX is particularly well-suited for DevOps and infrastructure workflows, providing compliance requirements, infrastructure pricing, and best practices context directly to your AI coding assistant.
</Note>

<Tabs>
  <Tab title="Cursor">
    <CardGroup cols={1}>
      <Card title="⚡ One-Click Installation" icon="zap" href="cursor://mcp/install?name=wistx&command=pipx&args=run,--no-cache,wistx-mcp&env=WISTX_API_KEY">
        Click this button to automatically configure WISTX MCP server in Cursor. Cursor will open and prompt you to enter your API key from [wistx.ai/api-key](https://wistx.ai/api-key).
      </Card>
    </CardGroup>

    <Info>
      **Quick Setup:** Use the one-click installation button above for the fastest setup experience. Cursor will handle the configuration automatically.

      **Automated Setup:** Or use our setup script: `curl -fsSL https://api.wistx.ai/v1/setup/script | bash -s -- YOUR_API_KEY cursor --remote`

      **Manual Setup:** Prefer to configure manually? Follow the steps below.
    </Info>

    <Steps>
      <Step title="Open MCP Configuration">
        Go to: **Settings → Cursor Settings → MCP → Add new global MCP server**

        In Cursor 1.0 and later, manually edit:

        * **macOS**: `~/.cursor/mcp.json`
        * **Windows**: `%APPDATA%\Cursor\mcp.json`
        * **Linux**: `~/.config/cursor/mcp.json`
      </Step>

      <Step title="Add WISTX Configuration">
        <CodeGroup>
          ```json Remote Server (Recommended - No Dependencies) theme={null}
          {
            "mcpServers": {
              "wistx": {
                "url": "https://api.wistx.ai/v1/mcp/request",
                "headers": {
                  "Authorization": "Bearer YOUR_API_KEY"
                }
              }
            }
          }
          ```

          ```json Local Server theme={null}
          {
            "mcpServers": {
              "wistx": {
                "command": "pipx",
                "args": ["run", "--no-cache", "wistx-mcp"],
                "env": {
                  "WISTX_API_KEY": "YOUR_API_KEY"
                }
              }
            }
          }
          ```
        </CodeGroup>
      </Step>
    </Steps>
  </Tab>

  <Tab title="Windsurf">
    <Info>
      **Quick Setup:** Use our automated setup script: `curl -fsSL https://api.wistx.ai/v1/setup/script | bash -s -- YOUR_API_KEY windsurf --remote`
    </Info>

    <Steps>
      <Step title="Open MCP Configuration">
        Open your Windsurf MCP configuration file:

        * **macOS**: `~/.codeium/windsurf/mcp_config.json`
        * **Windows**: `%APPDATA%\Codeium\Windsurf\mcp_config.json`
        * **Linux**: `~/.codeium/windsurf/mcp_config.json`
      </Step>

      <Step title="Add WISTX Configuration">
        <CodeGroup>
          ```json Remote Server (Recommended) theme={null}
          {
            "mcpServers": {
              "wistx": {
                "serverUrl": "https://api.wistx.ai/v1/mcp/request",
                "headers": {
                  "Authorization": "Bearer YOUR_API_KEY"
                }
              }
            }
          }
          ```

          ```json Local Server theme={null}
          {
            "mcpServers": {
              "wistx": {
                "command": "pipx",
                "args": ["run", "--no-cache", "wistx-mcp"],
                "env": {
                  "WISTX_API_KEY": "YOUR_API_KEY"
                }
              }
            }
          }
          ```
        </CodeGroup>
      </Step>
    </Steps>
  </Tab>

  <Tab title="Claude Desktop">
    <Info>
      **Quick Setup:** Use our automated setup script: `curl -fsSL https://api.wistx.ai/v1/setup/script | bash -s -- YOUR_API_KEY claude-desktop --remote`
    </Info>

    <Steps>
      <Step title="Open Configuration File">
        Edit your Claude Desktop configuration:

        * **macOS**: `~/Library/Application Support/Claude/claude_desktop_config.json`
        * **Windows**: `%APPDATA%\Claude\claude_desktop_config.json`
        * **Linux**: `~/.config/Claude/claude_desktop_config.json`
      </Step>

      <Step title="Add WISTX Configuration">
        <CodeGroup>
          ```json Remote Server (Recommended) theme={null}
          {
            "mcpServers": {
              "wistx": {
                "serverUrl": "https://api.wistx.ai/v1/mcp/request",
                "headers": {
                  "Authorization": "Bearer YOUR_API_KEY"
                }
              }
            }
          }
          ```

          ```json Local Server theme={null}
          {
            "mcpServers": {
              "wistx": {
                "command": "pipx",
                "args": ["run", "--no-cache", "wistx-mcp"],
                "env": {
                  "WISTX_API_KEY": "YOUR_API_KEY"
                }
              }
            }
          }
          ```
        </CodeGroup>
      </Step>
    </Steps>
  </Tab>

  <Tab title="VS Code">
    <Info>
      **Quick Setup:** Use our automated setup script: `curl -fsSL https://api.wistx.ai/v1/setup/script | bash -s -- YOUR_API_KEY vscode --remote`
    </Info>

    <Steps>
      <Step title="Open MCP Configuration">
        Open your VS Code MCP configuration file. You can either:

        * Run the **MCP: Open User Configuration** command from the Command Palette (opens `mcp.json` in your user profile)
        * Use **MCP: Add Server** command and select **Global** to add to your profile
        * Or manually edit the file at:
          * **macOS/Linux**: `~/.config/Code/User/mcp.json`
          * **Windows**: `%APPDATA%\Code\User\mcp.json`
      </Step>

      <Step title="Add WISTX Configuration">
        <CodeGroup>
          ```json Remote Server (Recommended) theme={null}
          {
            "servers": {
              "wistx": {
                "type": "http",
                "url": "https://api.wistx.ai/v1/mcp/request",
                "headers": {
                  "Authorization": "Bearer YOUR_API_KEY"
                }
              }
            }
          }
          ```

          ```json Local Server theme={null}
          {
            "servers": {
              "wistx": {
                "type": "stdio",
                "command": "pipx",
                "args": ["run", "--no-cache", "wistx-mcp"],
                "env": {
                  "WISTX_API_KEY": "YOUR_API_KEY"
                }
              }
            }
          }
          ```
        </CodeGroup>

        <Note>
          When using multiple VS Code profiles, this allows you to switch between different MCP server configurations based on your active profile.
        </Note>
      </Step>
    </Steps>
  </Tab>

  <Tab title="Continue.dev">
    <Info>
      **Quick Setup:** Use our automated setup script: `curl -fsSL https://api.wistx.ai/v1/setup/script | bash -s -- YOUR_API_KEY continue --remote`
    </Info>

    <Steps>
      <Step title="Open Continue Configuration">
        Edit your `~/.continue/config.json` file
      </Step>

      <Step title="Add WISTX Configuration">
        <CodeGroup>
          ```json Remote Server (Recommended) theme={null}
          {
            "experimental": {
              "modelContextProtocolServer": {
                "transport": {
                  "type": "http",
                  "url": "https://api.wistx.ai/v1/mcp/request",
                  "headers": {
                    "Authorization": "Bearer YOUR_API_KEY"
                  }
                }
              }
            }
          }
          ```

          ```json Local Server theme={null}
          {
            "models": [...],
            "mcpServers": [
              {
                "name": "wistx",
                "command": "pipx",
                "args": ["run", "--no-cache", "wistx-mcp"],
                "env": {
                  "WISTX_API_KEY": "YOUR_API_KEY"
                }
              }
            ]
          }
          ```
        </CodeGroup>
      </Step>
    </Steps>
  </Tab>

  <Tab title="Claude Code">
    <Info>
      **Quick Setup:** Use our automated setup script: `curl -fsSL https://api.wistx.ai/v1/setup/script | bash -s -- YOUR_API_KEY claude-code --remote`
    </Info>

    <Steps>
      <Step title="Add WISTX Configuration">
        <CodeGroup>
          ```bash Remote Server (Recommended) theme={null}
          # For current project only (default)
          claude mcp add --transport http wistx https://api.wistx.ai/v1/mcp/request \
            --header "Authorization: Bearer YOUR_API_KEY"

          # For global installation (all projects)
          claude mcp add --transport http wistx https://api.wistx.ai/v1/mcp/request \
            --header "Authorization: Bearer YOUR_API_KEY" --scope user
          ```

          ```bash Local Server theme={null}
          # For current project only (default)
          claude mcp add wistx -e WISTX_API_KEY=YOUR_API_KEY -- pipx run --no-cache wistx-mcp

          # For global installation (all projects)
          claude mcp add wistx -e WISTX_API_KEY=YOUR_API_KEY --scope user -- pipx run --no-cache wistx-mcp
          ```
        </CodeGroup>

        <Note>
          **Scope Options:**

          * **Default (no --scope flag)**: Installs for current project only
          * **--scope user**: Installs globally for all projects on your machine

          Use `--scope user` if you want WISTX available across all your projects. This is ideal for personal development where you frequently use WISTX across different codebases.
        </Note>
      </Step>
    </Steps>
  </Tab>

  <Tab title="Codex">
    <Info>
      **Quick Setup:** Use our automated setup script: `curl -fsSL https://api.wistx.ai/v1/setup/script | bash -s -- YOUR_API_KEY codex --remote`
    </Info>

    <Steps>
      <Step title="Add WISTX Configuration">
        <CodeGroup>
          ```bash Remote Server (Recommended) theme={null}
          codex mcp add wistx --type http --url https://api.wistx.ai/v1/mcp/request \
            --header "Authorization: Bearer YOUR_API_KEY"
          ```

          ```bash Local Server theme={null}
          codex mcp add wistx --env WISTX_API_KEY=YOUR_API_KEY -- pipx run --no-cache wistx-mcp
          ```
        </CodeGroup>
      </Step>
    </Steps>
  </Tab>

  <Tab title="Cline">
    <Info>
      **Quick Setup:** Use our automated setup script: `curl -fsSL https://api.wistx.ai/v1/setup/script | bash -s -- YOUR_API_KEY cline --remote`
    </Info>

    <Steps>
      <Step title="Open MCP Configuration">
        Open your Cline MCP configuration file according to your IDE:

        * **VS Code**: Use the MCP configuration steps similar to Continue.dev
        * Check Cline's documentation for the specific configuration file location
      </Step>

      <Step title="Add WISTX Configuration">
        <CodeGroup>
          ```json Remote Server (Recommended) theme={null}
          {
            "mcpServers": {
              "wistx": {
                "url": "https://api.wistx.ai/v1/mcp/request",
                "type": "streamableHttp",
                "headers": {
                  "Authorization": "Bearer YOUR_API_KEY"
                }
              }
            }
          }
          ```

          ```json Local Server theme={null}
          {
            "mcpServers": {
              "wistx": {
                "command": "pipx",
                "args": ["run", "--no-cache", "wistx-mcp"],
                "env": {
                  "WISTX_API_KEY": "YOUR_API_KEY"
                }
              }
            }
          }
          ```
        </CodeGroup>
      </Step>
    </Steps>
  </Tab>

  <Tab title="Google Antigravity">
    <CardGroup cols={1}>
      <Card title="⚡ One-Click Installation" icon="zap">
        Antigravity includes an **MCP Server Store** with one-click installation. Open Antigravity IDE, navigate to "Manage MCPs" tab, click "View MCP server store", search for "WISTX", and click "Install". Antigravity will automatically configure the server.
      </Card>
    </CardGroup>

    <Info>
      **Quick Setup:** Use the one-click installation via Antigravity's MCP Server Store for the fastest setup experience.

      **Automated Setup:** Or use our setup script: `curl -fsSL https://api.wistx.ai/v1/setup/script | bash -s -- YOUR_API_KEY antigravity --remote`

      **Manual Setup:** Prefer to configure manually? Follow the steps below.
    </Info>

    <Steps>
      <Step title="Open MCP Configuration">
        Open Antigravity IDE and navigate to the **"mcp\_config.json"** tab.
      </Step>

      <Step title="Add WISTX Configuration">
        <CodeGroup>
          ```json Remote Server (Recommended) theme={null}
          {
            "mcpServers": {
              "wistx": {
                "serverUrl": "https://api.wistx.ai/v1/mcp/request",
                "headers": {
                  "Authorization": "Bearer YOUR_API_KEY"
                }
              }
            }
          }
          ```

          ```json Local Server theme={null}
          {
            "mcpServers": {
              "wistx": {
                "command": "pipx",
                "args": ["run", "--no-cache", "wistx-mcp"],
                "env": {
                  "WISTX_API_KEY": "YOUR_API_KEY"
                }
              }
            }
          }
          ```
        </CodeGroup>
      </Step>
    </Steps>

    <Note>
      **Antigravity Features:**

      * **Agent-First Architecture:** AI agents operate with greater autonomy
      * **Multi-Model Support:** Gemini 3 Pro, Claude Sonnet 4.5, GPT-OSS
      * **MCP Server Store:** Browse and install servers with one click
      * **Direct System Access:** Agents can write, run, and test applications

      For more information, visit [antigravity.google](https://antigravity.google/).
    </Note>
  </Tab>

  <Tab title="Gemini CLI">
    <Info>
      **Quick Setup:** Use our automated setup script: `curl -fsSL https://api.wistx.ai/v1/setup/script | bash -s -- YOUR_API_KEY gemini-cli --remote`
    </Info>

    <Steps>
      <Step title="Install Gemini CLI">
        Install Gemini CLI following Google's official installation instructions:

        ```bash theme={null}
        # Install via npm (recommended)
        npm install -g @google/gemini-cli

        # Or via other package managers
        # See: https://github.com/google-gemini/gemini-cli
        ```

        <Info>
          For detailed installation instructions, see the [Gemini CLI GitHub repository](https://github.com/google-gemini/gemini-cli) or [official documentation](https://geminicli.com/docs/).
        </Info>
      </Step>

      <Step title="Configure MCP Servers">
        Gemini CLI supports MCP servers through its configuration file. Configure WISTX as an MCP server:

        **Configuration file location:**

        * **macOS/Linux**: `~/.config/gemini-cli/config.json` or `~/.gemini-cli/config.json`
        * **Windows**: `%APPDATA%\gemini-cli\config.json`

        **Add WISTX MCP Server:**

        <CodeGroup>
          ```json Remote Server (Recommended) theme={null}
          {
            "mcpServers": {
              "wistx": {
                "url": "https://api.wistx.ai/v1/mcp/request",
                "headers": {
                  "Authorization": "Bearer YOUR_API_KEY"
                }
              }
            }
          }
          ```

          ```json Local Server theme={null}
          {
            "mcpServers": {
              "wistx": {
                "command": "pipx",
                "args": ["run", "--no-cache", "wistx-mcp"],
                "env": {
                  "WISTX_API_KEY": "YOUR_API_KEY"
                }
              }
            }
          }
          ```
        </CodeGroup>
      </Step>

      <Step title="Use WISTX with Gemini CLI">
        Once configured, you can use WISTX tools through Gemini CLI commands:

        ```bash theme={null}
        # Example: Ask about compliance requirements
        gemini "What compliance requirements do I need for a PCI-DSS compliant RDS instance?"

        # Example: Calculate infrastructure costs
        gemini "Calculate the monthly cost for an EKS cluster with 3 m5.large nodes"
        ```

        Gemini CLI will automatically use WISTX MCP tools to provide accurate DevOps and infrastructure context.
      </Step>
    </Steps>

    <Note>
      **Reference Documentation:**

      * [Gemini CLI GitHub](https://github.com/google-gemini/gemini-cli) - Official repository
      * [Gemini CLI Documentation](https://geminicli.com/docs/) - Official docs
      * [MCP Servers Guide](https://geminicli.com/docs/mcp-servers/) - MCP server configuration guide
    </Note>
  </Tab>

  <Tab title="Factory">
    <Info>
      **Quick Setup:** Use our automated setup script: `curl -fsSL https://api.wistx.ai/v1/setup/script | bash -s -- YOUR_API_KEY factory --remote`
    </Info>

    <Steps>
      <Step title="Add WISTX via Factory CLI">
        Factory's droid supports MCP servers through its CLI:

        <CodeGroup>
          ```bash Remote Server (Recommended) theme={null}
          droid mcp add wistx https://api.wistx.ai/v1/mcp/request --type http --header "Authorization: Bearer YOUR_API_KEY"
          ```

          ```bash Local Server theme={null}
          droid mcp add wistx "pipx run --no-cache wistx-mcp" --env WISTX_API_KEY=YOUR_API_KEY
          ```
        </CodeGroup>
      </Step>

      <Note>
        Once configured, WISTX tools will be available in your droid sessions. Type `/mcp` within droid to manage servers.
      </Note>
    </Steps>
  </Tab>

  <Tab title="Amp">
    <Info>
      **Quick Setup:** Use our automated setup script: `curl -fsSL https://api.wistx.ai/v1/setup/script | bash -s -- YOUR_API_KEY amp --remote`
    </Info>

    <Steps>
      <Step title="Add WISTX via Amp CLI">
        Amp supports MCP servers through its CLI:

        ```bash theme={null}
        amp mcp add wistx --header "Authorization=Bearer YOUR_API_KEY" https://api.wistx.ai/v1/mcp/request
        ```
      </Step>
    </Steps>
  </Tab>

  <Tab title="Warp">
    <Info>
      **Quick Setup:** Use our automated setup script: `curl -fsSL https://api.wistx.ai/v1/setup/script | bash -s -- YOUR_API_KEY warp`
    </Info>

    <Steps>
      <Step title="Add WISTX Configuration">
        1. Navigate to **Settings → AI → Manage MCP servers**
        2. Click **+ Add**
        3. Add configuration:

        ```json theme={null}
        {
          "wistx": {
            "command": "pipx",
            "args": ["run", "--no-cache", "wistx-mcp"],
            "env": {
              "WISTX_API_KEY": "YOUR_API_KEY"
            },
            "working_directory": null,
            "start_on_launch": true
          }
        }
        ```
      </Step>
    </Steps>
  </Tab>

  <Tab title="GitHub Copilot Agent">
    <Info>
      **Quick Setup:** Use our automated setup script: `curl -fsSL https://api.wistx.ai/v1/setup/script | bash -s -- YOUR_API_KEY copilot-agent --remote`
    </Info>

    <Steps>
      <Step title="Add to Repository Settings">
        Add to: **Repository → Settings → Copilot → Coding agent → MCP configuration**
      </Step>

      <Step title="Add WISTX Configuration">
        <CodeGroup>
          ```json Remote Server (Recommended) theme={null}
          {
            "mcpServers": {
              "wistx": {
                "type": "http",
                "url": "https://api.wistx.ai/v1/mcp/request",
                "headers": {
                  "Authorization": "Bearer YOUR_API_KEY"
                }
              }
            }
          }
          ```

          ```json Local Server theme={null}
          {
            "mcpServers": {
              "wistx": {
                "type": "stdio",
                "command": "pipx",
                "args": ["run", "--no-cache", "wistx-mcp"],
                "env": {
                  "WISTX_API_KEY": "YOUR_API_KEY"
                }
              }
            }
          }
          ```
        </CodeGroup>
      </Step>
    </Steps>
  </Tab>

  <Tab title="GitHub Copilot CLI">
    <Info>
      **Quick Setup:** Use our automated setup script: `curl -fsSL https://api.wistx.ai/v1/setup/script | bash -s -- YOUR_API_KEY copilot-cli --remote`
    </Info>

    <Steps>
      <Step title="Open Configuration">
        Open `~/.copilot/mcp-config.json` and add:
      </Step>

      <Step title="Add WISTX Configuration">
        <CodeGroup>
          ```json Remote Server (Recommended) theme={null}
          {
            "mcpServers": {
              "wistx": {
                "type": "http",
                "url": "https://api.wistx.ai/v1/mcp/request",
                "headers": {
                  "Authorization": "Bearer YOUR_API_KEY"
                }
              }
            }
          }
          ```

          ```json Local Server theme={null}
          {
            "mcpServers": {
              "wistx": {
                "type": "local",
                "command": "pipx",
                "args": ["run", "--no-cache", "wistx-mcp"],
                "env": {
                  "WISTX_API_KEY": "YOUR_API_KEY"
                }
              }
            }
          }
          ```
        </CodeGroup>
      </Step>
    </Steps>
  </Tab>

  <Tab title="Amazon Q Developer CLI">
    <Info>
      **Quick Setup:** Use our automated setup script: `curl -fsSL https://api.wistx.ai/v1/setup/script | bash -s -- YOUR_API_KEY amazon-q`
    </Info>

    <Steps>
      <Step title="Add WISTX Configuration">
        ```json theme={null}
        {
          "mcpServers": {
            "wistx": {
              "command": "pipx",
              "args": ["run", "--no-cache", "wistx-mcp"],
              "env": {
                "WISTX_API_KEY": "YOUR_API_KEY"
              }
            }
          }
        }
        ```
      </Step>
    </Steps>
  </Tab>

  <Tab title="Opencode">
    <Info>
      **Quick Setup:** Use our automated setup script: `curl -fsSL https://api.wistx.ai/v1/setup/script | bash -s -- YOUR_API_KEY opencode --remote`
    </Info>

    <Steps>
      <Step title="Add WISTX Configuration">
        <CodeGroup>
          ```json Remote Server (Recommended) theme={null}
          {
            "mcp": {
              "wistx": {
                "type": "remote",
                "url": "https://api.wistx.ai/v1/mcp/request",
                "headers": {
                  "Authorization": "Bearer YOUR_API_KEY"
                },
                "enabled": true
              }
            }
          }
          ```

          ```json Local Server theme={null}
          {
            "mcp": {
              "wistx": {
                "type": "local",
                "command": ["pipx", "run", "--no-cache", "wistx-mcp"],
                "env": {
                  "WISTX_API_KEY": "YOUR_API_KEY"
                },
                "enabled": true
              }
            }
          }
          ```
        </CodeGroup>
      </Step>
    </Steps>
  </Tab>

  <Tab title="Crush">
    <Info>
      **Quick Setup:** Use our automated setup script: `curl -fsSL https://api.wistx.ai/v1/setup/script | bash -s -- YOUR_API_KEY crush --remote`
    </Info>

    <Steps>
      <Step title="Add WISTX Configuration">
        <CodeGroup>
          ```json Remote Server (Recommended) theme={null}
          {
            "$schema": "https://charm.land/crush.json",
            "mcp": {
              "wistx": {
                "type": "http",
                "url": "https://api.wistx.ai/v1/mcp/request",
                "headers": {
                  "Authorization": "Bearer YOUR_API_KEY"
                }
              }
            }
          }
          ```

          ```json Local Server theme={null}
          {
            "$schema": "https://charm.land/crush.json",
            "mcp": {
              "wistx": {
                "type": "stdio",
                "command": "pipx",
                "args": ["run", "--no-cache", "wistx-mcp"],
                "env": {
                  "WISTX_API_KEY": "YOUR_API_KEY"
                }
              }
            }
          }
          ```
        </CodeGroup>
      </Step>
    </Steps>
  </Tab>

  <Tab title="Augment Code">
    <Info>
      **Quick Setup:** Use our automated setup script: `curl -fsSL https://api.wistx.ai/v1/setup/script | bash -s -- YOUR_API_KEY augment`
    </Info>

    <Steps>
      <Step title="Via UI">
        1. Hamburger menu → Settings → Tools
        2. Click **+ Add MCP**
        3. Enter command: `pipx run --no-cache wistx-mcp`
        4. Name: `WISTX`
      </Step>

      <Step title="Manual Configuration">
        ```json theme={null}
        "augment.advanced": {
          "mcpServers": [
            {
              "name": "wistx",
              "command": "pipx",
              "args": ["run", "--no-cache", "wistx-mcp"],
              "env": {
                "WISTX_API_KEY": "YOUR_API_KEY"
              }
            }
          ]
        }
        ```
      </Step>
    </Steps>
  </Tab>

  <Tab title="Trae">
    <Info>
      **Quick Setup:** Use our automated setup script: `curl -fsSL https://api.wistx.ai/v1/setup/script | bash -s -- YOUR_API_KEY trae --remote`
    </Info>

    <Steps>
      <Step title="Add WISTX Configuration">
        <CodeGroup>
          ```json Remote Server (Recommended) theme={null}
          {
            "mcpServers": {
              "wistx": {
                "url": "https://api.wistx.ai/v1/mcp/request",
                "headers": {
                  "Authorization": "Bearer YOUR_API_KEY"
                }
              }
            }
          }
          ```

          ```json Local Server theme={null}
          {
            "mcpServers": {
              "wistx": {
                "command": "pipx",
                "args": ["run", "--no-cache", "wistx-mcp"],
                "env": {
                  "WISTX_API_KEY": "YOUR_API_KEY"
                }
              }
            }
          }
          ```
        </CodeGroup>
      </Step>
    </Steps>
  </Tab>

  <Tab title="Zed">
    <Info>
      **Quick Setup:** Use our automated setup script: `curl -fsSL https://api.wistx.ai/v1/setup/script | bash -s -- YOUR_API_KEY zed`
    </Info>

    <Steps>
      <Step title="Add WISTX Configuration">
        Configure WISTX MCP server in Zed's settings. Check Zed's documentation for the exact configuration file location.
      </Step>
    </Steps>
  </Tab>

  <Tab title="JetBrains IDEs">
    <Info>
      **Quick Setup:** Use our automated setup script: `curl -fsSL https://api.wistx.ai/v1/setup/script | bash -s -- YOUR_API_KEY jetbrains`
    </Info>

    <Steps>
      <Step title="Add WISTX Configuration">
        JetBrains IDEs support MCP servers through plugins. Check the specific IDE's MCP plugin documentation for configuration instructions.
      </Step>
    </Steps>
  </Tab>

  <Tab title="Roo Code">
    <Info>
      **Quick Setup:** Use our automated setup script: `curl -fsSL https://api.wistx.ai/v1/setup/script | bash -s -- YOUR_API_KEY roo-code --remote`
    </Info>

    <Steps>
      <Step title="Add WISTX Configuration">
        Configure WISTX MCP server in Roo Code's settings. Check Roo Code's documentation for the exact configuration format.
      </Step>
    </Steps>
  </Tab>

  <Tab title="Kilo Code">
    <Info>
      **Quick Setup:** Use our automated setup script: `curl -fsSL https://api.wistx.ai/v1/setup/script | bash -s -- YOUR_API_KEY kilo-code --remote`
    </Info>

    <Steps>
      <Step title="Add WISTX Configuration">
        Configure WISTX MCP server in Kilo Code's settings. Check Kilo Code's documentation for the exact configuration format.
      </Step>
    </Steps>
  </Tab>

  <Tab title="Qodo Gen">
    <Info>
      **Quick Setup:** Use our automated setup script: `curl -fsSL https://api.wistx.ai/v1/setup/script | bash -s -- YOUR_API_KEY qodo-gen --remote`
    </Info>

    <Steps>
      <Step title="Add WISTX Configuration">
        Configure WISTX MCP server in Qodo Gen's settings. Check Qodo Gen's documentation for the exact configuration format.
      </Step>
    </Steps>
  </Tab>

  <Tab title="Qwen Coder">
    <Info>
      **Quick Setup:** Use our automated setup script: `curl -fsSL https://api.wistx.ai/v1/setup/script | bash -s -- YOUR_API_KEY qwen-coder --remote`
    </Info>

    <Steps>
      <Step title="Add WISTX Configuration">
        Configure WISTX MCP server in Qwen Coder's settings. Check Qwen Coder's documentation for the exact configuration format.
      </Step>
    </Steps>
  </Tab>

  <Tab title="Visual Studio">
    <Info>
      **Quick Setup:** Use our automated setup script: `curl -fsSL https://api.wistx.ai/v1/setup/script | bash -s -- YOUR_API_KEY visual-studio --remote`
    </Info>

    <Steps>
      <Step title="Add WISTX Configuration">
        Configure WISTX MCP server in Visual Studio's settings. Check Visual Studio's MCP extension documentation for configuration instructions.
      </Step>
    </Steps>
  </Tab>

  <Tab title="LM Studio">
    <Info>
      **Quick Setup:** Use our automated setup script: `curl -fsSL https://api.wistx.ai/v1/setup/script | bash -s -- YOUR_API_KEY lm-studio`
    </Info>

    <Steps>
      <Step title="Add WISTX Configuration">
        Configure WISTX MCP server in LM Studio's settings. Check LM Studio's documentation for MCP server configuration.
      </Step>
    </Steps>
  </Tab>

  <Tab title="Bolt AI">
    <Info>
      **Quick Setup:** Use our automated setup script: `curl -fsSL https://api.wistx.ai/v1/setup/script | bash -s -- YOUR_API_KEY bolt-ai`
    </Info>

    <Steps>
      <Step title="Add WISTX Configuration">
        Configure WISTX MCP server in Bolt AI's settings. Check Bolt AI's documentation for MCP server configuration.
      </Step>
    </Steps>
  </Tab>

  <Tab title="Perplexity">
    <Info>
      **Quick Setup:** Use our automated setup script: `curl -fsSL https://api.wistx.ai/v1/setup/script | bash -s -- YOUR_API_KEY perplexity`
    </Info>

    <Steps>
      <Step title="Add WISTX Configuration">
        Configure WISTX MCP server in Perplexity's settings. Check Perplexity's documentation for MCP server configuration.
      </Step>
    </Steps>
  </Tab>
</Tabs>

## Automated Setup Script

Don't want to configure manually? Use our automated setup script.

### Remote Setup (Recommended)

```bash theme={null}
curl -fsSL https://api.wistx.ai/v1/setup/script | bash -s -- YOUR_API_KEY IDE_NAME --remote
```

**Supported IDEs:** `cursor`, `vscode`, `windsurf`, `cline`, `antigravity`, `trae`, `continue`, `claude-desktop`, `claude-code`, `codex`, `gemini-cli`, `factory`, `amp`, `warp`, `copilot-agent`, `copilot-cli`, `opencode`, `crush`, `amazon-q`, `augment`, `jetbrains`, `zed`, `roo-code`, `kilo-code`, `qodo-gen`, `qwen-coder`, `visual-studio`, `lm-studio`, `bolt-ai`, `perplexity`

### Local Setup

```bash theme={null}
curl -fsSL https://api.wistx.ai/v1/setup/script | bash -s -- YOUR_API_KEY IDE_NAME
```

**Supported IDEs:** All of the above plus any IDE that supports MCP stdio protocol.

## Verification

After installation and configuration, verify everything is working:

1. **Restart your coding agent** completely
2. **Check tool availability** - Ask your AI assistant: "What compliance requirements do I need for a PCI-DSS compliant RDS instance?"
3. **Verify API connection** - The AI assistant should automatically use WISTX tools to answer

<Warning>
  If tools don't appear after restart, check:

  * Your API key is correct and active
  * Configuration file syntax is valid JSON
  * For local server: Python 3.11+ is installed and pipx/uvx is working correctly
  * For remote server: Internet connection is available

  See our [Troubleshooting Guide](/guides/troubleshooting) for more help.
</Warning>

## Next Steps

* [Tools & Features](/integrations/tools-features) - Explore all available MCP tools
* [API Reference](/api-reference/introduction) - Use the REST API for programmatic access
* [Examples](/guides/examples) - See real-world use cases
* [Troubleshooting](/guides/troubleshooting) - Common issues and solutions

***

<Warning>
  **Need Help?** Join our [Discord community](https://discord.gg/ZVGK5Fv3wT) for support, visit our [GitHub repository](https://github.com/WISTXHQ/wistx-model) to report issues, or reach out through [wistx.ai/api-key](https://wistx.ai/api-key) for support and updates.
</Warning>


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.