Documentation

What is Agent MCP Studio?

Agent MCP Studio is a free, browser-based platform for building, testing, and exporting MCP (Model Context Protocol) tools and AI agent teams. Every piece of code runs inside your browser using WebAssembly — no server, no Docker, no Python installation needed.

• Write tools in Python or DuckDB SQL — the browser runs them natively via Pyodide WASM and DuckDB-WASM.
• Generate code from English — describe what you want, the LLM writes the Python or SQL for you.
• Build agent personas — give each AI specialist a name, a role, and a curated set of tools.
• Pick a collaboration strategy — Supervisor, Debate, Mixture of Experts, and 7 more.
• Export a real MCP server — download a runnable Python file for Claude Desktop or any MCP client.
• No account required — free forever. Your data stays in your browser.

The 5-Step Workflow

Most people go from zero to a working AI agent team in under 10 minutes. Here's the path:

🐍 Generate Tab

Choosing a Runtime

Every tool runs in one of two isolated sandboxes:

Natural-Language Specification

Describe your tool in plain English. Be specific about:

• Tool name — Python snake_case (e.g. get_stock_price)
• Parameters — names and types ({"symbol": "string", "days": "int"})
• What it fetches or computes — the URL, formula, or logic
• Return value — what fields to include in the result

Create an async MCP tool named get_stock_price that accepts
{"symbol": "string", "days": "int"}.
Fetch https://api.example.com/price/{symbol}?days={days}
via http_request. Return {"symbol", "price", "change_pct"}.

The Code Editor

The right panel is a full CodeMirror editor with Python syntax highlighting. A working starter tool (unit_converter) is pre-loaded so you can click ▶ Register Tool immediately — no LLM or API key needed.

A complete Python tool example

async def github_user(params: dict) -> dict:
    """
    Fetch a GitHub user's public profile.
    Returns name, bio, followers, and public repos.
    """
    username = params["username"]
    data = await http_request(
        f"https://api.github.com/users/{username}"
    )
    return {
        "name":         data.get("name"),
        "bio":          data.get("bio"),
        "followers":    data.get("followers"),
        "public_repos": data.get("public_repos"),
    }

Allowed Python imports

The sandbox allows a curated set of standard-library modules. No third-party packages (pip install) — but you don't need them for most tools:

# Allowed imports
import json, re, math, statistics, datetime, time
import random, hashlib, base64, itertools, functools
import collections, typing, string, decimal, fractions
import struct, copy, textwrap, unicodedata, enum
import dataclasses, abc

# Built-in helpers (always available, no import needed)
await http_request(url, method="GET", headers={}, body=None)
await http_request(url, method="POST", body=json.dumps(payload))

Register vs Validate Only

• ▶ Register Tool — AST-parses your code, checks for syntax errors, and saves it to the Registry. The tool is ready to be called.
• Validate Only — same check, but does NOT save. Use this to proof-read before committing.
• Copy — copies the raw code to your clipboard.

📦 Registry

Managing tools

• Enable / Disable — disabled tools are invisible to the agent team. Toggle per-tool or use "Enable all" / "Disable all".
• Preload All — initializes Pyodide and warms up every tool's sandbox. First call is faster after preloading.
• Clear Cache — forces Pyodide to reload its runtime on next invocation.

Export options

The exported MCP server

The downloaded mcp_server.py is a fully self-contained Python script using the mcp SDK. Run it with:

pip install mcp httpx
python mcp_server.py

Then point Claude Desktop's config at it:

{
  "mcpServers": {
    "my-tools": {
      "command": "python",
      "args": ["/path/to/mcp_server.py"]
    }
  }
}

🧪 Test Tab

How to test a tool

🤝 Agents Tab

Personas

A persona is an AI specialist. It has:

• Name — snake_case identifier, e.g. financial_expert
• System prompt — a paragraph describing the persona's role, tone, and specialty
• Assigned tools — drag tool chips from the palette onto the persona's node in the graph
• Color — visual identifier in the chat and graph views

Example system prompt for a financial_expert persona:

You are a financial analysis expert. You have access to tools
that can fetch stock prices, calculate portfolio metrics, and
retrieve earnings reports. Always cite the data source and
provide confidence levels with your analysis.

The node graph

Every persona appears as a draggable node on the canvas. Edges between nodes are drawn automatically based on the active strategy. The graph reshapes as you switch strategies — a Supervisor strategy puts one node at the center; a Debate strategy creates a ring topology.

Assigning tools to personas

In the left palette (Tools — Drag onto a Persona), each registered tool appears as a chip. Drag a chip onto a persona node to assign that tool. Assignments are saved instantly and survive page reloads.

♟️ Collaboration Strategies

💬 Agent Chat

Modes

• Normal chat — talks directly to the selected LLM backend with no tool use. Great for quick Q&A.
• Agentic mode — enables the full agent team. Your personas, tools, and strategy all activate. Responses stream token-by-token.

Backend selection

Streaming output

Each persona's turn streams into the chat as it happens — you see tokens appear word by word. A spinning indicator shows which persona is currently "thinking". When a tool call happens, the result is shown inline with the turn.

🦆 Data (SQL) Tab

The Data tab runs DuckDB-WASM — a full analytical SQL engine compiled to WebAssembly. It can query CSV, Parquet, and JSON files you upload directly into the browser's in-memory filesystem.

Creating a SQL tool

-- DuckDB tool: top_products
-- params: {"category": "string", "limit": "int"}
SELECT
    product_name,
    SUM(revenue) AS total_revenue,
    COUNT(*) AS num_orders
FROM sales
WHERE category = $category
GROUP BY product_name
ORDER BY total_revenue DESC
LIMIT $limit;

📚 Knowledge (RAG) Tab

How RAG works here

⌨️ MCP Console

The console gives you a direct JSON-RPC-style interface to invoke any registered tool. Pick a tool, enter params, hit Invoke, and see the raw response. This is the fastest way to debug a tool's output format before assigning it to a persona.

// Example invocation
{
  "tool": "github_user",
  "params": { "username": "torvalds" }
}

// Response
{
  "name": "Linus Torvalds",
  "bio": "Linux kernel developer",
  "followers": 218000,
  "public_repos": 7
}

⚙️ Settings

LLM backend

Network allowlist

Tools can only call external URLs that match patterns in the allowlist. This prevents a badly-written (or malicious) tool from calling arbitrary endpoints. Each example specification automatically adds the relevant host:

api.github.com          # GitHub REST API
api.openweathermap.org  # Weather data
hacker-news.firebaseio.com  # HN stories
api.coingecko.com       # Crypto prices
*.wikipedia.org         # Wikipedia (wildcard supported)

Credentials (secrets)

API keys used by your tools (e.g. an Alpha Vantage key for a stock price tool) go in the Credentials section. They are stored in localStorage and injected into the Pyodide sandbox at runtime — they never appear in your tool's source code.

🚀 Export & Deploy

Export MCP Server

Clicking Export MCP Server downloads a mcp_server.py that includes:

• All enabled tools, translated from browser-WASM Python to standard CPython
• The persona definitions and system prompts
• The selected collaboration strategy as Python code
• The network allowlist enforced via httpx

Using with Claude Desktop

# 1. Install dependencies
pip install "mcp[cli]" httpx

# 2. Run the server
python mcp_server.py

# 3. Configure Claude Desktop (~/.config/claude/claude_desktop_config.json)
# Add the snippet shown in the export dialog.

Import & share tool packs

Use Export JSON to get a portable tools.json containing all your tool definitions. Share it with teammates — they can Import it into their own Studio instance to start from the same toolset.

❓ Frequently Asked Questions