Claude API × MCP で構築する有料コンサルティング SaaS の実装

// mcp-server.js (Node.js)
const Anthropic = require("@anthropic-ai/sdk");
 
const server = {
  name: "sales-consultant-mcp",
  version: "1.0.0",
  tools: [
    {
      name: "get_sales_pipeline",
      description: "クライアント企業の営業パイプライン（見込み客、進捗、金額）を取得",
      inputSchema: {
        type: "object",
        properties: {
          months: {
            type: "number",
            description: "過去N ヶ月のデータを取得"
          }
        }
      }
    },
    {
      name: "get_customer_feedback",
      description: "失注理由・顧客フィードバック（テキスト分析済み）を取得",
      inputSchema: {
        type: "object",
        properties: {
          limit: { type: "number", description: "最大取得件数" }
        }
      }
    },
    {
      name: "get_rep_performance",
      description: "営業担当者別パフォーマンス（成約率・平均契約金）を取得",
      inputSchema: { type: "object", properties: {} }
    }
  ]
};
 
// 実装例: get_sales_pipeline
const handlers = {
  get_sales_pipeline: async (params) => {
    // クライアント企業の CRM に接続（認証は OAuth）
    const response = await clientCRM.query(`
      SELECT stage, COUNT(*), SUM(value) 
      FROM opportunities 
      WHERE created_at > DATE_SUB(NOW(), INTERVAL ${params.months} MONTH)
      GROUP BY stage
    `);
    
    // 結果は構造化フォーマット（CSV）で返す
    return JSON.stringify(response);
  }
};
 
module.exports = { server, handlers };

// 認証ミドルウェア例
const authenticateMCP = (req) => {
  const clientId = req.headers["x-client-id"];
  const clientSecret = req.headers["x-client-secret"];
  
  // D1 KV から認証情報を取得
  const auth = KV.get(`auth:${clientId}`);
  if (!auth || !verifySecret(auth, clientSecret)) {
    throw new Error("Unauthorized");
  }
  
  // 使用量チェック
  const usage = KV.get(`usage:${clientId}:${Date.now() / (3600 * 1000)}`);
  if (usage > 100) {
    throw new Error("Rate limit exceeded");
  }
  
  return clientId;
};

// Claude API 呼び出し時にトークン消費を記録
const callClaude = async (clientId, userMessage) => {
  const response = await anthropic.messages.create({
    model: "claude-opus",
    max_tokens: 1024,
    messages: [{ role: "user", content: userMessage }]
  });
  
  const tokensUsed = response.usage.input_tokens + response.usage.output_tokens;
  
  // トークン消費をログに記録
  await logTokenUsage(clientId, tokensUsed);
  
  // 月間使用量がプランの上限を超えたか確認
  const monthlyUsage = await getMonthlyTokens(clientId);
  if (monthlyUsage > getPlanLimit(clientId)) {
    // Stripe の Usage Record を送信（追加請求）
    await stripe.billing.meterEvents.create({
      event_name: "token_usage",
      customer: clientId,
      value: tokensUsed,
      timestamp: Math.floor(Date.now() / 1000)
    });
  }
  
  return response;
};

// セットアップウィザード
const setupWizard = {
  step1: "CRM を選択（Salesforce / HubSpot / Pipedrive）",
  step2: "OAuth で認証（クライアント企業のデータベース）",
  step3: "データ取得テスト（「過去 3 ヶ月の営業データを読み込みました」と確認）"
};
 
// 自動テスト: Claude が「営業パイプラインの簡単な診断」を実施
const diagnoseOnboarding = async (clientId) => {
  const pipelineData = await mcp.getPipeline(clientId);
  
  const diagnosis = await anthropic.messages.create({
    model: "claude-opus",
    messages: [{
      role: "user",
      content: `
        このパイプラインデータを見て、改善機会を3つ提案してください:
        ${JSON.stringify(pipelineData)}
      `
    }]
  });
  
  // 結果をメールで自動送信
  await sendEmail(clientId, {
    subject: "セットアップ完了。あなたの営業データの初期診断",
    body: diagnosis.content[0].text
  });
};

// 週1回「営業レポート自動生成」を送付
const weeklyReport = async (clientId) => {
  const weekData = await mcp.getWeeklyData(clientId);
  
  const report = await anthropic.messages.create({
    model: "claude-opus",
    messages: [{
      role: "user",
      content: `
        先週の営業データを分析して、以下を含むマネージャー向けレポートを作成:
        1. 成約率の前週比
        2. 課題が見えている案件3つ（改善案付き）
        3. 来週のアクション 3 つ
        
        データ: ${JSON.stringify(weekData)}
      `
    }]
  });
  
  // Slack / メールで自動配信
  await notifyClient(clientId, report.content[0].text);
};

// ユーザーの利用パターンを監視
const trackEngagement = async (clientId) => {
  const usage = await getMonthlyUsage(clientId);
  
  if (usage < 100) {
    // 未利用顧客へのリエンゲージメント
    await sendReminder(clientId, {
      subject: "営業戦略の実例: XX社が失注率を下げた方法",
      body: "このツールは個別の案件相談にも対応しています。試しに…"
    });
  } else if (usage > 500) {
    // アクティブユーザーを Pro にアップセル
    await suggestUpgrade(clientId, {
      message: "月額トークン上限に近づいています。Pro プランへの移行で…"
    });
  }
};

// 30日ぶりに利用再開したユーザーは高い解約リスク
const detectChurnRisk = async () => {
  const inactiveUsers = await getInactiveUsers(30);
  
  for (const clientId of inactiveUsers) {
    // Claude に「このユーザーが困っていそうなことは？」を聞く
    const churnAnalysis = await anthropic.messages.create({
      model: "claude-opus",
      messages: [{
        role: "user",
        content: `
          このクライアントは営業コンサル SaaS の未利用状態です。
          考えられる理由 3 つと、それぞれへの対応を提案してください:
          - 利用方法が分からない
          - 期待した結果が得られていない
          - 他のツールに乗り換えた
        `
      }]
    });
    
    // リエンゲージメント施策を送付
    const messages = parseChurnAnalysis(churnAnalysis);
    for (const msg of messages) {
      await sendPersonalizedEmail(clientId, msg);
    }
  }
};

// リトライロジック + キャッシング
const callClaudeWithRetry = async (prompt, clientId, cacheKey) => {
  // キャッシュをまず確認
  const cached = await KV.get(`cache:${cacheKey}`);
  if (cached) return cached;
  
  // リトライ最大 3 回（exponential backoff）
  for (let attempt = 0; attempt < 3; attempt++) {
    try {
      const response = await Promise.race([
        anthropic.messages.create({
          model: "claude-opus",
          messages: [{ role: "user", content: prompt }]
        }),
        delay(20000) // タイムアウト 20 秒
      ]);
      
      // キャッシュに保存（TTL 3 時間）
      await KV.put(`cache:${cacheKey}`, response, { expirationTtl: 10800 });
      return response;
    } catch (error) {
      if (attempt < 2) {
        await delay(Math.pow(2, attempt) * 1000);
        continue;
      }
      throw error;
    }
  }
};

// データは段階的に取得する（サマリー→詳細）
const smartDataFetch = async (clientId, params) => {
  // Phase 1: 概要を取得（< 100KB）
  const summary = await mcp.getPipelineSummary(clientId, params.months);
  
  // Phase 2: Claude が「詳しく見たい」箇所を特定
  const focus = await anthropic.messages.create({
    model: "claude-opus",
    messages: [{
      role: "user",
      content: `この概要から、詳しく分析すべき3つの領域を特定してください:\n${summary}`
    }]
  });
  
  // Phase 3: 指定領域のデータのみ詳細取得
  const focusAreas = extractFocusAreas(focus);
  const detailedData = await Promise.all(
    focusAreas.map(area => mcp.getDetailedData(clientId, area))
  );
  
  // Phase 4: 詳細分析
  return await anthropic.messages.create({
    model: "claude-opus",
    messages: [{
      role: "user",
      content: `詳細データに基づいて、営業戦略を提案:\n${JSON.stringify(detailedData)}`
    }]
  });
};

// リアルタイム異常検知
const monitorUsage = async () => {
  const clients = await getAllClients();
  
  for (const clientId of clients) {
    const hourlyUsage = await getHourlyTokens(clientId);
    const baseline = await getMonthlyAverage(clientId);
    
    // 通常の 3 倍を超えたら即ブロック
    if (hourlyUsage > baseline / 30 * 3) {
      // 顧客に確認メール
      await sendAlert(clientId, {
        subject: "異常な API 使用を検出",
        body: "確認: 今が正常な使用ですか？'確認'を押してください"
      });
      
      // 返答がなければ API キーを自動無効化（30分後）
      setTimeout(async () => {
        if (!await getConfirmation(clientId)) {
          await disableAPIKey(clientId);
          await processRefund(clientId);
        }
      }, 30 * 60 * 1000);
    }
  }
};
 
// 月額 + 従量課金のハイブリッド上限設定
const setCostCap = async (clientId) => {
  const plan = getPlan(clientId);
  const costCap = plan.monthly_fee * 3; // 月額料金の 3 倍までに制限
  
  // Stripe で cost limit を設定
  await stripe.billing.meterEvents.create({
    event_name: "token_usage",
    customer: clientId,
    value: 0, // 初期化
    timestamp: Math.floor(Date.now() / 1000)
  });
};