Antigravity × MCP で外部APIを統合した独自AIエージェントを構築する

mkdir my-api-mcp-server
cd my-api-mcp-server
npm init -y
npm install @modelcontextprotocol/sdk zod
npm install -D typescript @types/node tsx

{
  "compilerOptions": {
    "target": "ES2022",
    "module": "ESNext",
    "moduleResolution": "bundler",
    "outDir": "./dist",
    "strict": true,
    "esModuleInterop": true,
    "skipLibCheck": true
  },
  "include": ["src/**/*"]
}

// src/index.ts
import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
import { z } from "zod";
 
// MCP サーバーインスタンスを作成
const server = new McpServer({
  name: "weather-api",
  version: "1.0.0",
});
 
// ツール: 指定した都市の天気情報を取得
server.tool(
  "get_weather",
  "指定した都市の現在の天気情報を取得します",
  {
    city: z.string().describe("都市名（例: Tokyo, New York）"),
    units: z
      .enum(["metric", "imperial"])
      .optional()
      .default("metric")
      .describe("温度の単位"),
  },
  async ({ city, units }) => {
    try {
      const apiKey = process.env.WEATHER_API_KEY;
      if (!apiKey) {
        return {
          content: [
            {
              type: "text",
              text: "エラー: WEATHER_API_KEY が設定されていません",
            },
          ],
        };
      }
 
      const url = `https://api.openweathermap.org/data/2.5/weather?q=${encodeURIComponent(city)}&units=${units}&appid=${apiKey}`;
      const response = await fetch(url);
 
      if (!response.ok) {
        return {
          content: [
            {
              type: "text",
              text: `API エラー: ${response.status} ${response.statusText}`,
            },
          ],
        };
      }
 
      const data = await response.json();
      // レスポンスを人間が読みやすい形式に整形
      const summary = [
        `都市: ${data.name}（${data.sys.country}）`,
        `天気: ${data.weather[0].description}`,
        `気温: ${data.main.temp}°${units === "metric" ? "C" : "F"}`,
        `湿度: ${data.main.humidity}%`,
        `風速: ${data.wind.speed} ${units === "metric" ? "m/s" : "mph"}`,
      ].join("\n");
 
      return { content: [{ type: "text", text: summary }] };
    } catch (error) {
      return {
        content: [
          {
            type: "text",
            text: `接続エラー: ${error instanceof Error ? error.message : "不明なエラー"}`,
          },
        ],
      };
    }
  }
);
 
// サーバーを起動
const transport = new StdioServerTransport();
await server.connect(transport);

// .antigravity/settings.json（プロジェクト設定）
{
  "mcpServers": {
    "weather-api": {
      "command": "npx",
      "args": ["tsx", "./my-api-mcp-server/src/index.ts"],
      "env": {
        "WEATHER_API_KEY": "YOUR_API_KEY"
      }
    }
  }
}

// src/project-agent.ts
import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
import { z } from "zod";
 
const server = new McpServer({
  name: "project-manager",
  version: "1.0.0",
});
 
// GitHub Issues から未完了タスクを取得
server.tool(
  "list_open_issues",
  "GitHubリポジトリの未完了Issueを一覧取得します",
  {
    repo: z.string().describe("リポジトリ名（owner/repo形式）"),
    labels: z
      .string()
      .optional()
      .describe("フィルターするラベル（カンマ区切り）"),
  },
  async ({ repo, labels }) => {
    const headers: Record<string, string> = {
      Accept: "application/vnd.github.v3+json",
    };
    const token = process.env.GITHUB_TOKEN;
    if (token) {
      headers["Authorization"] = `Bearer ${token}`;
    }
 
    let url = `https://api.github.com/repos/${repo}/issues?state=open&per_page=20`;
    if (labels) {
      url += `&labels=${encodeURIComponent(labels)}`;
    }
 
    const response = await fetch(url, { headers });
    if (!response.ok) {
      return {
        content: [
          { type: "text", text: `GitHub APIエラー: ${response.status}` },
        ],
      };
    }
 
    const issues = await response.json();
    const summary = issues
      .map(
        (issue: any) =>
          `#${issue.number}: ${issue.title} [${issue.labels.map((l: any) => l.name).join(", ")}]`
      )
      .join("\n");
 
    return {
      content: [
        {
          type: "text",
          text: `未完了Issue（${issues.length}件）:\n${summary}`,
        },
      ],
    };
  }
);
 
// Slack にメッセージを送信
server.tool(
  "send_slack_message",
  "Slackチャンネルにメッセージを送信します",
  {
    channel: z.string().describe("チャンネルID"),
    message: z.string().describe("送信するメッセージ"),
  },
  async ({ channel, message }) => {
    const token = process.env.SLACK_BOT_TOKEN;
    if (!token) {
      return {
        content: [
          { type: "text", text: "エラー: SLACK_BOT_TOKEN が未設定です" },
        ],
      };
    }
 
    const response = await fetch("https://slack.com/api/chat.postMessage", {
      method: "POST",
      headers: {
        Authorization: `Bearer ${token}`,
        "Content-Type": "application/json",
      },
      body: JSON.stringify({ channel, text: message }),
    });
 
    const data = await response.json();
    if (!data.ok) {
      return {
        content: [
          { type: "text", text: `Slackエラー: ${data.error}` },
        ],
      };
    }
 
    return {
      content: [{ type: "text", text: "メッセージを送信しました" }],
    };
  }
);
 
const transport = new StdioServerTransport();
await server.connect(transport);

// src/rate-limiter.ts
class RateLimiter {
  private timestamps: number[] = [];
  private maxRequests: number;
  private windowMs: number;
 
  constructor(maxRequests: number, windowMs: number) {
    this.maxRequests = maxRequests;
    this.windowMs = windowMs;
  }
 
  async waitIfNeeded(): Promise<void> {
    const now = Date.now();
    // ウィンドウ外のタイムスタンプを除去
    this.timestamps = this.timestamps.filter(
      (t) => now - t < this.windowMs
    );
 
    if (this.timestamps.length >= this.maxRequests) {
      const oldestInWindow = this.timestamps[0];
      const waitTime = this.windowMs - (now - oldestInWindow) + 100;
      await new Promise((resolve) => setTimeout(resolve, waitTime));
    }
 
    this.timestamps.push(Date.now());
  }
}
 
// 使用例: 1分あたり最大60リクエスト
export const githubLimiter = new RateLimiter(60, 60_000);
// ツール内で使用: await githubLimiter.waitIfNeeded();

// src/auth.ts
function getRequiredEnv(key: string): string {
  const value = process.env[key];
  if (!value) {
    throw new Error(
      `必須環境変数 ${key} が設定されていません。` +
        `Antigravity の MCP 設定で env に追加してください。`
    );
  }
  return value;
}
 
// トークンのリフレッシュ対応
class TokenManager {
  private token: string;
  private refreshToken: string;
  private expiresAt: number = 0;
 
  constructor() {
    this.token = getRequiredEnv("API_ACCESS_TOKEN");
    this.refreshToken = getRequiredEnv("API_REFRESH_TOKEN");
  }
 
  async getValidToken(): Promise<string> {
    if (Date.now() < this.expiresAt - 60_000) {
      return this.token;
    }
 
    // トークンをリフレッシュ
    const response = await fetch("https://api.example.com/oauth/token", {
      method: "POST",
      headers: { "Content-Type": "application/json" },
      body: JSON.stringify({
        grant_type: "refresh_token",
        refresh_token: this.refreshToken,
      }),
    });
 
    const data = await response.json();
    this.token = data.access_token;
    this.expiresAt = Date.now() + data.expires_in * 1000;
    return this.token;
  }
}

// src/error-handler.ts
type ApiResult<T> = { success: true; data: T } | { success: false; error: string };
 
async function safeApiCall<T>(
  fn: () => Promise<T>,
  context: string
): Promise<ApiResult<T>> {
  try {
    const data = await fn();
    return { success: true, data };
  } catch (error) {
    if (error instanceof TypeError && error.message.includes("fetch")) {
      return { success: false, error: `${context}: ネットワーク接続エラー` };
    }
    return {
      success: false,
      error: `${context}: ${error instanceof Error ? error.message : "不明なエラー"}`,
    };
  }
}
 
// ツール内での使用例
// const result = await safeApiCall(
//   () => fetch(url).then(r => r.json()),
//   "GitHub Issues取得"
// );

# MCP Inspector をインストール
npx @modelcontextprotocol/inspector
 
# サーバーを指定して起動
npx @modelcontextprotocol/inspector npx tsx src/index.ts