# Getting Started

## Imagine. Build. Ship.

If you can imagine it, OBTO can build it. Sign up, connect your AI client, and deploy your first application through conversation.

## Sign Up

Go to [obto.co](/content/site-root.html) and click **Sign in** in the top-right corner. Authenticate with your Google account. Your OBTO instance is created automatically — no setup required.

## Copy Your MCP Endpoint

After signing in, you'll see your personal **MCP server URL** on the landing page. This URL is unique to your account and connects your AI client to your OBTO instance.

**Copy this URL.** You'll need it in Step 4.

> 💡 Your MCP endpoint is the bridge between your AI chat interface and the OBTO deployment engine. Every app you build through conversation gets deployed through this connection.

## Get the OBTO Skill

The **OBTO Skill(obto-developer)** is a file called `SKILL.md` that teaches your AI model how to build and deploy applications on OBTO. Download it from GitHub:

👉 [github.com/obto-inc/platform](https://github.com/obto-inc/platform/blob/main/SKILL.md)

| Client | Where to put SKILL.md |
| --- | --- |
| Claude Desktop | Add to project knowledge or attach as a file |
| Claude Web | Upload as a file attachment in your conversation |
| Cursor | Place in workspace root or `.cursor/skills/` |
| VS Code | Place in workspace root directory |
| AntiGravity | Place in `.agent/skills/` directory |

## Connect to Your AI Client

Select your client. Replace `YOUR_MCP_ENDPOINT` with the URL from Step 2.

### Claude.ai — Web Interface

The simplest option. Native remote MCP via **Connectors**.

1. **Settings → Connectors** ( [claude.ai/settings/connectors](https://claude.ai/settings/connectors))
2. Click **"Add custom connector"**
3. Paste your OBTO MCP endpoint URL
4. Click **"Add"** — transport auto-detected
5. In chat: **"+" → "Connectors"** to toggle on

### Claude Desktop App

Uses **Connectors UI** for remote servers — _not_ the config file.

### Recommended: Connectors UI

1. **"+" at bottom of chat → "Connectors" → "Manage Connectors"**
2. Add custom connector with your endpoint URL
3. Syncs across Claude.ai, Desktop, and Mobile

### Alternative: Config file with mcp-remote

Requires Node.js. Bridges stdio to HTTP.

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

```json
{
  "mcpServers": {
    "obto": {
      "command": "npx",
      "args": [
        "mcp-remote",
        "https://<my obto.co host>.obto.co/ms/mcp"
      ]
    }
  }
}
```

Common Pitfall

The config file does **not** support a direct `"url"` field. `{"url":"https://..."}` silently fails. Use Connectors UI or `mcp-remote`. **Fully quit & restart** after changes.

### Claude Code (CLI)

Native HTTP support — simplest CLI setup.

### One-command setup

```bash
claude mcp add --transport http obto-mcp https://<my obto.co host>.obto.co/ms/mcp
```

### With scope

```bash
# User scope (all projects)
claude mcp add --transport http --scope user obto-mcp https://<my obto.co host>.obto.co/ms/mcp

# Project scope (team via .mcp.json)
claude mcp add --transport http --scope project obto-mcp https://<my obto.co host>.obto.co/ms/mcp
```

Flag Order

All flags must come **before** the server name. `claude mcp add obto-mcp --transport http` fails.

### Config file

`~/.claude.json` (user) or `.mcp.json` (project root):

```json
{
  "mcpServers": {
    "obto-mcp": {
      "type": "http",
      "url": "https://<my obto.co host>.obto.co/ms/mcp"
    }
  }
}
```

**Useful:** `claude mcp list` · `claude mcp get obto-mcp` · `/mcp` · `claude --mcp-debug`

### VS Code with GitHub Copilot (Agent Mode)

Built-in since **VS Code 1.99+**. Requires Copilot extension + `chat.agent.enabled: true`.

### Option A — Workspace (recommended)

Create `.vscode/mcp.json`:

```json
{
  "servers": {
    "obto": {
      "type": "http",
      "url": "https://<my obto.co host>.obto.co/ms/mcp"
    }
  }
}
```

### Option B — User settings.json

```json
{
  "mcp": {
    "servers": {
      "obto": {
        "type": "http",
        "url": "https://<my obto.co host>.obto.co/ms/mcp"
      }
    }
  }
}
```

Critical

VS Code uses `"servers"` — **not** `"mcpServers"`. #1 config error. Verify: Copilot Chat → Agent mode → tools icon.

### VS Code with Continue.dev

YAML config. Tools only in **Agent mode**.

macOS/Linux: `~/.continue/config.yaml`  
Windows: `%USERPROFILE%\.continue\config.yaml`

```yaml
mcpServers:
  - name: OBTO
    type: streamable-http
    url: https://<my obto.co host>.obto.co/ms/mcp
```

Tip

If `streamable-http` fails, try `sse`. Continue uses kebab-case: `sse`, `stdio`, `streamable-http`.

### VS Code with Cline

**Access:** MCP Servers icon → Configure → Configure MCP Servers

macOS: `~/Library/Application Support/Code/User/globalStorage/saoudrizwan.claude-dev/settings/cline_mcp_settings.json`  
Windows: `%APPDATA%\Code\User\globalStorage\saoudrizwan.claude-dev\settings\cline_mcp_settings.json`

```json
{
  "mcpServers": {
    "obto": {
      "url": "https://<my obto.co host>.obto.co/ms/mcp",
      "type": "sse",
      "disabled": false,
      "timeout": 60
    }
  }
}
```

Tip

Start with `"sse"` — more reliable than `"streamableHttp"` (Cline uses **camelCase**). Green dot = connected.

### VS Code with Roo Code

**Access:** 🔌 MCP icon → Edit Global/Project MCP

macOS: `~/Library/Application Support/Code/User/globalStorage/rooveterinaryinc.roo-cline/settings/mcp_settings.json`  
Windows: `%APPDATA%\Code\User\globalStorage\rooveteritaryinc.roo-cline\settings\mcp_settings.json`  
Project: `roo/mcp.json` (overrides global)

```json
{
  "mcpServers": {
    "obto": {
      "type": "sse",
      "url": "https://<my obto.co host>.obto.co/ms/mcp",
      "disabled": false,
      "timeout": 60
    }
  }
}
```

Required

`type` is **required** — omitting it errors. Kebab-case: `"sse"`, `"streamable-http"`, `"stdio"`.

### Cursor IDE

Native remote MCP. Simplest IDE config.

Project: `cursor/mcp.json`   
Global: `~/.cursor/mcp.json`  
UIPreferences → Cursor Settings → Tools & MCP

```json
{
  "mcpServers": {
    "obto": {
      "url": "https://<my obto.co host>.obto.co/ms/mcp"
    }
  }
}
```

Auto-detects transport. No `"type"` needed. Green indicator in Settings → Tools & MCP.

Tool Limit

Cursor caps at ~40 tools across all servers. Toggle off/on or restart if tools don't appear.

### Windsurf IDE (Codeium)

Own config path, **different key name** for URL.

macOS/Linux: `~/.codeium/windsurf/mcp_config.json`  
Windows: `%USERPROFILE%\.codeium\windsurf\mcp_config.json`  
UISettings → Cascade → Manage MCPs

```json
{
  "mcpServers": {
    "obto": {
      "serverUrl": "https://<my obto.co host>.obto.co/ms/mcp"
    }
  }
}
```

Windsurf Key

`"serverUrl"` not `"url"`. Most common Windsurf MCP error.

### JetBrains IDEs

All IntelliJ-based IDEs since **2025.1**.

1. **Settings → Tools → AI Assistant → Model Context Protocol (MCP)**
2. **\+ Add → HTTP** type
3. Paste config, **OK → Apply**

```json
{
  "mcpServers": {
    "obto": {
      "url": "https://<my obto.co host>.obto.co/ms/mcp"
    }
  }
}
```

Tip

**"Import from Claude"** button imports existing Claude Desktop configs.

### Zed Editor

Stdio only — needs `mcp-remote` (Node.js required).

```json
{
  "context_servers": {
    "obto": {
      "source": "custom",
      "command": "npx",
      "args": ["-y", "mcp-remote", "https://<my obto.co host>.obto.co/ms/mcp"],
      "env": {}
    }
  }
}
```

Zed Quirk

`"source": "custom"` is required or Zed silently skips the server.

### Amazon Q Developer

Native HTTP. Config: `~/.aws/amazonq/default.json` or `.amazonq/default.json`:

```json
{
  "mcpServers": {
    "obto": {
      "type": "http",
      "url": "https://<my obto.co host>.obto.co/ms/mcp"
    }
  }
}
```

### Universal Fallback (Any stdio-only Client)

`mcp-remote` bridges stdio to HTTP. Wrap in whatever root key your client expects:

```json
{
  "command": "npx",
  "args": ["-y", "mcp-remote", "https://<my obto.co host>.obto.co/ms/mcp"]
}
```

## Build

You're connected. Select the obto-developer skill and then just describe what you want:

"Build me a landing page for my coffee shop called Daily Grind with a hero section, menu with prices, photo gallery, and a contact form that saves submissions."

The AI reads the OBTO Skill, writes the backend logic, creates the frontend, deploys everything in the correct order, and your app goes live at `yourapp.obto.co`.

## Ready to build?

Sign in and get your MCP endpoint in under a minute.

[Get Started →](/content/site-root.html) [Documentation](https://docs.obto.co/) [GitHub](https://github.com/obto-inc/platform) [Contact](mailto:dev@obto.co)