---
title: MCPLambda MCP Server
description: Manage your MCPLambda deployments directly from your AI client using the MCPLambda MCP server.
---

The **MCPLambda MCP server** is a remote MCP server deployed at `api.mcplambda.io/mcp` that lets you manage your MCPLambda deployments directly from your AI client — Claude Desktop, Cursor, VSCode, or any MCP-compatible tool.

Instead of switching to the dashboard or CLI, you can ask your AI assistant to deploy servers, check status, view logs, manage secrets, and search the registry — all through natural language.

---

## How It Works

1. You connect your AI client to the MCPLambda MCP server.
2. The MCP server exposes tools for deployment management.
3. You ask your AI assistant to perform actions (e.g., "deploy the filesystem server" or "check the status of my deployment").
4. The AI assistant calls the appropriate MCP tool and reports back.

---

## Getting Started

### Step 1: Create a Service Account Token

The MCPLambda MCP server authenticates using a **service account token**. Create one from the MCPLambda dashboard:

1. Sign in to [mcplambda.io](https://mcplambda.io).
2. Go to **Settings > API Tokens**.
3. Click **Create Token**.
4. Give it a name (e.g., "MCP Server Access").
5. Copy the token — it starts with `mcpl_sat_` and is only shown once.

> **Security:** Store the token securely. The token prefix (first 12 characters) is safe to log or display, but the full token should be treated like a password.

### Step 2: Connect Your AI Client

Add the MCPLambda MCP server to your client configuration:

#### Claude Desktop

Add to your `claude_desktop_config.json`:

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

```json
{
  "mcpServers": {
    "mcplambda": {
      "url": "https://api.mcplambda.io/mcp",
      "headers": {
        "Authorization": "Bearer mcpl_sat_your_token_here"
      }
    }
  }
}
```

Restart Claude Desktop after saving.

#### Cursor

1. Open **Cursor Settings** > **General** > **MCP**.
2. Click **+ Add New MCP Server**.
3. **Name:** `mcplambda`
4. **Type:** `SSE`
5. **URL:** `https://api.mcplambda.io/mcp`
6. Add the Authorization header with your service account token.
7. Click **Save**.

#### VSCode (Cline, Roo Code, Continue)

1. Open the extension's MCP settings.
2. Add a new server with type **SSE/HTTP**.
3. **URL:** `https://api.mcplambda.io/mcp`
4. Add header: `Authorization: Bearer mcpl_sat_your_token_here`
5. Save and restart the extension.

### Step 3: Start Using It

Once connected, your AI assistant will have access to MCPLambda management tools. Just ask:

- "Deploy the MCP filesystem server"
- "List all my deployments"
- "Check the status of my-server"
- "Show me the logs for my-server"
- "Search the registry for GitHub servers"
- "Stop the my-server deployment"

---

## Available Tools

### Deployment Management

| Tool | Description |
|------|-------------|
| `list_deployments` | List all deployments in your active project. |
| `get_deployment` | Get details and status of a specific deployment. |
| `create_deployment` | Deploy a new MCP server (package, git, or image). |
| `delete_deployment` | Delete a deployment. |
| `start_deployment` | Start a stopped deployment. |
| `stop_deployment` | Stop a running deployment. |
| `get_deployment_logs` | Fetch recent logs for a deployment. |
| `get_deployment_api_key` | Retrieve the API key for a deployment (only for `auth_type: key`). |
| `rotate_deployment_api_key` | Rotate the API key for a deployment. |

### Project Management

| Tool | Description |
|------|-------------|
| `list_projects` | List all your projects. |
| `create_project` | Create a new project. |

### Secret Management

| Tool | Description |
|------|-------------|
| `list_secrets` | List project secrets (values are masked). |
| `create_secret` | Create a project secret. |

### Registry

| Tool | Description |
|------|-------------|
| `search_registry` | Search the MCPLambda MCP server registry. |
| `get_registry_server` | Get details of a specific registry server. |

---

## Example Conversations

### Deploying a Server

```text
You: "Deploy the MCP filesystem server for me."

AI: I'll search the registry for a filesystem server and deploy it.

  -> search_registry("filesystem")
  <- Found: @modelcontextprotocol/server-filesystem

  -> create_deployment(
       name: "filesystem-server",
       package_name: "npx://@modelcontextprotocol/server-filesystem",
       transport: "streamable-http",
       auth_type: "key",
       api_key_duration: 30 days
     )

Your filesystem server is being deployed. I'll check the status...

  -> get_deployment("filesystem-server")
  <- Status: running, URL: https://filesystem-server.mcplambda.io

Your server is live at https://filesystem-server.mcplambda.io/mcp.
The API key is mcpl_live_... (I've saved it to your config).
```

### Checking Status

```text
You: "How are my deployments doing?"

AI: Let me check all your deployments.

  -> list_deployments()
  <- 3 deployments found:
     - filesystem-server: running (small, 1 unit)
     - github-mcp: running (medium, 2 units)
     - test-server: stopped (small, 0 units)

You have 2 running deployments and 1 stopped. You're using 3 of your
compute units. Would you like me to start the stopped one or stop
one of the running ones?
```

### Managing Secrets

```text
You: "Create a secret called GITHUB_TOKEN with value ghp_xxx"

AI: I'll create that secret for you.

  -> create_secret(name: "GITHUB_TOKEN", value: "ghp_xxx")

Done! The secret GITHUB_TOKEN has been created in your project.
You can now reference it when deploying servers that need a GitHub token.
```

### Searching the Registry

```text
You: "What MCP servers are available for GitHub?"

AI: Let me search the registry.

  -> search_registry("github")
  <- Found 3 servers:
     - @modelcontextprotocol/server-github (npx)
     - mcp-server-github (uvx)
     - github-mcp-go (go)

Would you like me to deploy one of these?
```

---

## Security

- **Service account tokens** are scoped — request only the permissions you need (`deployments:write`, `secrets:write`).
- **Never share your token** — treat it like a password.
- **Rotate tokens** periodically from the dashboard.
- **Deployment API keys** (for `auth_type: key` deployments) are separate from service account tokens — they authenticate MCP clients to your deployed servers, not to the MCPLambda platform.

---

## FAQ

### Do I need the mcpl CLI to use the MCP server?

No. The MCP server is independent of the CLI. You can use it directly from your AI client with just a service account token. However, the CLI is useful for initial setup and scripting.

### Can I use the MCP server with multiple projects?

Yes. The `list_deployments` and `create_deployment` tools accept a project parameter. If not specified, your default project is used.

### What is the difference between the MCPLambda MCP server and my deployed MCP servers?

The **MCPLambda MCP server** (`api.mcplambda.io/mcp`) is a management tool — it lets you deploy and manage servers. Your **deployed MCP servers** (e.g., `my-server.mcplambda.io/mcp`) are the actual MCP servers that provide tools to your AI agents (filesystem, GitHub, database, etc.).

### Can I manage billing through the MCP server?

Not currently. Billing management is available through the dashboard only. Service account tokens for the MCP server should be scoped to deployment and secret management.

<Cards>
  <Card
    title="Agent Guide"
    href="/docs/agents/"
    description="Comprehensive guide for AI agents deploying MCP servers."
  />
  <Card
    title="CLI Reference"
    href="/docs/cli/"
    description="Manage your deployments from the terminal."
  />
  <Card
    title="Connecting AI Clients"
    href="/docs/ai-clients/"
    description="Connect deployed servers to AI tools."
  />
</Cards>