Antigravity × MCP 統合ガイド — Arcade.dev 7,500+ツール・API 活用術

2026年、Antigravity エコシステムは**MCP（Model Context Protocol）**との深い統合により、7,500以上のツール・API への自動アクセスを実現しました。

Antigravity と MCP を組み合わせ、Arcade.dev のツール群を AI エージェント開発に活かすための完全な実装パスを順を追って整理していきます。

MCP の概要とAIエージェント開発における重要性

Model Context Protocol（MCP）は、AI モデルが外部ツール・API・データソースと対話するための標準化されたプロトコルです。2024年に Anthropic が発表し、2026年には業界標準となりましました。

MCP が解決する課題

従来の課題:

AI エージェントは「考える力」は強いが、「外界と接触する力」は限定的
API の多様性：各 API が異なるスキーマ・認証・エラー処理を持ち、統合が煩雑
コンテキストの断片化：複数データソースからの情報を統合するのに時間と労力がかかる

MCP の解決:

標準化されたインターフェース: すべてのツール・API が同じプロトコルで接続
ツール自動検出: MCP サーバーが自身のツール・スキーマを自動報告
セキュアな統合: 認証・権限管理の一元化
スケーラビリティ: 新ツール追加時にエージェント側のコード変更が不要

Arcade.dev との連携

Arcade.dev は、7,500以上のビジネス・開発ツールの統合プラットフォームです。Salesforce・Slack・GitHub・Google Workspace・Figma・Stripe・Notion・AWS などが含まれます。

MCP と Arcade.dev の統合により：

API の管理複雑性排除: 1つの MCP ランタイムで全ツールにアクセス
認証の一元化: OAuth トークン・API キーの管理が Arcade.dev 側で完結
コンテキスト統合: 複数ツール間でデータを自動的に関連付け・統合

Antigravity での MCP サーバーセットアップ手順

Step 1: MCP インストール

# Node.js 環境での MCP インストール
npm install @anthropic-ai/sdk mcp
 
# Python 環境での場合
pip install mcp-sdk

Step 2: MCP サーバーの初期化

# MCP プロジェクトディレクトリ作成
mkdir my-mcp-server && cd my-mcp-server
npm init -y
 
# 依存関係インストール
npm install @anthropic-ai/sdk express cors dotenv

Step 3: 基本的な MCP サーバーコード

// 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',
  description: 'MCP server for Antigravity integration'
});
 
// ツール定義
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;
    // API 呼び出し処理
    const response = await fetch(apiEndpoint, { body: JSON.stringify(params) });
    return response.json();
  }
});
 
app.use(express.json());
app.use(cors());
 
// MCP エンドポイント
app.post('/mcp', async (req, res) => {
  const result = await mcpServer.processMessage(req.body);
  res.json(result);
});
 
const PORT = process.env.PORT || 3000;
app.listen(PORT, () => {
  console.log(`MCP Server running on port ${PORT}`);
});

Step 4: 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  # 最初は 500 ツールまでに制限
  timeout: 30000    # タイムアウト: 30秒

Arcade.dev MCP ランタイム統合 — 7,500+ツール・APIへのアクセス

ランタイムの有効化

// antigravity-mcp-client.js
const ArcadeRuntime = require('arcade-mcp-runtime');
 
const runtime = new ArcadeRuntime({
  apiKey: process.env.ARCADE_API_KEY,
  environment: 'production'
});
 
// 利用可能なツール一覧を取得
async function listAvailableTools() {
  const tools = await runtime.getTools({
    limit: 100,
    offset: 0
  });
  
  console.log(`Available tools: ${tools.total} (showing ${tools.items.length})`);
  tools.items.forEach(tool => {
    console.log(`- ${tool.name}: ${tool.description}`);
  });
  
  return tools;
}
 
// ツール実行
async function executeTool(toolName, params) {
  const result = await runtime.executeTool(toolName, params);
  return result;
}
 
module.exports = { runtime, listAvailableTools, executeTool };

ツールカテゴリ別の活用

Arcade.dev の 7,500+ツールは、以下のカテゴリに分類されます：

開発ツール（1,200+）

GitHub・GitLab・Bitbucket API
Docker Hub・npm Registry
AWS・Google Cloud・Azure API
CI/CD: GitHub Actions・GitLab CI・Jenkins

ビジネスツール（2,500+）

CRM: Salesforce・HubSpot・Pipedrive
チャット: Slack・Microsoft Teams・Discord
メール・カレンダー・ドライブ: Google Workspace・Microsoft 365
プロジェクト管理: Asana・Monday・Notion・Jira

デザイン・メディア（800+）

Figma・Adobe XD・Sketch
Canva・Photoshop API
YouTube・Spotify・Cloudinary

データ・分析（1,000+）

Google Analytics・Mixpanel・Amplitude
Stripe・PayPal（決済）
Segment・mParticle（データ統合）

その他（1,000+）

AI：OpenAI・Anthropic・Google Gemini
コンテンツ管理：WordPress・Contentful
通知：Twilio・SendGrid

カスタム MCP サーバーの構築方法

Arcade.dev に存在しない独自ツールが必要な場合、カスタム MCP サーバーを構築できます。

Example: 独自 CRM ツール

// custom-crm-mcp-server.js
const { Server } = require('@anthropic-ai/sdk/mcp');
 
const crmServer = new Server({
  name: 'custom-crm-mcp',
  version: '1.0.0'
});
 
// ツール1: 顧客情報取得
crmServer.defineTool({
  name: 'get-customer-info',
  description: 'Fetch customer information from internal CRM',
  inputSchema: {
    type: 'object',
    properties: {
      customerId: { type: 'string' },
      fields: { type: 'array', items: { type: 'string' } }
    },
    required: ['customerId']
  },
  handler: async (input) => {
    const { customerId, fields } = input;
    
    // 内部 CRM データベースからクエリ
    const customer = await db.query(
      'SELECT * FROM customers WHERE id = ?',
      [customerId]
    );
    
    if (fields && fields.length > 0) {
      return customer.rows[0][fields];
    }
    return customer.rows[0];
  }
});
 
// ツール2: 顧客更新
crmServer.defineTool({
  name: 'update-customer',
  description: 'Update customer information',
  inputSchema: {
    type: 'object',
    properties: {
      customerId: { type: 'string' },
      updates: { type: 'object' }
    },
    required: ['customerId', 'updates']
  },
  handler: async (input) => {
    const { customerId, updates } = input;
    
    const result = await db.query(
      'UPDATE customers SET ? WHERE id = ?',
      [updates, customerId]
    );
    
    return { success: true, updated: result.affectedRows };
  }
});
 
// ツール3: 顧客検索
crmServer.defineTool({
  name: 'search-customers',
  description: 'Search customers by various criteria',
  inputSchema: {
    type: 'object',
    properties: {
      query: { type: 'string' },
      filters: { type: 'object' }
    },
    required: ['query']
  },
  handler: async (input) => {
    const { query, filters } = input;
    
    let sql = 'SELECT * FROM customers WHERE name LIKE ?';
    const params = [`%${query}%`];
    
    if (filters) {
      if (filters.status) {
        sql += ' AND status = ?';
        params.push(filters.status);
      }
      if (filters.minRevenue) {
        sql += ' AND revenue >= ?';
        params.push(filters.minRevenue);
      }
    }
    
    const results = await db.query(sql, params);
    return results.rows;
  }
});
 
module.exports = crmServer;

実践レシピ1: GitHub 連携の自動化

GitHub のリポジトリ・プルリクエスト・Issue を自動で監視し、AI エージェントが自動対応するワークフロー。

// github-automation.js
const { runtime } = require('./antigravity-mcp-client');
 
async function setupGitHubAutomation(repoOwner, repoName) {
  
  // 1. リポジトリの最新 Issue 取得
  const issues = await runtime.executeTool('github.list-issues', {
    owner: repoOwner,
    repo: repoName,
    state: 'open',
    labels: 'needs-triage',
    limit: 10
  });
  
  console.log(`Found ${issues.length} open issues to triage`);
  
  // 2. 各 Issue に対して AI が内容を分析
  for (const issue of issues) {
    const analysis = await analyzeIssue(issue);
    
    // 3. 分析結果に基づいてラベル追加
    if (analysis.priority === 'high') {
      await runtime.executeTool('github.add-labels', {
        owner: repoOwner,
        repo: repoName,
        issue_number: issue.number,
        labels: ['priority-high', 'urgent']
      });
      
      // 4. アサイン
      const assignee = await findBestEngineer(analysis);
      await runtime.executeTool('github.assign-issue', {
        owner: repoOwner,
        repo: repoName,
        issue_number: issue.number,
        assignee: assignee
      });
    }
    
    // 5. コメント追加（初期トリアージ結果）
    await runtime.executeTool('github.create-comment', {
      owner: repoOwner,
      repo: repoName,
      issue_number: issue.number,
      body: `## Triage Summary\n${analysis.summary}`
    });
  }
}
 
async function analyzeIssue(issue) {
  // AI エージェントが Issue を分析
  return {
    priority: issue.title.includes('[BUG]') ? 'high' : 'medium',
    category: extractCategory(issue.body),
    summary: generateSummary(issue)
  };
}
 
// 使用例
setupGitHubAutomation('myorg', 'myrepo').catch(console.error);

実践レシピ2: データベース操作の統合

複数のデータベース（PostgreSQL・MongoDB・Firestore）に対して、統一されたインターフェースで操作。

// database-mcp.js
const DatabaseMCP = require('./custom-crm-mcp-server');
 
class UnifiedDatabaseMCP {
  constructor() {
    this.backends = {
      postgres: require('pg-promise')(),
      mongodb: require('mongodb').MongoClient,
      firestore: require('firebase-admin').firestore()
    };
  }
  
  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);
      default:
        throw new Error(`Unknown database: ${database}`);
    }
  }
  
  async queryPostgres(table, operation, params) {
    const db = this.backends.postgres;
    switch (operation) {
      case 'find':
        return db.any(`SELECT * FROM ${table} WHERE id = $1`, [params.id]);
      case 'insert':
        return db.one(`INSERT INTO ${table} SET $1 RETURNING *`, [params]);
      case 'update':
        return db.one(
          `UPDATE ${table} SET $1 WHERE id = $2 RETURNING *`,
          [params.updates, params.id]
        );
      case 'delete':
        return db.none(`DELETE FROM ${table} WHERE id = $1`, [params.id]);
    }
  }
  
  async queryMongoDB(collection, operation, params) {
    const db = this.backends.mongodb;
    switch (operation) {
      case 'find':
        return db.collection(collection).findOne({ _id: params.id });
      case 'insert':
        return db.collection(collection).insertOne(params);
      case 'update':
        return db.collection(collection).updateOne(
          { _id: params.id },
          { $set: params.updates }
        );
      case 'delete':
        return db.collection(collection).deleteOne({ _id: params.id });
    }
  }
  
  async queryFirestore(collection, operation, params) {
    const db = this.backends.firestore;
    switch (operation) {
      case 'find':
        return (await db.collection(collection).doc(params.id).get()).data();
      case 'insert':
        await db.collection(collection).doc(params.id).set(params);
        return params;
      case 'update':
        await db.collection(collection).doc(params.id).update(params.updates);
        return params.updates;
      case 'delete':
        await db.collection(collection).doc(params.id).delete();
        return { deleted: true };
    }
  }
}
 
module.exports = UnifiedDatabaseMCP;

実践レシピ3: Figma → コード変換パイプライン

Figma デザインを自動的にコンポーネントコードへ変換し、リポジトリに commit する完全自動化ワークフロー。

// figma-to-code.js
const { runtime } = require('./antigravity-mcp-client');
 
async function figmaToCodePipeline(figmaFileKey, repositoryUrl) {
  
  // Step 1: Figma ファイル取得
  const figmaFile = await runtime.executeTool('figma.get-file', {
    file_key: figmaFileKey
  });
  
  console.log(`Processing Figma file: ${figmaFile.name}`);
  
  // Step 2: コンポーネントを検出
  const components = extractComponents(figmaFile);
  
  // Step 3: 各コンポーネントをコードに変換
  const generatedCode = {};
  for (const component of components) {
    generatedCode[component.name] = await generateComponentCode(component);
  }
  
  // Step 4: リポジトリにクローン
  const repoClone = await runtime.executeTool('git.clone', {
    url: repositoryUrl
  });
  
  // Step 5: コンポーネント ファイル生成
  for (const [componentName, code] of Object.entries(generatedCode)) {
    const filePath = `src/components/${componentName}.tsx`;
    await writeFile(filePath, code);
  }
  
  // Step 6: Git commit & push
  await runtime.executeTool('git.add', {
    path: 'src/components/'
  });
  
  await runtime.executeTool('git.commit', {
    message: `Auto: Sync Figma components from ${figmaFile.name}`
  });
  
  await runtime.executeTool('git.push', {
    branch: 'figma-sync'
  });
  
  // Step 7: プルリクエスト作成
  const pr = await runtime.executeTool('github.create-pull-request', {
    title: `[Auto] Sync Figma: ${figmaFile.name}`,
    body: `Auto-generated from Figma file: ${figmaFileKey}`,
    head: 'figma-sync',
    base: 'main'
  });
  
  console.log(`PR created: ${pr.html_url}`);
  return pr;
}
 
function extractComponents(figmaFile) {
  // Figma ファイルから コンポーネント抽出
  return figmaFile.components.map(comp => ({
    name: comp.name,
    props: comp.properties || [],
    children: comp.children || []
  }));
}
 
async function generateComponentCode(component) {
  // AI にコード生成を依頼
  return `
import React from 'react';
 
interface ${component.name}Props {
  ${component.props.map(p => `${p.name}: ${p.type};`).join('\n  ')}
}
 
export const ${component.name}: React.FC<${component.name}Props> = (props) => {
  // Auto-generated from Figma
  return <div>{/* ${component.name} implementation */}</div>;
};
`;
}
 
// 使用例
figmaToCodePipeline(
  'abc123def456',
  'https://github.com/myorg/myrepo.git'
).catch(console.error);

応用：Claude を MCP 経由で呼び出し、Gemini と使い分ける

Antigravity は標準で Gemini モデルを採用しています。ただ MCP はモデル非依存の仕様ですので、プロキシを一枚はさめば同じチャット画面から Claude を呼び出すこともできます。

仕組みは単純です。ローカルで動く小さな MCP サーバーを Claude API のラッパーとして用意し、Antigravity からはひとつのツールとして接続します。

// .antigravity/mcp.json — Claude をプロキシ経由で追加する
{
  "mcpServers": {
    "claude-proxy": {
      "command": "node",
      "args": ["./scripts/claude-mcp-proxy.js"],
      "env": {
        "ANTHROPIC_API_KEY": "YOUR_ANTHROPIC_API_KEY"
      }
    }
  }
}

プロキシ本体は、受け取ったプロンプトを Anthropic SDK にそのまま渡し、応答を MCP のツール結果として返すだけの薄い実装で足ります。

// scripts/claude-mcp-proxy.js（最小構成の例）
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();

これで「ask_claude にこの設計方針をレビューさせて」といった指示が、Antigravity のチャットからそのまま通ります。

どちらのモデルにどの仕事を渡すか

両方をつなぐと、つい「どちらか優れている方」を探したくなります。けれども実際に使い分けてみると、優劣ではなく相性の問題だと感じます。

Google Workspace や Google Cloud に絡む連携、ブラウザ操作をともなうエージェント的な作業は、Gemini に任せると流れがよどみません。
長い設計ドキュメントの読解、仕様の矛盾の洗い出し、文章としての出力は Claude が落ち着いて処理してくれます。

私自身、個人開発でこの構成を使うときは、実装の下書きを Gemini に量産させ、その設計判断のレビューだけを Claude に投げる、という二段構えに落ち着きました。IDE を離れずに視点を切り替えられることが、思っていた以上に作業のリズムを保ってくれます。私はこの使い分けを、Dolice で運営しているブログの更新作業でも同じ要領に落とし込んでいます。

つなぐ前に決めておくこと

プロキシは API キーを直接握ります。.env に隔離し、リポジトリには絶対にコミットしないでください。チームで共有する場合は、プロキシ側でモデル名と最大トークン数を固定しておくと、呼び出しコストが想定外に膨らむのを防げます。

セキュリティとアクセス制御のベストプラクティス

MCP で多数の外部ツールを統合する際、セキュリティは最重要です。

1. 認証・認可の一元化

// security-config.js
const SecurityManager = require('@anthropic-ai/mcp-security');
 
const securityManager = new SecurityManager({
  providers: {
    oauth2: {
      clientId: process.env.OAUTH_CLIENT_ID,
      clientSecret: process.env.OAUTH_CLIENT_SECRET
    },
    apiKey: {
      strategy: 'vault',  // HashiCorp Vault
      path: 'secret/data/mcp-keys'
    }
  }
});
 
// トークン自動更新
securityManager.enableAutoTokenRefresh({
  interval: 3600000  // 1時間ごと
});

2. ツール実行の権限制御

// access-control.js
const acl = {
  'user:engineers': {
    tools: ['github.*', 'docker.*', 'aws.*'],
    resources: ['prod', 'staging']
  },
  'user:analysts': {
    tools: ['google-analytics.*', 'stripe.*'],
    resources: ['analytics', 'billing']
  },
  'agent:ci-bot': {
    tools: ['github.*', 'docker.*'],
    resources: ['staging']
  }
};
 
function canExecuteTool(principal, toolName, resource) {
  const rules = acl[principal];
  if (!rules) return false;
  
  const hasToolAccess = rules.tools.some(pattern => 
    matchPattern(pattern, toolName)
  );
  const hasResourceAccess = rules.resources.includes(resource);
  
  return hasToolAccess && hasResourceAccess;
}

3. セキュアなシークレット管理

# HashiCorp Vault でシークレット保管
vault kv put secret/mcp/github \
  token="ghp_..." \
  owner="myorg"
 
vault kv put secret/mcp/stripe \
  api_key="sk_live_..." \
  webhook_secret="whsec_..."

MCP × マルチエージェントワークフローの設計パターン

複数の AI エージェントが MCP で連携し、複雑なワークフローを実行するパターン。

パターン1: 順序依存ワークフロー

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

Agent 1 が Issue を取得 → Agent 2 が修正案を提案 → Agent 3 がコンテナ化 → Agent 4 がデプロイ

パターン2: 並列・マージワークフロー

Agent 1 (Design) ─┐
                  ├→ Agent 4 (Integration)
Agent 2 (Backend) ┤
                  ├→ Agent 5 (Testing)
Agent 3 (DevOps)  ┘

パターン3: ループ・反復ワークフロー

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

全体を振り返って

Antigravity × MCP の統合は、AI エージェント開発の新たな時代を開きます。

MCP の標準化で、API 統合の複雑性が劇的に削減
Arcade.dev の 7,500+ツールで、エージェントの能力範囲が無限拡大
カスタム MCP サーバーで、独自ツール・ビジネスロジックを追加
セキュリティ・アクセス制御により、エンタープライズレベルの信頼性を確保

次のステップ：AgentKit 2.0 新機能完全ガイドで、Antigravity のエージェント・オーケストレーション機能と組み合わせ、より高度なシステムを設計します。