---
title: "Connect your tool"
description: "Ready-to-paste Edge configs for Cursor, Windsurf, Claude Desktop, Grok Bot, Continue, Aider, LangChain, LlamaIndex, CrewAI and the Vercel AI SDK."
url: "https://edge.network/docs/agent/connect"
section: "Agent tooling"
---

# Connect your tool

Ready-to-paste configs for every popular agent tool. Add your access code, or skip the code entirely and let the MCP server sign itself up.

Replace `ea_live_YOUR_CODE_HERE` in the configs below with your access code. For how the server works (transports, auth, explore tier), see [MCP server](/docs/agent/mcp); for what your agent can do once connected, see the [tool reference](/docs/agent/mcp-tools).

> [!TIP]
> **No account yet? You don't need one.** Omit `EDGE_AGENT_CODE` and the MCP server creates a free explore-tier Edge account on first run. It needs no card and no human in the loop. It can deploy free-tier resources (static sites, DNS zones, Shield widgets, storage buckets) immediately. Set `EDGE_OPERATOR_EMAIL` to receive the claim link that enables paid resources. Agents talking straight to the API can [sign themselves up](/docs/agent/self-signup) the same way.
>
> ```json
> {
>   "mcpServers": {
>     "edge": { "command": "npx", "args": ["-y", "@edge-network/mcp"] }
>   }
> }
> ```

## Getting an access code

Create one in the Edge console under [Account → Agent Access](/console/agent-access). You choose which products it can touch, its permissions and an optional monthly budget cap (soft or hard). The panel generates all of the configs below with your real code injected.

## Pick your tool

### Cursor

`.cursor/mcp.json` (project) or `~/.cursor/mcp.json` (global):

```json
{
  "mcpServers": {
    "edge": {
      "command": "npx",
      "args": ["-y", "@edge-network/mcp"],
      "env": { "EDGE_AGENT_CODE": "ea_live_YOUR_CODE_HERE" }
    }
  }
}
```

**Try it:** "Deploy this folder as a static site on Edge and give me the URL."

### Windsurf

`~/.codeium/windsurf/mcp_config.json`:

```json
{
  "mcpServers": {
    "edge": {
      "command": "npx",
      "args": ["-y", "@edge-network/mcp"],
      "env": { "EDGE_AGENT_CODE": "ea_live_YOUR_CODE_HERE" }
    }
  }
}
```

**Try it:** "Deploy this project as a static site on Edge."

### Claude Desktop

`claude_desktop_config.json` (**Settings → Developer → Edit Config**):

```json
{
  "mcpServers": {
    "edge": {
      "command": "npx",
      "args": ["-y", "@edge-network/mcp"],
      "env": { "EDGE_AGENT_CODE": "ea_live_YOUR_CODE_HERE" }
    }
  }
}
```

**Try it:** "Create a DNS zone for example.com on Edge and list its nameservers."

### Grok Bot

**Settings → Plugins → Add custom MCP server**. Grok Bot runs in the cloud, so it connects to the remote MCP endpoint (nothing to install):

```text
Name:     Edge
URL:      https://edge.network/mcp
Headers:  Authorization: Bearer ea_live_YOUR_CODE_HERE
```

**Try it:** "Deploy this folder as a static site on Edge and give me the URL."

### Continue

`.continue/config.yaml`:

```yaml
mcpServers:
  - name: Edge Network
    command: npx
    args: ["-y", "@edge-network/mcp"]
    env:
      EDGE_AGENT_CODE: ea_live_YOUR_CODE_HERE
```

**Try it:** "Add bot protection to my contact form using Edge Shield."

### Aider

Terminal. Aider has no MCP support, so it reads Edge instructions from a conventions file (see [below](#aider-conventions-file)):

```bash
export EDGE_AGENT_CODE="ea_live_YOUR_CODE_HERE"
curl -s "https://edge.network/agent/prompt?format=text" -o CONVENTIONS.md
aider --read CONVENTIONS.md
```

**Try it:** "Using the Edge API described in CONVENTIONS.md (auth via $EDGE_AGENT_CODE), deploy ./dist as a static site."

### LangChain

```bash
pip install "edge-network-agent[langchain]"
```

```python
from edge_network_agent import EdgeAgentTools

edge = EdgeAgentTools(agent_code="ea_live_YOUR_CODE_HERE")
tools = edge.langchain_tools()
system_prompt = edge.starter_prompt()
```

**Try it:** `agent.invoke({"input": "Deploy my React build to portfolio.example.com"})`

### LlamaIndex

```bash
pip install "edge-network-agent[llamaindex]"
```

```python
from edge_network_agent import EdgeAgentTools
from llama_index.core.agent import ReActAgent

edge = EdgeAgentTools(agent_code="ea_live_YOUR_CODE_HERE")
agent = ReActAgent.from_tools(edge.llamaindex_tools(), llm=llm)
```

**Try it:** `agent.chat("Create a storage bucket called assets and upload ./images to it")`

### CrewAI

```bash
pip install "edge-network-agent[crewai]"
```

```python
from edge_network_agent import EdgeAgentTools
from crewai import Agent

edge = EdgeAgentTools(agent_code="ea_live_YOUR_CODE_HERE")

deployer = Agent(
    role="Infrastructure Engineer",
    goal="Deploy and monitor applications on Edge Network",
    tools=edge.crewai_tools(),
)
```

**Try it:** Task: "Deploy the marketing site and verify it responds with a 200"

### Vercel AI SDK

```bash
npm install @edge-network/ai-tools ai
```

```js
import { generateText } from 'ai'
import { createEdgeTools, fetchStarterPrompt } from '@edge-network/ai-tools'

const edgeTools = await createEdgeTools({ agentCode: 'ea_live_YOUR_CODE_HERE' })

const result = await generateText({
  model,
  system: await fetchStarterPrompt(),
  tools: edgeTools,
  prompt: 'Deploy the ./dist folder to my-site.example.com',
})
```

**Try it:** `prompt: 'Deploy the ./dist folder to my-site.example.com'`

### Remote MCP

For clients that support remote MCP servers. There is nothing to install:

```json
{
  "mcpServers": {
    "edge": {
      "url": "https://edge.network/mcp",
      "headers": { "Authorization": "Bearer ea_live_YOUR_CODE_HERE" }
    }
  }
}
```

Works with any MCP client that supports streamable-HTTP servers.

### Raw API

Use any HTTP client. The API is self-describing:

```bash
curl https://edge.network/agent \
  -H "Authorization: Bearer ea_live_YOUR_CODE_HERE"
```

The discovery response documents every endpoint. Add `X-Dry-Run: true` to any mutation to preview it with a cost estimate.

## Aider conventions file

Aider doesn't speak MCP, but it excels at following a conventions file. The Edge starter system prompt covers what Edge offers, how to authenticate, dry-run discipline, the `tell_user` convention and the claim flow. It is served as plain Markdown, so the conventions file is one curl away:

```bash
curl -s "https://edge.network/agent/prompt?format=text" -o CONVENTIONS.md
aider --read CONVENTIONS.md
```

Keep the access code out of the file: export it as `EDGE_AGENT_CODE` and tell Aider to use `$EDGE_AGENT_CODE` in its curl commands. The prompt is versioned, so re-run the curl occasionally to pick up improvements.

## What your agent gets

All integrations expose the same tool set, served live from the API (so they never go stale): deploy static sites and full VM-backed apps, manage projects (health, scale, teardown), storage buckets and uploads, DNS zones and records, Shield bot-protection widgets and Assist AI-answer sites. Discovery, cost-estimating dry runs and the account claim flow are included too.

## Next steps

- [Discovery endpoint](/docs/agent/discovery)
- [Deploy a static site](/docs/agent/deploy-static-site)
- [Self-signup](/docs/agent/self-signup)