Tabstack MCP Server

You’re building something that uses Tabstack. You don’t want to leave your editor to look up method signatures, remember parameter names, or round-trip through a terminal to see what a response actually looks like.

The Tabstack MCP server wires Tabstack into whatever MCP-capable coding assistant you’re already using — Claude Code, Cursor, VS Code Copilot, Windsurf, Zed, or any other client that speaks the Model Context Protocol. Ask for the right method, run it against a real URL with your own schema, inspect the result, iterate on the call, then lift the version you like into the project you’re actually shipping.

This is a development-time tool. It’s not how a production agent should call Tabstack — for that, use the SDK directly. It’s how you explore, prototype, and debug the integration on the way there.

---

What is MCP?

The Model Context Protocol (MCP) is an open standard for connecting AI agents to external data and tools. Think of it as a USB port for AI — a standard interface that lets any compatible client talk to any compatible server without custom integration code.

MCP was introduced by Anthropic and has since been adopted across the ecosystem: Claude, Cursor, VS Code Copilot, and a growing list of coding assistants and local LLM environments all support it. When you add an MCP server to your assistant’s config, that server’s tools become first-class capabilities the assistant can use on your behalf.

---

Install in your tool

You’ll need a Tabstack API key first (get one at tabstack.ai).

Cursor

Click to install. You’ll be prompted to add your API key in Cursor Settings > Tools & MCP > New MCP Server.

VS Code

Open in VS Code

After installing, set your API key in VS Code’s mcp.json (Command Palette > MCP: Open User Configuration).

Claude Code

claude mcp add tabstack https://tabstack.stlmcp.com \
  --transport http \
  --header "x-tabstack-api-key: YOUR_API_KEY"

Verify the connection:

claude mcp list

You should see tabstack: https://tabstack.stlmcp.com (HTTP) - ✓ Connected.

Claude Desktop or any other MCP-compatible client

Add this to your mcp.json config file:

{
  "mcpServers": {
    "tabstack": {
      "type": "http",
      "url": "https://tabstack.stlmcp.com",
      "headers": {
        "x-tabstack-api-key": "YOUR_API_KEY"
      }
    }
  }
}

Restart the client. The server should appear as tabstack in your tool picker.

---

What the server exposes

The Tabstack server uses a “Code Mode” architecture. Rather than exposing every API endpoint as a separate tool (which burns tokens and makes the assistant brittle about which tool to pick), it exposes two:

search_docs — semantic search over the Tabstack SDK documentation, scoped to the language you’re working in (TypeScript, Python, Go, Ruby, and others). Your assistant reaches for this first when it needs to find the right method or parameter before generating code.

execute — runs TypeScript code against a pre-authenticated Tabstack SDK client in an isolated sandbox and returns whatever the function returns or logs. Your assistant drafts a small run(client) function and fires it off to see what actually comes back.

A typical round-trip your assistant goes through when you ask it a Tabstack question:

// generated and run by the assistant after you ask:
// "extract the pricing plans from stripe.com/pricing as JSON"
async function run(client) {
  const result = await client.extract.json({
    url: "https://stripe.com/pricing",
    json_schema: {
      type: "object",
      properties: {
        plans: {
          type: "array",
          items: {
            type: "object",
            properties: {
              name: { type: "string" },
              price_usd: { type: ["number", "null"] },
            },
          },
        },
      },
    },
  });
  return result;
}

The sandbox client is already authenticated with your key. The assistant doesn’t juggle credentials, imports, or boilerplate — it writes the business logic, hits execute, and hands you the response. You look at the result, decide whether the schema is right, ask for a tweak, and repeat.

---

What this is useful for

API discovery. Ask in English what you want to do (“how do I convert a page to markdown?”, “does Tabstack support geotargeted requests?”) and get an SDK-accurate answer grounded in the real docs, not the model’s training cutoff.

Schema iteration. Draft a JSON schema, run an extraction against a real URL, see what comes back, adjust the schema, rerun. All inline in the chat — no separate terminal, no credential plumbing.

Sanity-checking behavior before you ship. Before you wire client.agent.research() into your production pipeline, run it from the assistant with your actual query. Check the event shapes, the citation payload, how long it takes, whether mode: 'fast' is good enough.

Copy-paste-ready code. Once a call works, ask the assistant for the equivalent SDK snippet in your project’s language. What you paste into your codebase has the same shape as what just ran successfully.

Exploring endpoints you haven’t used before. Trying /generate/json for the first time? Ask the assistant to generate an example and run it. Ten seconds from question to a known-good response you can iterate from.

---

Sandbox limits

The execute tool runs in an isolated environment:

• No filesystem or external network access outside the Tabstack API.
• 30-second timeout per HTTP request.
• ~5-minute total execution timeout.
• Variables don’t persist between execute calls. Return or log everything you need.

For large tasks, use API parameters to filter and paginate within a single execute block rather than chaining multiple calls.

---

When to use this vs. the SDK directly

Situation	Reach for
Discovering the API, prototyping, debugging an integration	MCP server
Production code in your service	SDK directly in your project
Latency-sensitive paths that can’t afford a sandbox round-trip	SDK directly
Multi-tenant auth where each request needs a different key	SDK directly
Wiring Tabstack into a deployed agent’s runtime tool set	SDK directly (the SDK is the agent’s tool)
Writing a one-off script to grab data for analysis	Either works; MCP is faster if you’re already in an editor

A useful mental model: the MCP server is for the developer-in-the-loop phase. Once the integration is working and you’re ready to embed it, move to direct SDK calls in your own code.

Interactive Mode — the SSE-based callback flow for forms that require user data — is not available over MCP. It needs a persistent stream the caller can exchange events on, which the MCP transport doesn’t expose. Use the SDK directly when you need it.

---

Next steps

• Quickstart — the minimal authenticate-and-call path if you’re going straight to SDK code.
• Build your first Tabstack app — end-to-end tutorial that turns Tabstack output into a real CLI.
• Schema design guide — how to write json_schema definitions that return exactly what you need.
• Production reliability patterns — handling failures and timeouts at scale.