Antigravity × MCP Integration Guide — Mastering 7,500+ Tools from Arcade.dev

In 2026, Antigravity's deep integration with MCP (Model Context Protocol) opens 7,500+ tools and APIs to your AI agents. This guide takes you through the complete implementation path.

What MCP Does and Why It Matters

Model Context Protocol is a standard for AI models to interact with external tools, APIs, and data sources. Anthropic introduced it in 2024; it's now an industry standard.

The Problem MCP Solves

Before MCP:

AI agents could reason but couldn't reliably interact with the outside world
Every API had different schemas, auth schemes, error handling—integration was tedious
Combining data from multiple sources scattered context across many tools

With MCP:

Unified interface: Every tool speaks the same protocol
Auto-discovery: MCP servers report their tools and schemas automatically
Secure integration: Authentication and permissions are centralized
Scalable: New tools require zero agent-side code changes

Why Arcade.dev

Arcade.dev is a platform of 7,500+ integrated business and development tools: Salesforce, Slack, GitHub, Google Workspace, Figma, Stripe, Notion, AWS, and hundreds more.

Combine MCP with Arcade.dev and:

No API sprawl: One MCP runtime talks to all 7,500 tools
Unified auth: OAuth tokens and API keys are managed once
Data unification: Relate data across tools automatically

Setting Up an MCP Server in Antigravity

Step 1: Install MCP

npm install @anthropic-ai/sdk mcp
# or for Python
pip install mcp-sdk

Step 2: Initialize Your MCP Project

mkdir my-mcp-server && cd my-mcp-server
npm init -y
npm install @anthropic-ai/sdk express cors dotenv

Step 3: Define Your First Tool

// server.js
const express = require('express');
const { Server } = require('@anthropic-ai/sdk/mcp');
 
const app = express();
const mcpServer = new Server({
  name: 'my-antigravity-mcp',
  version: '1.0.0'
});
 
// Define a tool
mcpServer.defineTool({
  name: 'fetch-data',
  description: 'Fetch data from external APIs',
  inputSchema: {
    type: 'object',
    properties: {
      apiEndpoint: { type: 'string' },
      params: { type: 'object' }
    },
    required: ['apiEndpoint']
  },
  handler: async (input) => {
    const { apiEndpoint, params } = input;
    const response = await fetch(apiEndpoint, { 
      body: JSON.stringify(params) 
    });
    return response.json();
  }
});
 
app.use(express.json());
app.post('/mcp', async (req, res) => {
  const result = await mcpServer.processMessage(req.body);
  res.json(result);
});
 
app.listen(3000, () => {
  console.log('MCP Server running on port 3000');
});

Step 4: Connect to Antigravity

# antigravity.mcp.config.yml
mcp_servers:
  - name: "my-antigravity-mcp"
    type: "http"
    url: "http://localhost:3000/mcp"
    auth:
      type: "bearer"
      token: "${MCP_AUTH_TOKEN}"
 
arcade_runtime:
  enabled: true
  tools_limit: 500
  timeout: 30000

Arcade.dev Runtime Integration

Enable the Runtime

const ArcadeRuntime = require('arcade-mcp-runtime');
 
const runtime = new ArcadeRuntime({
  apiKey: process.env.ARCADE_API_KEY
});
 
// List available tools
async function listTools() {
  const tools = await runtime.getTools({ limit: 100 });
  console.log(`Total tools available: ${tools.total}`);
  return tools;
}
 
// Execute a tool
async function useTool(toolName, params) {
  return runtime.executeTool(toolName, params);
}

Tool Categories (7,500+ total)

Development (1,200+): GitHub, AWS, Docker, CI/CD platforms
Business (2,500+): Salesforce, Slack, Google Workspace, Asana
Design & Media (800+): Figma, Adobe, Canva, Spotify
Data & Analytics (1,000+): GA4, Stripe, Segment
Other (1,000+): WordPress, Twilio, Firebase

Build Your Own MCP Server

When Arcade.dev doesn't have what you need, build a custom MCP server.

Example: Internal CRM Tool

const { Server } = require('@anthropic-ai/sdk/mcp');
 
const crmServer = new Server({
  name: 'custom-crm-mcp'
});
 
// Tool: Get customer info
crmServer.defineTool({
  name: 'get-customer-info',
  description: 'Fetch from internal CRM',
  inputSchema: {
    type: 'object',
    properties: {
      customerId: { type: 'string' }
    },
    required: ['customerId']
  },
  handler: async ({ customerId }) => {
    const customer = await db.query(
      'SELECT * FROM customers WHERE id = ?',
      [customerId]
    );
    return customer.rows[0];
  }
});
 
// Tool: Update customer
crmServer.defineTool({
  name: 'update-customer',
  description: 'Update customer record',
  inputSchema: {
    type: 'object',
    properties: {
      customerId: { type: 'string' },
      updates: { type: 'object' }
    },
    required: ['customerId', 'updates']
  },
  handler: async ({ customerId, updates }) => {
    const result = await db.query(
      'UPDATE customers SET ? WHERE id = ?',
      [updates, customerId]
    );
    return { success: true, rows: result.affectedRows };
  }
});
 
module.exports = crmServer;

Recipe 1: GitHub Automation

Automatically triage issues, assign them, and add context.

async function setupGitHubAutomation(owner, repo) {
  
  // Fetch open issues
  const issues = await runtime.executeTool('github.list-issues', {
    owner,
    repo,
    state: 'open',
    labels: 'needs-triage'
  });
  
  for (const issue of issues) {
    const analysis = analyzeIssue(issue);
    
    // Add labels based on priority
    if (analysis.priority === 'high') {
      await runtime.executeTool('github.add-labels', {
        owner,
        repo,
        issue_number: issue.number,
        labels: ['priority-high']
      });
      
      // Assign to engineer
      const assignee = await findBestEngineer(analysis);
      await runtime.executeTool('github.assign-issue', {
        owner,
        repo,
        issue_number: issue.number,
        assignee
      });
    }
    
    // Post summary
    await runtime.executeTool('github.create-comment', {
      owner,
      repo,
      issue_number: issue.number,
      body: `## Triage\n${analysis.summary}`
    });
  }
}

Recipe 2: Database Integration

Query PostgreSQL, MongoDB, and Firestore through one interface.

class UnifiedDatabaseMCP {
  async query(database, collection, operation, params) {
    switch (database) {
      case 'postgres':
        return this.queryPostgres(collection, operation, params);
      case 'mongodb':
        return this.queryMongoDB(collection, operation, params);
      case 'firestore':
        return this.queryFirestore(collection, operation, params);
    }
  }
  
  async queryPostgres(table, operation, params) {
    const db = this.postgres;
    if (operation === 'find') {
      return db.any(`SELECT * FROM ${table} WHERE id = $1`, [params.id]);
    }
    if (operation === 'insert') {
      return db.one(`INSERT INTO ${table} SET $1 RETURNING *`, [params]);
    }
    if (operation === 'update') {
      return db.one(
        `UPDATE ${table} SET $1 WHERE id = $2 RETURNING *`,
        [params.updates, params.id]
      );
    }
  }
  
  // Similar for MongoDB and Firestore...
}

Recipe 3: Figma to Code Pipeline

Transform Figma designs into React components automatically.

async function figmaToCode(figmaFileKey, repoUrl) {
  
  // 1. Get Figma file
  const file = await runtime.executeTool('figma.get-file', {
    file_key: figmaFileKey
  });
  
  // 2. Extract components
  const components = extractComponents(file);
  
  // 3. Generate code
  const codeMap = {};
  for (const comp of components) {
    codeMap[comp.name] = generateCode(comp);
  }
  
  // 4. Clone repo, write files, commit
  await runtime.executeTool('git.clone', { url: repoUrl });
  
  for (const [name, code] of Object.entries(codeMap)) {
    writeFile(`src/components/${name}.tsx`, code);
  }
  
  await runtime.executeTool('git.add', { path: 'src/components/' });
  await runtime.executeTool('git.commit', { 
    message: `Auto: Sync Figma components` 
  });
  await runtime.executeTool('git.push', { branch: 'figma-sync' });
  
  // 5. Create PR
  const pr = await runtime.executeTool('github.create-pull-request', {
    title: `[Auto] Sync Figma`,
    head: 'figma-sync',
    base: 'main'
  });
  
  return pr;
}

Adding Claude via MCP and Splitting Work with Gemini

Antigravity ships with Gemini as its default model. Because MCP is model-agnostic, though, a thin proxy lets you reach Claude from the very same chat panel.

The idea is simple. You run a small local MCP server that wraps the Claude API, and Antigravity connects to it as just another tool.

// .antigravity/mcp.json — add Claude through a proxy
{
  "mcpServers": {
    "claude-proxy": {
      "command": "node",
      "args": ["./scripts/claude-mcp-proxy.js"],
      "env": {
        "ANTHROPIC_API_KEY": "YOUR_ANTHROPIC_API_KEY"
      }
    }
  }
}

The proxy itself stays lightweight: take the incoming prompt, hand it to the Anthropic SDK, and return the response as an MCP tool result.

// scripts/claude-mcp-proxy.js (minimal example)
const { Server } = require('@modelcontextprotocol/sdk/server');
const Anthropic = require('@anthropic-ai/sdk');
 
const anthropic = new Anthropic({ apiKey: process.env.ANTHROPIC_API_KEY });
const server = new Server({ name: 'claude-proxy', version: '1.0.0' });
 
server.tool('ask_claude', { prompt: 'string' }, async ({ prompt }) => {
  const res = await anthropic.messages.create({
    model: 'claude-sonnet-4-6',
    max_tokens: 4096,
    messages: [{ role: 'user', content: prompt }],
  });
  return { content: res.content[0].text };
});
 
server.listen();

Now an instruction like "have ask_claude review this design decision" runs straight from the Antigravity chat.

Which model gets which job

Once both are wired up, it is tempting to hunt for the "better" one. In daily use, though, it feels less like ranking and more like fit.

Integrations that touch Google Workspace or Google Cloud, and agentic work that drives a browser, flow more naturally when handed to Gemini.
Reading long design documents, surfacing contradictions in a spec, and producing polished prose are where Claude stays composed.

As an indie developer, I settled on a two-stage rhythm: let Gemini draft implementations in volume, and send only the design-level review to Claude. Being able to switch perspectives without leaving the IDE keeps the work moving more than I expected, and I lean on the same split when updating the Dolice blogs.

Decide this before you connect

The proxy holds your API key directly. Keep it in .env and never commit it. When sharing with a team, pin the model name and max token count inside the proxy so call costs do not creep past what you planned for.

Security & Access Control

Centralize Authentication

const SecurityManager = require('@anthropic-ai/mcp-security');
 
const manager = new SecurityManager({
  providers: {
    oauth2: { clientId: process.env.OAUTH_CLIENT_ID },
    vault: { path: 'secret/data/mcp-keys' }
  }
});
 
manager.enableAutoTokenRefresh({ interval: 3600000 });

Role-Based Access Control

const acl = {
  'user:engineers': {
    tools: ['github.*', 'docker.*'],
    resources: ['staging']
  },
  'agent:ci-bot': {
    tools: ['github.*'],
    resources: ['staging']
  }
};
 
function canExecute(principal, tool, resource) {
  const rules = acl[principal];
  if (!rules) return false;
  
  const hasTool = rules.tools.some(p => matchPattern(p, tool));
  const hasResource = rules.resources.includes(resource);
  
  return hasTool && hasResource;
}

Multi-Agent Workflows with MCP

Pattern 1: Sequential Workflows

Agent 1 (GitHub) → Agent 2 (Review) → Agent 3 (Docker) → Agent 4 (Deploy)

Pattern 2: Parallel Merge

Agent 1 (Design) + Agent 2 (Backend) + Agent 3 (DevOps) → Agent 4 (Integration)

Pattern 3: Loop & Retry

Agent 1 (Monitor) → Detect → Agent 2 (Fix) → Agent 3 (Verify) → Success? Loop

Wrapping up

Antigravity × MCP unlocks a new era of AI agent capabilities.

MCP standardizes tool integration, eliminating API sprawl
Arcade.dev's 7,500+ tools expand agent capabilities exponentially
Custom MCP servers let you add proprietary logic
Security controls ensure enterprise-grade trust

Next: Read AgentKit 2.0 Complete Feature Guide to orchestrate agents and build sophisticated systems.