Claude CodeとMCPサーバーでAI駆動のアクセス解析作ってみた

1
┌─────────────────┐
2
│  Claude Code    │ ← ユーザーの自然言語クエリ
3
└────────┬────────┘
4
         │ MCP Protocol (stdio)
5
         ▼
6
┌─────────────────┐
7
│  MCP Server     │
8
│  ├ Tool Handler │ ← ツール実行ロジック
9
│  ├ API Client   │ ← GA4/GSC API呼び出し
10
│  └ Auth Manager │ ← 認証管理
11
└────────┬────────┘
12
         │ API Requests
13
         ▼
14
┌─────────────────┐
15
│  GA4 / GSC API  │
1 collapsed line
16
└─────────────────┘

1
src/
2
├── mcp/                    # MCP関連コード
3
│   ├── server.ts          # MCPサーバーエントリポイント
4
│   ├── config.ts          # 設定管理
5
│   ├── tools/             # ツール定義
6
│   │   ├── analyze-comparison.ts    # 比較分析ツール
7
│   │   ├── analyze-exploratory.ts   # 探索的分析ツール
8
│   │   ├── check-config.ts          # 設定確認ツール
9
│   │   └── validate-config.ts       # 設定検証ツール
10
│   └── utils/
11
│       ├── validator.ts   # 入力検証（Zod）
12
│       └── error-handler.ts
13
├── application/           # アプリケーション層
14
│   ├── query-orchestrator.ts
15
│   └── insight-generator.ts
6 collapsed lines
16
├── infrastructure/        # インフラ層
17
│   ├── ga4-client.ts     # GA4 API クライアント
18
│   ├── gsc-client.ts     # GSC API クライアント
19
│   └── auth-manager.ts   # 認証管理
20
└── domain/               # ドメイン層
21
    └── models/           # ドメインモデル

1
import { z } from "zod";
2

3
export const AnalyzeComparisonInputSchema = z.object({
4
  query: z.string().min(1),
5
  options: z.object({
6
    verbose: z.boolean().default(false),
7
    compareType: z.string().optional(),
8
    propertyId: z.string().optional(),
9
  }).default({ verbose: false }),
10
});
11

12
export type AnalyzeComparisonInput = z.infer<typeof AnalyzeComparisonInputSchema>;

1
export function toMCPError(error: Error): MCPResponse<never> {
2
  return {
3
    success: false,
4
    error: {
5
      code: "INTERNAL_ERROR",
6
      message: error.message,
7
    },
8
  };
9
}

1
{
2
  "ga4-analyzer": {
3
    "command": "node",
4
    "args": [
5
      "/Users/username/path/to/ga4-analyzer/dist/mcp-server.js"
6
    ],
7
    "env": {
8
      "GA4_PROPERTY_ID": "318772207",
9
      "GA4_SERVICE_ACCOUNT_KEY": "/path/to/serviceaccount.json",
10
      "GA4_ENABLE_GSC": "true",
11
      "GA4_GSC_SITE_URL": "https://www.example.com",
12
      "GA4_MAX_RETRIES": "3",
13
      "GA4_REQUEST_TIMEOUT": "30000",
14
      "GA4_DATA_LIMIT": "100"
15
    }
2 collapsed lines
16
  }
17
}

1
{
2
  "name": "ga4-analyzer",
3
  "version": "0.1.0",
4
  "description": "GA4 + Google Search Console integrated access analysis MCP server",
5
  "author": "htada",
6
  "type": "mcp"
7
}

1
3/3のアクセス増の要因を教えて

1
【対象日: 2026-03-03 vs 比較日: 2026-03-02】
2

3
総アクセス数: 1,200 セッション（前日比 +20.0%、+200 セッション）
4

5
【主な増加要因】
6
■ 参照元/メディア
7
  1. google/organic: +200 セッション（+33.3%）★★★
8

9
■ ページ
10
  1. /blog/typescript-tips: +85 セッション（+42.0%）★★★
11
  2. /blog/astro-setup: +40 セッション（+18.0%）★★
12

13
【推察】
14
・Googleオーガニック検索の急増が主因。特定の記事への検索流入が増加した可能性。
15
・/blog/typescript-tips への流入が突出しており、SNSシェアまたは検索順位上昇が考えられる。

1
過去30日間で検索順位が上昇したページを表示して

1
【検索キーワード分析】期間: 2026-02-04 〜 2026-03-04
2

3
■ 検索順位が改善したページ TOP 5
4
  1. /blog/typescript-tips
5
     クリック数: 320（+85）、表示回数: 4,200（+1,100）
6
     平均順位: 4.2 → 2.8（+1.4ポジション改善）★★★
7

8
  2. /blog/astro-setup
9
     クリック数: 180（+42）、表示回数: 2,800（+600）
10
     平均順位: 8.5 → 6.1（+2.4ポジション改善）★★
11

12
  3. /blog/firebase-deploy
13
     クリック数: 95（+18）、表示回数: 1,500（+200）
14
     平均順位: 12.3 → 10.8（+1.5ポジション改善）★
15

3 collapsed lines
16
【推察】
17
・/blog/typescript-tips は上位表示が安定してきており、CTRも改善傾向。
18
・技術系コンテンツ全般で評価が上昇中。内部リンク強化が効いている可能性。

1
GA4の設定を確認して

1
{
2
  "success": true,
3
  "data": {
4
    "ga4PropertyId": "318772207",
5
    "enableGSC": true,
6
    "gscSiteUrl": "https://45395.jp",
7
    "maxRetries": 3,
8
    "requestTimeout": 30000,
9
    "dataLimit": 100,
10
    "serviceAccountKeyPath": "/path/to/serviceaccount.json",
11
    "status": {
12
      "ga4": "connected",
13
      "gsc": "connected"
14
    }
15
  }
1 collapsed line
16
}

1
export class AuthenticationManager {
2
  loadCredentials(config: {
3
    serviceAccountKeyPath?: string;
4
    useApplicationDefaultCredentials?: boolean;
5
  }): GoogleAuth {
6
    if (config.serviceAccountKeyPath) {
7
      // サービスアカウントキーファイルから読み込み
8
      const keyFile = JSON.parse(fs.readFileSync(config.serviceAccountKeyPath, 'utf-8'));
9
      return new GoogleAuth({
10
        credentials: keyFile,
11
        scopes: [
12
          'https://www.googleapis.com/auth/analytics.readonly',
13
          'https://www.googleapis.com/auth/webmasters.readonly',
14
        ],
15
      });
11 collapsed lines
16
    } else {
17
      // Application Default Credentialsを使用
18
      return new GoogleAuth({
19
        scopes: [
20
          'https://www.googleapis.com/auth/analytics.readonly',
21
          'https://www.googleapis.com/auth/webmasters.readonly',
22
        ],
23
      });
24
    }
25
  }
26
}

1
async function executeWithRetry<T>(
2
  fn: () => Promise<T>,
3
  maxRetries: number = 3,
4
  timeout: number = 30000,
5
): Promise<T> {
6
  let lastError: Error;
7

8
  for (let attempt = 0; attempt < maxRetries; attempt++) {
9
    try {
10
      return await Promise.race([
11
        fn(),
12
        new Promise<never>((_, reject) =>
13
          setTimeout(() => reject(new Error('Timeout')), timeout)
14
        ),
15
      ]);
10 collapsed lines
16
    } catch (error) {
17
      lastError = error as Error;
18
      if (attempt < maxRetries - 1) {
19
        await new Promise(resolve => setTimeout(resolve, 1000 * (attempt + 1)));
20
      }
21
    }
22
  }
23

24
  throw lastError!;
25
}

1
export function loadConfigFromEnv(): Partial<Configuration> {
2
  return {
3
    ga4PropertyId: process.env.GA4_PROPERTY_ID || '',
4
    serviceAccountKeyPath: process.env.GA4_SERVICE_ACCOUNT_KEY,
5
    enableGSC: process.env.GA4_ENABLE_GSC === 'true',
6
    gscSiteUrl: process.env.GA4_GSC_SITE_URL,
7
    maxRetries: parseInt(process.env.GA4_MAX_RETRIES || '3', 10),
8
    requestTimeout: parseInt(process.env.GA4_REQUEST_TIMEOUT || '30000', 10),
9
    dataLimit: parseInt(process.env.GA4_DATA_LIMIT || '100', 10),
10
  };
11
}

1
export interface ToolDefinition<TInput, TOutput> {
2
  name: string;
3
  description: string;
4
  inputSchema: z.ZodSchema<TInput>;
5
  handler: (input: TInput) => Promise<MCPResponse<TOutput>>;
6
}
7

8
export interface MCPResponse<T> {
9
  success: boolean;
10
  data?: T;
11
  error?: {
12
    code: string;
13
    message: string;
14
  };
15
}

1
class DataCache {
2
  private cache: Map<string, { data: any; timestamp: number }> = new Map();
3
  private ttl: number = 5 * 60 * 1000; // 5分
4

5
  get(key: string): any | null {
6
    const entry = this.cache.get(key);
7
    if (!entry) return null;
8

9
    if (Date.now() - entry.timestamp > this.ttl) {
10
      this.cache.delete(key);
11
      return null;
12
    }
13

14
    return entry.data;
15
  }
8 collapsed lines
16

17
  set(key: string, data: any): void {
18
    this.cache.set(key, {
19
      data,
20
      timestamp: Date.now(),
21
    });
22
  }
23
}

1
async function fetchMultipleDimensions(
2
  ga4Client: GA4ApiClient,
3
  dimensions: string[],
4
  dateRange: DateRange,
5
): Promise<Map<string, DimensionData>> {
6
  const results = await Promise.all(
7
    dimensions.map(dim =>
8
      ga4Client.runReport({
9
        dimensions: [{ name: dim }],
10
        metrics: [{ name: 'activeUsers' }],
11
        dateRanges: [dateRange],
12
      })
13
    )
14
  );
15

2 collapsed lines
16
  return new Map(dimensions.map((dim, i) => [dim, results[i]]));
17
}

1
export const QueryInputSchema = z.object({
2
  query: z.string().min(1).max(500),
3
  options: z.object({
4
    dateRange: z.object({
5
      start: z.string().regex(/^\d{4}-\d{2}-\d{2}$/),
6
      end: z.string().regex(/^\d{4}-\d{2}-\d{2}$/),
7
    }).optional(),
8
  }).optional(),
9
});

1
class RateLimiter {
2
  private requests: number[] = [];
3
  private limit: number = 10;
4
  private window: number = 60000; // 1分
5

6
  async checkLimit(): Promise<void> {
7
    const now = Date.now();
8
    this.requests = this.requests.filter(t => now - t < this.window);
9

10
    if (this.requests.length >= this.limit) {
11
      const oldestRequest = this.requests[0];
12
      const waitTime = this.window - (now - oldestRequest);
13
      await new Promise(resolve => setTimeout(resolve, waitTime));
14
    }
15

3 collapsed lines
16
    this.requests.push(now);
17
  }
18
}

1
// stdout: MCPプロトコル通信用
2
// stderr: デバッグログ用
3

4
console.error(`[MCP Server] Tool executed: ${toolName}`);
5
console.error(`[MCP Server] Input: ${JSON.stringify(input)}`);
6
console.error(`[MCP Server] Result: ${JSON.stringify(result)}`);

1
Error: Unable to authenticate with GA4 API

1
Error: Request timeout after 30000ms

1
Error: Cannot find module './dist/mcp-server.js'

1
export class RealtimeAnalyzer {
2
  async getCurrentVisitors(propertyId: string): Promise<number> {
3
    const response = await ga4Client.runRealtimeReport({
4
      property: `properties/${propertyId}`,
5
      metrics: [{ name: 'activeUsers' }],
6
    });
7

8
    return response.rows?.[0]?.metricValues?.[0]?.value || 0;
9
  }
10
}

1
export class AlertSystem {
2
  async checkAnomalies(metrics: Metrics): Promise<void> {
3
    if (metrics.activeUsers < metrics.baseline * 0.5) {
4
      await this.sendSlackNotification({
5
        message: 'Traffic dropped by 50%!',
6
        severity: 'high',
7
      });
8
    }
9
  }
10
}

1
export class ReportGenerator {
2
  generateMarkdownReport(analysis: AnalysisResult): string {
3
    return `
4
# アクセス解析レポート
5

6
## 期間比較
7

8
| 指標       | 前期                       | 今期                      | 変化率                  |
9
| ---------- | -------------------------- | ------------------------- | ----------------------- |
10
| ユーザー数 | ${analysis.previous.users} | ${analysis.current.users} | ${analysis.changeRate}% |
11

12
## トップページ
13

14
${analysis.topPages.map((page, i) => `${i + 1}. ${page.path} (${page.views} views)`).join('\n')}
15
    `;
2 collapsed lines
16
  }
17
}