Claude API × MCP: Building a Paid Consulting SaaS That Runs Without You

// 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: "Fetch client's sales pipeline (prospects, stage, value)",
      inputSchema: {
        type: "object",
        properties: {
          months: { type: "number", description: "Past N months" }
        }
      }
    },
    {
      name: "get_customer_feedback",
      description: "Fetch lost deal reasons and customer feedback (text-analyzed)",
      inputSchema: {
        type: "object",
        properties: {
          limit: { type: "number" }
        }
      }
    },
    {
      name: "get_rep_performance",
      description: "Fetch sales rep metrics (close rate, avg deal size)",
      inputSchema: { type: "object", properties: {} }
    }
  ]
};
 
// Implementation
const handlers = {
  get_sales_pipeline: async (params) => {
    // Connect to client's CRM (OAuth2 token from KV)
    const crmToken = await KV.get(`crm:token:${clientId}`);
    
    const response = await fetch("https://api.salesforce.com/services/data/v57.0/query", {
      headers: { Authorization: `Bearer ${crmToken}` },
      body: `q=SELECT StageName, COUNT(), SUM(Amount) FROM Opportunity 
             WHERE CreatedDate > LAST_N_MONTHS:${params.months} GROUP BY StageName`
    });
    
    return JSON.stringify(await response.json());
  }
};
 
module.exports = { server, handlers };

// Auth middleware
const authenticateMCP = (clientId, token) => {
  const auth = KV.get(`mcp:auth:${clientId}`);
  if (!verifyOAuth(auth, token)) throw new Error("Unauthorized");
  
  // Rate limit check (token bucket algorithm)
  const bucket = KV.get(`ratelimit:${clientId}`);
  if (bucket.tokens < 1) throw new Error("Rate limit");
  
  bucket.tokens -= 1;
  KV.put(`ratelimit:${clientId}`, bucket);
  
  return true;
};

// Log every Claude call
const callClaude = async (clientId, userMessage) => {
  const response = await anthropic.messages.create({
    model: "claude-opus",
    max_tokens: 1024,
    messages: [{ role: "user", content: userMessage }]
  });
  
  const inputTokens = response.usage.input_tokens;
  const outputTokens = response.usage.output_tokens;
  const totalTokens = inputTokens + outputTokens;
  
  // Record in KV for daily rollup
  await KV.put(`tokens:${clientId}:${new Date().toISOString().split('T')[0]}`, totalTokens);
  
  // Daily: Aggregate and send to Stripe
  const dailyTotal = await aggregateDailyTokens(clientId);
  
  // Stripe meters consumption
  await stripe.billing.meterEvents.create({
    event_name: "claude_tokens_used",
    customer: clientId,
    value: dailyTotal,
    timestamp: Math.floor(Date.now() / 1000)
  });
  
  return response;
};

// Automated onboarding
const setupWizard = {
  step1: "Select CRM (Salesforce/HubSpot/Pipedrive)",
  step2: "OAuth grant (client authorizes us to read their data)",
  step3: "Fetch test data & verify",
  step4: "Automated diagnosis & send results"
};
 
const autoOnboard = async (clientId) => {
  const pipelineData = await mcp.getPipeline(clientId);
  
  // Claude immediately diagnoses
  const diagnosis = await anthropic.messages.create({
    model: "claude-opus",
    messages: [{
      role: "user",
      content: `Analyze this pipeline. What's the biggest opportunity? 
        ${JSON.stringify(pipelineData)}`
    }]
  });
  
  // Email them the insight (not generic, but custom to *their* data)
  await sendEmail(clientId, {
    subject: "Your sales pipeline analysis is ready",
    body: diagnosis.content[0].text
  });
};

// Weekly automated email
const weeklyReport = async (clientId) => {
  const weekData = await mcp.getWeeklyStats(clientId);
  
  const report = await anthropic.messages.create({
    model: "claude-opus",
    messages: [{
      role: "user",
      content: `Create a manager's summary for this week's sales:
      - Deals won
      - Top risks (deals at risk of loss)
      - One tactical recommendation
      ${JSON.stringify(weekData)}`
    }]
  });
  
  // Send via Slack (better UX than email)
  await slack.chat.postMessage({
    channel: clientId,
    text: report.content[0].text,
    unfurl_links: false
  });
};

// Monitor for churn signals
const monitorEngagement = async () => {
  const clients = await getAllClients();
  
  for (const clientId of clients) {
    const usage = await getMonthlyUsage(clientId);
    const baseline = await getHistoricalAverage(clientId);
    
    // If usage dropped 50%, they're churning
    if (usage < baseline * 0.5) {
      // Send re-engagement email
      await sendEmail(clientId, {
        subject: "Sales opportunity you might have missed this month",
        body: "Here's a customer success story from someone using your industry…"
      });
    }
  }
};

const callClaudeResilient = async (prompt, clientId) => {
  // Check cache first (3-hour TTL)
  const cacheKey = hash(prompt, clientId);
  const cached = await KV.get(`cache:${cacheKey}`);
  if (cached) return cached;
  
  // Retry up to 3 times with 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(18000) // 18-second timeout
      ]);
      
      // Cache result
      await KV.put(`cache:${cacheKey}`, response, { 
        expirationTtl: 10800 
      });
      
      return response;
    } catch (e) {
      if (attempt === 2) throw e;
      await delay(Math.pow(2, attempt) * 1000);
    }
  }
};

const smartAnalysis = async (clientId, request) => {
  // Phase 1: Get executive summary (~50KB)
  const summary = await mcp.getPipelineSummary(clientId, 24);
  
  // Phase 2: Claude identifies what needs deep dive
  const deepDiveTopics = await anthropic.messages.create({
    model: "claude-opus",
    messages: [{
      role: "user",
      content: `From this 2-year summary, what 3 areas need detailed analysis?\n${summary}`
    }]
  });
  
  // Phase 3: Fetch only the relevant detailed data
  const topics = parseTopics(deepDiveTopics);
  const detailedData = await Promise.all(
    topics.map(t => mcp.getDetailedAnalysis(clientId, t))
  );
  
  // Phase 4: Comprehensive analysis
  return await anthropic.messages.create({
    model: "claude-opus",
    messages: [{
      role: "user",
      content: `Strategic recommendations based on this analysis:\n${JSON.stringify(detailedData)}`
    }]
  });
};

const monitorAnomalies = async () => {
  const clients = await getAllClients();
  
  for (const clientId of clients) {
    const hourlyUsage = await getHourlyTokens(clientId);
    const monthlyBaseline = await getMonthlyAverage(clientId);
    
    // If this hour > 3x daily average, flag it
    if (hourlyUsage > (monthlyBaseline / 30) * 3) {
      // Alert customer immediately
      await sendUrgentAlert(clientId, {
        subject: "Unusual API activity detected",
        body: "Confirm this is legitimate. Reply 'YES' within 30 minutes or we'll disable this key."
      });
      
      // Auto-disable after 30 min if no response
      setTimeout(async () => {
        const confirmed = await getConfirmation(clientId);
        if (!confirmed) {
          await disableAPIKey(clientId);
          await processPartialRefund(clientId); // Refund suspicious portion
        }
      }, 30 * 60 * 1000);
    }
  }
};