const assistantConfig = {
  model: {
    provider: "openai",
    model: "gpt-4",
    temperature: 0.7,
    systemPrompt: "You are an eCommerce sales assistant. When customers ask about products, use the getProductRecommendations function. Always capture: product interest, budget range, and purchase intent score (1-10). End calls by asking for email to send cart link."
  },
  voice: {
    provider: "11labs",
    voiceId: "rachel",
    stability: 0.5,
    similarityBoost: 0.8
  },
  transcriber: {
    provider: "deepgram",
    model: "nova-2",
    language: "en"
  },
  functions: [
    {
      name: "getProductRecommendations",
      description: "Fetch product recommendations based on customer preferences",
      parameters: {
        type: "object",
        properties: {
          category: { type: "string" },
          priceRange: { type: "string" },
          preferences: { type: "array", items: { type: "string" } }
        },
        required: ["category"]
      }
    },
    {
      name: "captureLeadData",
      description: "Store customer contact and purchase intent",
      parameters: {
        type: "object",
        properties: {
          email: { type: "string" },
          phone: { type: "string" },
          intentScore: { type: "number" },
          interestedProducts: { type: "array" }
        },
        required: ["email", "intentScore"]
      }
    }
  ],
  recordingEnabled: true,
  endCallFunctionEnabled: true
};

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

app.use(express.json());

// Validate VAPI webhook signature
function validateWebhook(req) {
  const signature = req.headers['x-vapi-signature'];
  const payload = JSON.stringify(req.body);
  const hash = crypto
    .createHmac('sha256', process.env.VAPI_SERVER_SECRET)
    .update(payload)
    .digest('hex');
  return signature === hash;
}

app.post('/webhook/vapi', async (req, res) => {
  if (!validateWebhook(req)) {
    return res.status(401).send('Invalid signature');
  }

  const { type, call, transcript, functionCall } = req.body;

  // Revenue-critical events
  if (type === 'function-call') {
    if (functionCall.name === 'getProductRecommendations') {
      // Log product interest for retargeting
      await logProductInterest(call.id, functionCall.parameters);
      
      // Return actual product data
      const products = await fetchFromInventory(functionCall.parameters);
      return res.json({ result: products });
    }
    
    if (functionCall.name === 'captureLeadData') {
      // This is your money shot
      const leadData = {
        email: functionCall.parameters.email,
        phone: call.customer.number,
        intentScore: functionCall.parameters.intentScore,
        products: functionCall.parameters.interestedProducts,
        callDuration: call.duration,
        timestamp: new Date()
      };
      
      await pushToCRM(leadData);
      
      // High-intent leads trigger immediate action
      if (leadData.intentScore >= 8) {
        await sendToSalesTeam(leadData);
      }
      
      return res.json({ result: "Lead captured" });
    }
  }

  if (type === 'end-of-call-report') {
    // Calculate call ROI
    const callCost = (call.duration / 60) * 0.12; // $0.12/min
    const estimatedValue = calculateLeadValue(transcript, call.metadata);
    
    await logCallMetrics({
      callId: call.id,
      cost: callCost,
      estimatedValue: estimatedValue,
      roi: ((estimatedValue - callCost) / callCost * 100).toFixed(2)
    });
  }

  res.sendStatus(200);
});

app.listen(3000);

graph LR
    A[Phone Call Initiation]
    B[Audio Capture]
    C[Noise Reduction]
    D[Voice Activity Detection]
    E[Speech-to-Text]
    F[Intent Recognition]
    G[Response Generation]
    H[Text-to-Speech]
    I[Audio Playback]
    J[Error Handling]
    K[API Integration]

    A-->B
    B-->C
    C-->D
    D-->E
    E-->F
    F-->G
    G-->H
    H-->I
    E-->|Error in STT|J
    F-->|Unrecognized Intent|J
    J-->K
    K-->G

// Test assistant configuration before going live
const testAssistant = {
  model: { provider: "openai", model: "gpt-4" },
  voice: { provider: "11labs", voiceId: "21m00Tcm4TlvDq8ikWAM" },
  transcriber: { provider: "deepgram", language: "en" },
  functions: [{
    name: "processOrder",
    parameters: {
      type: "object",
      properties: {
        items: { type: "array" },
        email: { type: "string" }
      },
      required: ["items", "email"]
    }
  }]
};

// Validate config structure
if (!testAssistant.functions[0].parameters.required.includes("email")) {
  throw new Error("Missing required email field - order processing will fail");
}

// Validate VAPI webhook signatures (production requirement)
function validateWebhook(req) {
  const signature = req.headers['x-vapi-signature'];
  const payload = JSON.stringify(req.body);
  const hash = crypto
    .createHmac('sha256', process.env.VAPI_SERVER_SECRET)
    .update(payload)
    .digest('hex');
  
  if (signature !== hash) {
    throw new Error('Invalid webhook signature - potential security breach');
  }
  return true;
}

app.post('/webhook/vapi', (req, res) => { // YOUR server receives webhooks here
  try {
    validateWebhook(req);
    const { type, call } = req.body;
    
    if (type === 'function-call' && call.function.name === 'processOrder') {
      const { items, email } = call.function.parameters;
      // Process order, calculate revenue
      const callCost = 0.15; // $0.15 per minute
      const estimatedValue = items.reduce((sum, item) => sum + item.price, 0);
      console.log(`Revenue: $${estimatedValue}, Cost: $${callCost}`);
    }
    
    res.json({ success: true });
  } catch (error) {
    console.error('Webhook validation failed:', error);
    res.status(401).json({ error: 'Unauthorized' });
  }
});

curl -X POST https://your-ngrok-url.ngrok.io/webhook/vapi \
  -H "Content-Type: application/json" \
  -H "x-vapi-signature: YOUR_TEST_SIGNATURE" \
  -d '{"type":"function-call","call":{"function":{"name":"processOrder","parameters":{"items":[{"price":49.99}],"email":"test@example.com"}}}}'

// Handle barge-in during product pitch
app.post('/webhook/vapi', (req, res) => {
  const { message } = req.body;
  
  if (message.type === 'speech-update') {
    const { role, transcript, isFinal } = message.speech;
    
    // User interruption detected mid-agent-response
    if (role === 'user' && !isFinal) {
      console.log(`[BARGE-IN] Partial: "${transcript}"`);
      
      // Cancel TTS buffer immediately
      if (transcript.length > 15) { // Threshold: 15 chars = real intent
        // Signal agent to stop current response
        return res.json({
          action: 'interrupt',
          newContext: `User interrupted. Budget constraint: ${transcript}`
        });
      }
    }
    
    if (isFinal && role === 'user') {
      // Process complete user input
      const budgetMatch = transcript.match(/under \$?(\d+)/i);
      if (budgetMatch) {
        const maxBudget = parseInt(budgetMatch[1]);
        // Update session with new constraint
        products.filter(p => p.price <= maxBudget);
      }
    }
  }
  
  res.sendStatus(200);
});

// Production-grade function call handler with queue
const callQueue = new Map();

app.post('/webhook/vapi', async (req, res) => {
  const { call, message } = req.body;
  
  // Prevent concurrent function calls for same session
  if (callQueue.has(call.id)) {
    return res.status(429).json({ error: 'Call in progress' });
  }
  
  callQueue.set(call.id, Date.now());
  
  try {
    if (message.type === 'function-call') {
      const { name, parameters } = message.functionCall;
      
      if (name === 'checkInventory') {
        const stock = await db.query(
          'SELECT quantity FROM inventory WHERE sku = $1 FOR UPDATE',
          [parameters.sku]
        );
        
        return res.json({
          result: {
            available: stock.rows[0]?.quantity > 0,
            quantity: stock.rows[0]?.quantity || 0
          }
        });
      }
    }
  } finally {
    callQueue.delete(call.id);
  }
});

// server.js - Production eCommerce Voice Agent
const express = require('express');
const crypto = require('crypto');
const app = express();

app.use(express.json());

// Assistant configuration with product recommendation logic
const assistantConfig = {
  model: {
    provider: "openai",
    model: "gpt-4",
    temperature: 0.7,
    systemPrompt: `You are a sales assistant for an eCommerce store. Qualify leads by asking:
    1. Budget range (under $500, $500-$2000, over $2000)
    2. Product category interest (electronics, home, fashion)
    3. Purchase timeline (immediate, this month, researching)
    
    Use the checkInventory function to verify stock before recommending products.
    Capture email and phone for follow-up. Be conversational but efficient.`
  },
  voice: {
    provider: "11labs",
    voiceId: "21m00Tcm4TlvDq8ikWAM",
    stability: 0.5,
    similarityBoost: 0.8
  },
  transcriber: {
    provider: "deepgram",
    model: "nova-2",
    language: "en"
  },
  functions: [
    {
      name: "checkInventory",
      description: "Check product availability and pricing",
      parameters: {
        type: "object",
        properties: {
          category: { type: "string" },
          priceRange: { type: "string" }
        },
        required: ["category"]
      }
    },
    {
      name: "captureLeadData",
      description: "Store qualified lead information",
      parameters: {
        type: "object",
        properties: {
          email: { type: "string" },
          phone: { type: "string" },
          preferences: { type: "object" }
        },
        required: ["email"]
      }
    }
  ]
};

// Webhook signature validation - prevents replay attacks
function validateWebhook(req) {
  const signature = req.headers['x-vapi-signature'];
  const payload = JSON.stringify(req.body);
  const hash = crypto
    .createHmac('sha256', process.env.VAPI_SERVER_SECRET)
    .update(payload)
    .digest('hex');
  return signature === hash;
}

// Product inventory mock - replace with real database
const products = {
  electronics: [
    { name: "Wireless Headphones", price: 299, stock: 15 },
    { name: "Smart Watch", price: 449, stock: 8 }
  ],
  home: [
    { name: "Robot Vacuum", price: 599, stock: 12 },
    { name: "Air Purifier", price: 349, stock: 20 }
  ]
};

// Revenue tracking state
const leadData = {
  qualified: [],
  callCost: 0.05, // $0.05 per minute average
  estimatedValue: 0
};

// Function call handler - executes during conversation
app.post('/webhook/function-call', async (req, res) => {
  if (!validateWebhook(req)) {
    return res.status(401).json({ error: 'Invalid signature' });
  }

  const { functionCall, call } = req.body.message;

  if (functionCall.name === 'checkInventory') {
    const { category, priceRange } = functionCall.parameters;
    const items = products[category] || [];
    const budgetMatch = priceRange ? 
      items.filter(p => {
        const maxBudget = parseInt(priceRange.split('-')[1]) || 10000;
        return p.price <= maxBudget && p.stock > 0;
      }) : items;

    return res.json({
      result: {
        available: budgetMatch.length > 0,
        items: budgetMatch.slice(0, 3),
        message: budgetMatch.length > 0 ? 
          `Found ${budgetMatch.length} products in stock` :
          'No matching products available'
      }
    });
  }

  if (functionCall.name === 'captureLeadData') {
    const lead = {
      ...functionCall.parameters,
      callId: call.id,
      timestamp: Date.now(),
      intentScore: 0.8 // Calculate based on conversation analysis
    };
    
    leadData.qualified.push(lead);
    leadData.estimatedValue += 450; // Average order value

    // Trigger Twilio SMS follow-up (async)
    sendFollowUpSMS(lead).catch(console.error);

    return res.json({
      result: {
        success: true,
        message: 'Lead captured. Sending product recommendations via SMS.'
      }
    });
  }

  res.status(400).json({ error: 'Unknown function' });
});

// Call analytics webhook - tracks revenue metrics
app.post('/webhook/call-ended', async (req, res) => {
  if (!validateWebhook(req)) {
    return res.status(401).json({ error: 'Invalid signature' });
  }

  const { call } = req.body;
  const durationMinutes = call.duration / 60;
  const callCost = durationMinutes * leadData.callCost;

  // Calculate ROI: (Estimated Revenue - Call Cost) / Call Cost
  const roi = leadData.estimatedValue > 0 ? 
    ((leadData.estimatedValue - callCost) / callCost * 100).toFixed(2) : 0;

  console.log(`Call Analytics:
    Duration: ${durationMinutes.toFixed(2)} min
    Cost: $${callCost.toFixed(2)}
    Qualified Leads: ${leadData.qualified.length}
    Estimated Revenue: $${leadData.estimatedValue}
    ROI: ${roi}%
  `);

  res.sendStatus(200);
});

// Twilio SMS integration for follow-up
async function sendFollowUpSMS(lead) {
  const response = await fetch('https://api.twilio.com/2010-04-01/Accounts/' + process.env.TWILIO_ACCOUNT_SID + '/Messages.json', {
    method: 'POST',
    headers: {
      'Authorization': 'Basic ' + Buffer.from(process.env.TWILIO_ACCOUNT_SID + ':' + process.env.TWILIO_AUTH_TOKEN).toString('base64'),
      'Content-Type': 'application/x-www-form-urlencoded'
    },
    body: new URLSearchParams({
      To: lead.phone,
      From: process.env.TWILIO_PHONE_NUMBER,
      Body: `Hi! Based on our call, here are products you might like: ${lead.preferences.interestedProducts?.join(', ')}. Reply YES to schedule a demo.`
    })
  });

  if (!response.ok) {
    throw new Error(`Twilio SMS failed: ${response.status}`);
  }
}

app.listen(3000, () => console.log('eCommerce Voice Agent running on port 3000'));

npm install express
export VAPI_API_KEY="your_vapi_key"
export VAPI_SERVER_SECRET="your_webhook_secret"
export TWILIO_ACCOUNT_SID="your_twilio_sid"
export TWILIO_AUTH_TOKEN="your_twilio_token"
export TWILIO_PHONE_NUMBER="+1234567890"

# Start server
node server.js

# In another terminal, expose webh

## FAQ

## Technical Questions

**How does VAPI handle product catalog queries in real-time?**

VAPI uses function calling to query your inventory API during conversations. When a customer asks "Do you have wireless headphones under $100?", the assistant triggers a function with parameters like `category: "electronics"` and `priceRange: { max: 100 }`. Your server returns matching products, and VAPI synthesizes a natural response. Latency is typically 200-400ms for simple queries. For catalogs over 10k SKUs, implement server-side caching to avoid database bottlenecks.

**Can I use VAPI with existing CRM systems like Salesforce?**

Yes. VAPI's webhook system sends `lead.captured` events with structured data (`email`, `phone`, `interestedProducts`). Your server receives these payloads and pushes to Salesforce via their REST API. The key is mapping VAPI's `leadData` object to Salesforce's Lead schema. Most implementations use a middleware layer (Node.js + Express) to transform payloads before CRM ingestion. Expect 500-800ms end-to-end latency for CRM writes.

**What's the difference between VAPI's native function calling and custom webhooks?**

Function calling is synchronous—VAPI waits for your server's response before continuing the conversation. Use this for product lookups or inventory checks. Webhooks are asynchronous—VAPI fires events like `call.ended` without blocking. Use webhooks for post-call analytics, CRM updates, or SMS follow-ups. Don't mix responsibilities: if you configure `functions` in `assistantConfig`, don't also build manual API polling logic.

## Performance

**How do I reduce latency for high-traffic eCommerce calls?**

Three critical optimizations: (1) Use connection pooling for database queries—don't open new connections per function call. (2) Cache product data in Redis with 5-minute TTL to avoid repeated DB hits. (3) Enable VAPI's `transcriber.endpointing` with a 300ms threshold to reduce silence detection lag. For Black Friday-level traffic (1000+ concurrent calls), deploy your webhook server across multiple regions and use a load balancer. Expect baseline latency of 150-250ms for function responses.

**What's the cost breakdown for 1000 calls per month?**

VAPI charges ~$0.05/minute for voice synthesis (ElevenLabs) + $0.02/minute for transcription (Deepgram). Average eCommerce call is 3-4 minutes, so ~$0.21-$0.28 per call. For 1000 calls: $210-$280/month. Add Twilio costs if using phone numbers (~$0.013/minute inbound). Total: ~$350-$450/month. ROI depends on conversion rate—if 10% of calls convert at $200 AOV, you generate $20k revenue against $400 cost.

## Platform Comparison

**Why use VAPI instead of building a custom Twilio + OpenAI integration?**

VAPI abstracts the complexity of streaming audio, barge-in handling, and function orchestration. Building this yourself requires managing WebSocket connections, audio buffer synchronization, and VAD (Voice Activity Detection) thresholds. VAPI's `transcriber.endpointing` handles interruptions natively—no need to write cancellation logic. Custom builds take 4-6 weeks; VAPI gets you live in 2-3 days. Trade-off: less control over audio pipeline internals.

**Can VAPI replace human sales reps for high-ticket items?**

Not entirely. VAPI excels at qualification (capturing `intentScore`, budget, timeline) and answering FAQs. For deals over $5k, use VAPI to pre-qualify leads, then route hot prospects to human reps via the `lead.qualified` webhook event. Hybrid approach: bot handles 80% of inbound volume, humans close the top 20%. Conversion rates drop 15-25% for fully automated high-ticket sales compared to human handoff.

## Resources

**VAPI**: Get Started with VAPI → [https://vapi.ai/?aff=misal](https://vapi.ai/?aff=misal)

**Official Documentation:**
- [VAPI API Reference](https://docs.vapi.ai) - Voice AI agents, function calling, webhook events
- [Twilio Voice API](https://www.twilio.com/docs/voice) - Programmable voice, call routing, SMS integration

**GitHub Examples:**
- [VAPI eCommerce Starter](https://github.com/VapiAI/server-side-example-node) - Node.js webhook handlers for conversational AI monetization
- [Twilio Voice Quickstart](https://github.com/twilio/voice-quickstart-js) - Client-side integration for AI phone agents

**Cost Calculators:**
- [VAPI Pricing](https://vapi.ai/pricing) - Per-minute rates for voicebots
- [Twilio Voice Pricing](https://www.twilio.com/voice/pricing) - Call costs by region

## References

1. https://docs.vapi.ai/quickstart/phone
2. https://docs.vapi.ai/quickstart/introduction
3. https://docs.vapi.ai/quickstart/web
4. https://docs.vapi.ai/observability/evals-quickstart
5. https://docs.vapi.ai/workflows/quickstart
6. https://docs.vapi.ai/assistants/quickstart
7. https://docs.vapi.ai/tools/custom-tools
8. https://docs.vapi.ai/server-url/developing-locally