Integrate Voice AI with Salesforce for Real Estate: My Implementation Journey

flowchart LR
    A[Inbound Call] --> B[VAPI Assistant]
    B --> C[Deepgram Transcription]
    C --> D[GPT-4 Extraction]
    D --> E{All Fields?}
    E -->|Yes| F[Function Call: create_lead]
    E -->|No| C
    F --> G[Webhook to Your Server]
    G --> H[Salesforce REST API]
    H --> I[Lead Created]
    I --> J[Confirm to Caller]

const express = require('express');
const crypto = require('crypto');
const app = express();

app.use(express.json());

const salesforceConfig = {
  clientId: process.env.SF_CLIENT_ID,
  clientSecret: process.env.SF_CLIENT_SECRET,
  redirectUri: process.env.SF_REDIRECT_URI,
  instanceUrl: process.env.SF_INSTANCE_URL,
  tokenEndpoint: 'https://login.salesforce.com/services/oauth2/token'
};

let accessToken = null;
let tokenTimestamp = Date.now();

async function ensureValidToken() {
  const tokenAge = Date.now() - tokenTimestamp;
  
  if (accessToken && tokenAge < 5400000) {
    return accessToken;
  }
  
  const response = await fetch(salesforceConfig.tokenEndpoint, {
    method: 'POST',
    headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
    body: new URLSearchParams({
      grant_type: 'refresh_token',
      refresh_token: process.env.SF_REFRESH_TOKEN,
      client_id: salesforceConfig.clientId,
      client_secret: salesforceConfig.clientSecret
    })
  });
  
  if (!response.ok) {
    throw new Error(`Token refresh failed: ${response.status}`);
  }
  
  const data = await response.json();
  accessToken = data.access_token;
  tokenTimestamp = Date.now();
  return accessToken;
}

const assistantConfig = {
  model: {
    provider: "openai",
    model: "gpt-4",
    messages: [{
      role: "system",
      content: "You are a real estate lead qualifier. Extract: firstName, lastName, phone, propertyType (house/condo/land), budget (number), location (string), timeline (immediate/1-3months/3-6months). Ask ONE question at a time. Only call create_lead when you have ALL 7 fields."
    }],
    tools: [{
      type: "function",
      function: {
        name: "create_lead",
        description: "Create Salesforce lead. Only call when ALL required fields collected.",
        parameters: {
          type: "object",
          properties: {
            firstName: { type: "string" },
            lastName: { type: "string" },
            phone: { type: "string" },
            propertyType: { type: "string", enum: ["house", "condo", "land"] },
            budget: { type: "number" },
            location: { type: "string" },
            timeline: { type: "string", enum: ["immediate", "1-3months", "3-6months"] }
          },
          required: ["firstName", "lastName", "phone", "propertyType", "budget", "location", "timeline"]
        }
      }
    }]
  },
  voice: {
    provider: "11labs",
    voiceId: "21m00Tcm4TlvDq8ikWAM"
  },
  transcriber: {
    provider: "deepgram",
    model: "nova-2",
    language: "en"
  },
  serverUrl: process.env.WEBHOOK_URL,
  serverUrlSecret: process.env.VAPI_SERVER_SECRET
};

const processingQueue = new Map();

app.post('/webhook/vapi', async (req, res) => {
  const payload = JSON.stringify(req.body);
  const signature = req.headers['x-vapi-signature'];
  
  const expectedSig = crypto
    .createHmac('sha256', process.env.VAPI_SERVER_SECRET)
    .update(payload)
    .digest('hex');
  
  if (signature !== expectedSig) {
    return res.status(401).json({ error: 'Invalid signature' });
  }
  
  const { message } = req.body;
  const callId = message.call?.id;
  
  if (processingQueue.has(callId)) {
    return res.status(202).json({ queued: true });
  }
  
  processingQueue.set(callId, true);
  
  try {
    if (message?.type === 'function-call' && message?.functionCall?.name === 'create_lead') {
      const params = message.functionCall.parameters;
      const token = await ensureValidToken();
      
      const sfResponse = await fetch(
        `${salesforceConfig.instanceUrl}/services/data/v58.0/sobjects/Lead`,
        {
          method: 'POST',
          headers: {
            'Authorization': `Bearer ${token}`,
            'Content-Type': 'application/json'
          },
          body: JSON.stringify({
            FirstName: params.firstName,
            LastName: params.lastName,
            Phone: params.phone,
            Company: 'Real Estate Lead',
            Property_Type__c: params.propertyType,
            Budget__c: params.budget,
            Location__c: params.location,
            Timeline__c: params.timeline,
            LeadSource: 'Voice AI'
          })
        }
      );
      
      if (!sfResponse.ok) {
        const error = await sfResponse.json();
        throw new Error(`Salesforce error: ${error[0]?.message}`);
      }
      
      const leadData = await sfResponse.json();
      
      return res.json({
        result: `Lead created successfully with ID ${leadData.id}. An agent will contact you within 24 hours.`
      });
    }
    
    res.sendStatus(200);
  } catch (error) {
    console.error('Lead creation failed:', error);
    res.json({
      result: "I encountered an issue saving your information. Let me transfer you to a live agent."
    });
  } finally {
    processingQueue.delete(callId);
  }
});

app.listen(3000, () => console.log('Webhook server running on port 3000'));

app.post('/webhook/vapi', async (req, res) => {
  const { message } = req.body;
  
  if (message.type === 'transcript' && message.transcriptType === 'partial') {
    const interruptDetected = message.transcript.length > 10 && message.role === 'user';
    
    if (interruptDetected) {
      await fetch(`https://api.vapi.ai/call/${message.call.id}/control`, {
        method: 'POST',
        headers: {
          'Authorization': `Bearer ${process.env.VAPI_API_KEY}`,
          'Content-Type': 'application/json'
        },
        body: JSON.stringify({
          action: 'interrupt',
          reason: 'user_barge_in'
        })
      });
      
      const token = await ensureValidToken();
      const leadData = {
        Id: message.call.metadata.salesforceLeadId,
        Interrupt_Count__c: (message.call.metadata.interruptCount || 0) + 1,
        Last_Interrupt_Text__c: message.transcript,
        Engagement_Score__c: 'High'
      };
      
      await fetch(
        `${salesforceConfig.instanceUrl}/services/data/v58.0/sobjects/Lead/${leadData.Id}`,
        {
          method: 'PATCH',
          headers: {
            'Authorization': `Bearer ${token}`,
            'Content-Type': 'application/json'
          },
          body: JSON.stringify(leadData)
        }
      );
    }
  }
  
  res.sendStatus(200);
});

const productionConfig = {
  model: {
    provider: "openai",
    model: "gpt-4",
    temperature: 0.3,
    messages: [{
      role: "system",
      content: "You are a real estate lead qualifier. Extract: firstName, lastName, phone, propertyType, budget, location, timeline. Ask ONE question at a time. Only call create_lead when you have ALL 7 fields."
    }],
    tools: [{
      type: "function",
      function: {
        name: "create_lead",
        description: "Create Salesforce lead with all required fields",
        parameters: {
          type: "object",
          properties: {
            firstName: { type: "string" },
            lastName: { type: "string" },
            phone: { type: "string" },
            propertyType: { type: "string", enum: ["house", "condo", "land"] },
            budget: { type: "number" },
            location: { type: "string" },
            timeline: { type: "string", enum: ["immediate", "1-3months", "3-6months"] }
          },
          required: ["firstName", "lastName", "phone", "propertyType", "budget", "location", "timeline"]
        }
      }
    }]
  },
  voice: {
    provider: "11labs",
    voiceId: "21m00Tcm4TlvDq8ikWAM",
    stability: 0.5,
    similarityBoost: 0.75
  },
  transcriber: {
    provider: "deepgram",
    model: "nova-2",
    language: "en",
    endpointing: {
      minSpeechDuration: 800,
      silenceDuration: 1200
    }
  },
  serverUrl: process.env.WEBHOOK_URL,
  serverUrlSecret: process.env.VAPI_SERVER_SECRET,
  silenceTimeoutSeconds: 30,
  maxDurationSeconds: 600,
  backgroundSound: "office"
};

# Start ngrok tunnel
ngrok http 3000
# Copy HTTPS URL (e.g., https://abc123.ngrok.io)

# Update assistant config
export WEBHOOK_URL="https://abc123.ngrok.io/webhook/vapi"

# Trigger test call
curl -X POST https://api.vapi.ai/call \
  -H "Authorization: Bearer $VAPI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "assistantId": "your-assistant-id",
    "customer": { "number": "+15551234567" }
  }'

curl -X GET \
  "${SF_INSTANCE_URL}/services/data/v58.0/sobjects/Lead/00Q5e00000AbCdEFG" \
  -H "Authorization: Bearer ${SF_ACCESS_TOKEN}"