# AI assistants (MCP) (/docs/developers/mcp-server)

Skavelo has an MCP server, so an AI assistant can work with your workspace for you. Ask it to write a walkthrough, draft a playbook from a support macro, add a lookup skill from your API docs, or go through **Needs attention** and suggest fixes.

The server's address is:

```
https://api.skavelo.com/mcp
```

You'll also find it on the **AI assistants** page in the dashboard sidebar, with these steps for each assistant.

## Connect an assistant [#connect-an-assistant]

Menu names can differ a little between versions of each app. In every case, the last step is the same: Skavelo opens in your browser, you sign in if asked, choose the workspace and what the assistant can do, and click **Connect**.

### Claude [#claude]

On the web and in the desktop app:

1. Open **Settings**, then **Connectors**.
2. Click **Add custom connector**. Name it Skavelo and paste the address above.
3. Click **Add**, then **Connect** next to Skavelo.
4. Approve the connection in Skavelo.
5. In a chat, turn Skavelo on from the tools menu and ask, for example, "List my Skavelo agents."

On Claude Team and Enterprise plans, an owner may need to add the connector for your organization first.

### ChatGPT [#chatgpt]

1. Open **Settings**, then **Apps and connectors**.
2. If there's no option to add your own, open **Advanced settings** and turn on **Developer mode**.
3. Create a connector. Name it Skavelo, choose **OAuth** for authentication, and paste the address above.
4. Approve the connection in Skavelo.
5. In a new chat, add Skavelo from the tools menu and ask, for example, "List my Skavelo agents."

Which ChatGPT plans can add connectors, and whether a connector can make changes, is set by OpenAI and can change. If these steps don't match what you see, check OpenAI's help for custom connectors.

### Claude Code [#claude-code]

```bash
claude mcp add --transport http skavelo https://api.skavelo.com/mcp
```

Start Claude Code, run `/mcp`, choose **skavelo**, then **Authenticate**, and approve the connection in Skavelo. Add `-s user` to the command to use Skavelo in every project.

### Cursor [#cursor]

[Add Skavelo to Cursor](https://cursor.com/install-mcp?name=skavelo&config=eyJ1cmwiOiJodHRwczovL2FwaS5za2F2ZWxvLmNvbS9tY3AifQ%3D%3D): Cursor opens and asks to install it; click **Install**.

Or add it yourself: open **Cursor Settings**, then **MCP**, and add a server, or add this to `~/.cursor/mcp.json`:

```json
{
  "mcpServers": {
    "skavelo": { "url": "https://api.skavelo.com/mcp" }
  }
}
```

Then, in Cursor's MCP settings, click **Needs login** next to skavelo and approve the connection in Skavelo.

### VS Code [#vs-code]

Run **MCP: Add Server** from the command palette, choose **HTTP** and paste the address, or add this to `.vscode/mcp.json`:

```json
{
  "servers": {
    "skavelo": { "type": "http", "url": "https://api.skavelo.com/mcp" }
  }
}
```

Start the server when VS Code asks, allow it to sign in, and approve the connection in Skavelo. Then use Skavelo from Copilot Chat in **Agent** mode.

To add Skavelo's skills as well, run **Chat: Install Plugin from Source** and enter `https://github.com/Skavelo/ai-assistants`. It adds the skills and the connection together.

### Gemini CLI [#gemini-cli]

```bash
gemini extensions install https://github.com/Skavelo/ai-assistants
```

The extension adds Skavelo's skills and the connection. Start Gemini CLI, run `/mcp auth skavelo` and approve the connection in Skavelo.

### Antigravity [#antigravity]

In the Antigravity app or IDE, add this to `~/.gemini/config/mcp_config.json`:

```json
{
  "mcpServers": {
    "skavelo": { "serverUrl": "https://api.skavelo.com/mcp" }
  }
}
```

Open **Settings**, then **Customizations**, click **Refresh** under Installed MCP Servers, then **Authenticate** next to skavelo. Approve the connection in Skavelo; Antigravity then shows a code to paste back into it.

In the Antigravity CLI, `agy plugin install https://github.com/Skavelo/ai-assistants` adds Skavelo's skills and the connection together. Sign in from `/mcp`.

### Codex [#codex]

The Codex CLI, the Codex IDE extension and the ChatGPT desktop app share one setup. In your terminal:

```bash
codex mcp add skavelo --url https://api.skavelo.com/mcp
codex mcp login skavelo
```

Approve the connection in Skavelo. In the ChatGPT desktop app, you can instead open **Settings**, then **MCP servers**, choose **Add server**, pick **Streamable HTTP** and paste the address. Save, **Restart**, then **Authenticate**.

### Windsurf [#windsurf]

Windsurf is now Devin Desktop. In Cascade's MCP settings, choose **Open MCP config file** and add Skavelo under `mcpServers`:

```json
{
  "mcpServers": {
    "skavelo": { "serverUrl": "https://api.skavelo.com/mcp" }
  }
}
```

Save the file. Windsurf starts the sign-in for Skavelo by itself; approve the connection in Skavelo.

### GitHub Copilot CLI [#github-copilot-cli]

```bash
copilot plugin install Skavelo/ai-assistants
```

The plugin adds Skavelo's skills and the connection. To connect without the skills, run `copilot mcp add --transport http skavelo https://api.skavelo.com/mcp` instead. Start Copilot CLI and sign in when it asks; to start the sign-in yourself, run `/mcp auth skavelo`.

### Other assistants [#other-assistants]

Any assistant that supports remote MCP servers with OAuth sign-in works, such as other editors and agents: add a remote (HTTP) server with the address above and start the sign-in from the assistant.

## Skills for your assistant [#skills-for-your-assistant]

Skills are ready-made instructions that teach an assistant the common Skavelo jobs, step by step. In Claude Code, one plugin adds the skills and the connection to Skavelo:

```
/plugin marketplace add skavelo/ai-assistants
/plugin install skavelo@skavelo
```

| Skill | What it does |
| --- | --- |
| `skavelo-needs-attention` | Works through answers users rated not helpful, questions Skavelo couldn't answer and reported problems, and fixes each one |
| `skavelo-skills-from-openapi` | Turns your OpenAPI spec into lookups and actions, created switched off |
| `skavelo-walkthroughs` | Writes and improves walkthroughs from the product map, and offers them at the right moment |
| `skavelo-playbooks` | Turns support macros and runbooks into troubleshooting playbooks, set to testing first |
| `skavelo-agent-review` | Reviews an agent's setup and suggests what to improve next |

In Cursor, the same plugin adds the skills and the connection: open **Customize**, choose **From GitHub Repository**, enter `https://github.com/Skavelo/ai-assistants`, then install **skavelo**.

In VS Code, Gemini CLI, the Antigravity CLI and GitHub Copilot CLI, the same repository installs the skills too; see their sections above. Other assistants that support skills in the `SKILL.md` format can use the same files from the [skavelo/ai-assistants repository](https://github.com/skavelo/ai-assistants).

## Things to ask [#things-to-ask]

- "Write a walkthrough for sending an invoice, using what's in the product map."
- "Go through this week's Needs attention and suggest a note for each one."
- "Create lookup skills from our API spec at https://… and leave them switched off."
- "Turn our refund macro into a playbook, set to testing."
- "Hide the widget on the checkout pages."

## Approving a connection [#approving-a-connection]

When the assistant connects, Skavelo shows which assistant is asking and where it will send you back. If you're signed out, you sign in first. Choose:

- **Workspace**, if you belong to more than one.
- **Read and change**, or **Read only**.

Only approve a connection you started yourself. The assistant then works as you, with your role: members can't change skills, playbooks or walkthrough offers through an assistant, the same as in the dashboard.

## What it can do [#what-it-can-do]

| Area | Read | Change |
| --- | --- | --- |
| Agents | List agents and see their setup | Switch an agent on or off on your site |
| Widget | Appearance, targeting and handoff, in the agent's setup | Change the look, targeting and handoff |
| Product map | Screens and walkthroughs | Create and edit walkthroughs |
| Walkthrough offers | List offers | Create and edit offers |
| Playbooks | List playbooks | Create, edit, and set to off, testing or on |
| Skills | List skills | Create and edit skills, and preview skills from an OpenAPI spec |
| Suggestions | Draft suggestions for a page | Replace the list |
| Notes | List notes | Add and edit notes |
| Websites and files | Websites, files and recent learning runs | Add and edit websites, read a failed file again, start learning |
| Conversations | List, filter and read conversations | |
| Needs attention | Answers to look at | Mark them handled |

A few limits keep your users safe:

- **Nothing can be deleted** through an assistant.
- **Some settings stay in the dashboard:** test accounts for apps behind a login, the email address handed-off conversations go to, uploading files and the widget icon.
- **Skills it creates start switched off.** It can switch on a lookup, which only reads data. Actions change your users' data, so someone switches them on in the dashboard after checking them.
- **New playbooks start off.** Set one to testing to try it in **Try it** before your users see it.
- Everything goes through the same checks and plan limits as the dashboard.

Conversations and **Needs attention** include the names and emails your app passes to Skavelo, so an assistant with access can read them. Their questions were written by your users. Good assistants treat them as text to review, but read what yours proposes before you let it make changes.

## Disconnect an assistant [#disconnect-an-assistant]

The **AI assistants** page in the dashboard lists every connected assistant, who connected it and when it was last used. Click the bin to disconnect one. Members can disconnect their own; owners and admins can disconnect anyone's. An assistant also stops working when the person who connected it leaves the workspace.

## Scripts and CI [#scripts-and-ci]

For a script with no person to approve it, send an [API key](/docs/developers/api-keys-and-deploys) instead: `Authorization: Bearer sk_live_...`. An API key can read and change everything the tools cover, like an admin.