How to Test Multilingual and Contextual Memory for Intuitive Voice AI Agents

TL;DR

Most multilingual voice agents fail when context switches languages mid-conversation or memory bleeds between sessions. Build a test harness using VAPI's conversation buffer memory with language-aware vector store retrieval to validate short-term context retention across Spanish, Mandarin, and English. Integrate Twilio for call simulation. Measure latency (target: <200ms retrieval) and accuracy (target: >95% context recall). This prevents hallucinations and language-mixing bugs before production.

Prerequisites

API Keys & Credentials

You'll need a VAPI API key (generate from dashboard.vapi.ai) and a Twilio Account SID + Auth Token (from console.twilio.com). Store these in a .env file—never hardcode credentials.

System Requirements

Node.js 18+ with npm or yarn. A local development environment with ngrok or similar tunneling tool to expose your webhook endpoints (required for Twilio callbacks). Minimum 2GB RAM for running concurrent test sessions.

SDK Versions

Install @vapi-ai/server-sdk (v0.20+) and twilio (v4.0+). Verify compatibility: npm list @vapi-ai/server-sdk twilio.

Testing Infrastructure

A test database or in-memory store (Redis recommended) to track conversation state across multilingual sessions. Audio testing tools like ffmpeg or sox for generating test audio files in different languages. Postman or curl for manual webhook validation.

Knowledge Assumptions

Familiarity with REST APIs, async/await patterns, and webhook handling. Basic understanding of speech-to-text (STT) and text-to-speech (TTS) concepts. Experience with environment variables and secure credential management.

Twilio: Get Twilio Voice API → Get Twilio

Step-by-Step Tutorial

Configuration & Setup

Start by configuring your VAPI assistant with multilingual support and memory persistence. The critical piece most developers miss: memory context must be explicitly structured to survive turn transitions.

const assistantConfig = {
  model: {
    provider: "openai",
    model: "gpt-4",
    messages: [
      {
        role: "system",
        content: "You are a multilingual assistant. Maintain conversation context across languages. Store user preferences: language, timezone, previous requests. Reference past interactions explicitly."
      }
    ],
    temperature: 0.7
  },
  voice: {
    provider: "elevenlabs",
    voiceId: "multilingual-v2" // Supports language switching mid-conversation
  },
  transcriber: {
    provider: "deepgram",
    model: "nova-2",
    language: "multi" // Auto-detects language switches
  },
  recordingEnabled: true // CRITICAL for post-call analysis
};

Why this breaks in production: Default configs don't persist context between language switches. When a user says "Book a meeting" in English then switches to "¿A qué hora?" in Spanish, the assistant loses the booking intent. The system prompt MUST explicitly instruct context retention across languages.

Architecture & Flow

flowchart LR
    A[User speaks in Language A] --> B[VAPI Transcriber]
    B --> C[LLM with Memory Context]
    C --> D{Language Switch?}
    D -->|Yes| E[Update Context + Language Flag]
    D -->|No| F[Continue in Current Language]
    E --> G[TTS in New Language]
    F --> G
    G --> H[User Response]
    H --> B

The memory layer sits BETWEEN transcription and LLM processing. Each turn must inject previous context as message history, not rely on LLM's native memory (which resets on provider timeouts).

Testing Multi-Turn Contextual Memory

Real-world failure pattern: Assistant remembers context for 3-4 turns, then forgets the user's name or original request. This happens because conversation buffer memory isn't being validated per turn.

Create a 5-turn test flow that validates context persistence:

// Turn 1: Establish context in English
const turn1 = {
  user: "My name is Carlos and I need to book a flight to Tokyo",
  expectedContext: {
    userName: "Carlos",
    intent: "flight_booking",
    destination: "Tokyo"
  }
};

// Turn 2: Switch to Spanish mid-conversation
const turn2 = {
  user: "¿Cuánto cuesta el vuelo?", // "How much does the flight cost?"
  expectedBehavior: "Assistant responds in Spanish AND references Tokyo flight"
};

// Turn 3: Return to English with pronoun reference
const turn3 = {
  user: "Book it for next Monday",
  expectedBehavior: "Assistant knows 'it' refers to Tokyo flight, not a new request"
};

// Turn 4: Test memory recall
const turn4 = {
  user: "What was my destination again?",
  expectedResponse: "Tokyo" // MUST match turn 1 context
};

// Turn 5: Validate full context retention
const turn5 = {
  user: "Confirm the booking",
  expectedToolCall: {
    function: "bookFlight",
    parameters: {
      passenger: "Carlos", // From turn 1
      destination: "Tokyo", // From turn 1
      date: "next Monday" // From turn 3
    }
  }
};

Critical validation points:

• Turn 2: Language switch must NOT reset context. Check transcription logs for language detection accuracy.
• Turn 3: Pronoun resolution ("it") requires vector store retriever to fetch turn 1 context.
• Turn 4: Direct memory recall test. If assistant says "I don't recall", your conversation buffer memory is broken.
• Turn 5: Tool call parameters MUST aggregate data from turns 1, 3. Missing parameters = memory leak.

Testing Twilio Integration for Call Recording

Use Twilio's recording API to capture full conversations for post-call analysis:

// Note: Endpoint inferred from standard Twilio API patterns
const response = await fetch('https://api.twilio.com/2010-04-01/Accounts/' + process.env.TWILIO_ACCOUNT_SID + '/Calls.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({
    'Url': 'https://your-server.com/twiml/vapi-bridge', // YOUR server's TwiML endpoint
    'To': '+1234567890',
    'From': process.env.TWILIO_PHONE_NUMBER,
    'Record': 'true', // Enable recording for analysis
    'RecordingStatusCallback': 'https://your-server.com/webhook/recording' // YOUR server receives recording URL
  })
});

Why recording matters for memory testing: You need the raw audio to verify:

1. Language detection accuracy (did Deepgram catch the Spanish switch?)
2. Context handoff timing (how many ms between language switch and response?)
3. TTS language matching (did ElevenLabs respond in the correct language?)

Analyze recordings with speech recognition testing tools to measure context-aware response latency. Target: <800ms for same-language turns, <1200ms for language switches.

System Diagram

Audio processing pipeline from microphone input to speaker output.

graph LR
    Input[Microphone]
    Buffer[Audio Buffer]
    VAD[Voice Activity Detection]
    STT[Speech-to-Text]
    NLU[Intent Detection]
    LLM[Response Generation]
    TTS[Text-to-Speech]
    Output[Speaker]
    Error[Error Handling]
    Retry[Retry Logic]
    
    Input-->Buffer
    Buffer-->VAD
    VAD-->STT
    STT-->NLU
    NLU-->LLM
    LLM-->TTS
    TTS-->Output
    
    VAD-->|Silence Detected|Error
    STT-->|Recognition Error|Error
    NLU-->|Intent Not Found|Error
    
    Error-->|Attempt Recovery|Retry
    Retry-->|Retry Successful|VAD
    Retry-->|Retry Failed|Output

Testing & Validation

Most multilingual memory tests fail because developers validate single turns instead of conversation continuity. Here's how to catch memory leaks before production.

Local Testing with Multi-Turn Flows

Test context retention across language switches using the /chat endpoint. This validates that memory persists when users alternate between languages mid-conversation:

// Test multilingual context retention across 5 turns
const conversationTest = async () => {
  const turns = [
    { role: 'user', content: 'My name is Maria and I live in Madrid' },
    { role: 'user', content: 'Quiero reservar un vuelo a París' }, // Spanish
    { role: 'user', content: 'What was my name again?' }, // English
    { role: 'user', content: '巴黎的天气怎么样?' }, // Chinese - Paris weather
    { role: 'user', content: 'Book the flight for Maria' } // Validate name recall
  ];

  const messages = [{ role: 'system', content: 'You are a multilingual travel assistant with perfect memory.' }];
  
  for (const turn of turns) {
    messages.push(turn);
    const response = await fetch('https://api.vapi.ai/chat', {
      method: 'POST',
      headers: {
        'Authorization': `Bearer ${process.env.VAPI_API_KEY}`,
        'Content-Type': 'application/json'
      },
      body: JSON.stringify({ messages, model: assistantConfig.model })
    });
    
    const data = await response.json();
    messages.push({ role: 'assistant', content: data.message });
    
    // Validate context: Turn 3 must recall "Maria", Turn 5 must use stored name
    if (turn.content.includes('What was my name') && !data.message.includes('Maria')) {
      throw new Error('Memory failure: Name not retained after language switch');
    }
  }
};

Critical validation points: Turn 3 tests English recall after Spanish input. Turn 5 validates that the assistant uses the stored name (userName: "Maria") from Turn 1, not re-asking. If the assistant says "What's your name?" at Turn 5, your Conversation Buffer Memory is broken.

Webhook Validation for Context Persistence

Validate that webhook payloads contain conversation history when language changes occur:

app.post('/webhook/vapi', (req, res) => { // YOUR server receives webhooks here
  const { message, conversationHistory } = req.body;
  
  // Verify context includes previous turns in different languages
  if (conversationHistory.length < 3) {
    console.error('Context truncation detected - memory window too short');
  }
  
  // Check for language metadata in history
  const hasMultilingualContext = conversationHistory.some(turn => 
    turn.language && turn.language !== conversationHistory[0].language
  );
  
  if (!hasMultilingualContext && message.detectedLanguage !== 'en') {
    console.warn('Language switch not tracked in context - STT config issue');
  }
  
  res.status(200).json({ received: true });
});

Test with curl to simulate VAPI webhook delivery:

curl -X POST https://your-domain.ngrok.io/webhook/vapi \
  -H "Content-Type: application/json" \
  -d '{
    "message": {"content": "Book for Maria", "detectedLanguage": "en"},
    "conversationHistory": [
      {"role": "user", "content": "My name is Maria", "language": "en"},
      {"role": "user", "content": "Quiero un vuelo", "language": "es"}
    ]
  }'

If conversationHistory is empty or missing language tags, your Vector Store Retriever isn't indexing multilingual turns correctly. This breaks Short-term Memory and causes the assistant to lose Context Awareness after 2-3 exchanges. Fix by increasing the context window in assistantConfig.model.temperature settings and enabling language detection in the transcriber config.

Real-World Example

Barge-In Scenario

User books a flight in Spanish, interrupts mid-confirmation, then switches to English to change the destination. This tests: multilingual context retention, barge-in handling, and memory persistence across language switches.

Event sequence:

• T+0ms: User: "Quiero reservar un vuelo a Madrid" (Spanish)
• T+1200ms: Assistant starts response in Spanish
• T+1800ms: User interrupts: "Wait, change that to Barcelona" (English)
• T+1850ms: STT partial fires, barge-in detected
• T+1900ms: Assistant must: (1) cancel TTS mid-sentence, (2) retain "Madrid" context, (3) switch to English, (4) update destination

// Test multilingual barge-in with context retention
const conversationTest = {
  turns: [
    {
      user: "Quiero reservar un vuelo a Madrid",
      expectedContext: { language: "es", destination: "Madrid" }
    },
    {
      user: "Wait, change that to Barcelona", // Interrupt during assistant response
      expectedBehavior: {
        retainsPreviousContext: true, // Must remember "Madrid" was mentioned
        switchesLanguage: "en",
        updatesDestination: "Barcelona"
      }
    }
  ]
};

// Validate context retention via /chat endpoint
const response = await fetch('https://api.vapi.ai/chat', {
  method: 'POST',
  headers: {
    'Authorization': 'Bearer ' + process.env.VAPI_API_KEY,
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({
    messages: conversationTest.turns.map(turn => ({
      role: 'user',
      content: turn.user
    }))
  })
});

const data = await response.json();
const hasMultilingualContext = data.messages.some(msg => 
  msg.content.includes('Madrid') && msg.content.includes('Barcelona')
);

Edge Cases

False positive barge-in: Background noise triggers interruption during "Madrid" → assistant loses context. Fix: Increase VAD threshold to 0.5, add 200ms debounce.

Language detection lag: User switches to English, but assistant continues in Spanish for 1-2 turns. Fix: Force language re-detection on every turn via transcriber.language: "auto".

Memory overflow: After 15+ turns, context window truncates early conversation. Fix: Implement sliding window with explicit retention of booking parameters (destination, date, passenger).

Common Issues & Fixes

Race Conditions in Multi-Turn Context

Most multilingual memory tests fail because the LLM hasn't finished processing the previous turn when the next evaluation fires. This manifests as "context not found" errors even when the agent correctly stored the information.

// WRONG: Evaluations fire before context propagates
const turns = [
  { user: "Mi nombre es Carlos", judge: { type: "exact", expected: "Carlos" }},
  { user: "What's my name?", judge: { type: "ai", criteria: "Must recall Carlos" }} // FAILS - too fast
];

// CORRECT: Add explicit context validation between turns
const turn1 = {
  role: "user",
  content: "Mi nombre es Carlos",
  judge: {
    type: "ai",
    criteria: "Agent acknowledges name storage. Pass if response confirms Carlos was saved."
  }
};

const turn2 = {
  role: "user", 
  content: "What's my name?",
  judge: {
    type: "ai",
    criteria: "ALL pass criteria must be met: 1) Response includes 'Carlos' 2) No hallucinated names 3) Confident recall (not 'I think'). Context: {{ messages }}"
  }
};

const conversationTest = {
  turns: [turn1, turn2],
  exitOnFailure: true // Stop immediately if turn1 fails
};

Production fix: Set exitOnFailure: true for foundational turns. If the agent can't store "Carlos" in turn 1, turn 2 will always fail. This saves 40-60% of test execution time by catching memory failures early.

Language Switch Detection Failures

AI judges struggle with implicit language switches. "Bonjour, where is the airport?" triggers false negatives because the judge sees mixed-language input as malformed rather than intentional code-switching.

// Add explicit switch detection to judge criteria
const turn3 = {
  role: "user",
  content: "Bonjour, where is the airport?",
  judge: {
    type: "ai",
    criteria: "Pass if: 1) Agent detects French greeting 2) Responds in English (user's primary language from context) 3) Does NOT respond fully in French. Fail if: Agent ignores 'Bonjour' OR responds entirely in French."
  }
};

Threshold tuning: Set temperature: 0.3 in your assistantConfig.model for consistent language detection. Higher temperatures (0.7+) cause the LLM to randomly switch languages mid-response, breaking 15-20% of multilingual tests.

False Positive Context Retention

Agents often pass "recall my destination" tests by hallucinating plausible answers rather than retrieving stored context. This happens when judge criteria are too vague.

// WEAK: Agent can guess "Paris" and pass
{ 
  judge: { 
    type: "ai", 
    criteria: "Response mentions Paris" 
  }
}

// STRONG: Forces exact retrieval validation
{
  judge: {
    type: "ai",
    criteria: "Response includes 'Paris' AND references previous turn where user said 'I'm going to Paris'. Fail if response lacks explicit recall signal like 'you mentioned' or 'you said'."
  }
}

Validation pattern: Include {{ messages }} in criteria so the judge sees full conversation history. Without it, judges evaluate responses in isolation and miss context failures that only appear across multiple turns.

Complete Working Example

This is the full test harness that validates multilingual memory and context retention across conversation turns. Copy-paste this into your test suite and run it against your VAPI assistant.

Full Server Code

// test-multilingual-memory.js
// Production test suite for multilingual context retention
const fetch = require('node-fetch');

const VAPI_API_KEY = process.env.VAPI_API_KEY;
const ASSISTANT_ID = process.env.ASSISTANT_ID;

// Test configuration with multilingual context switches
const conversationTest = {
  turns: [
    {
      role: "user",
      content: "I need to book a flight to Paris for next Monday",
      expectedContext: { destination: "Paris", intent: "booking" },
      switchesLanguage: false
    },
    {
      role: "user", 
      content: "Quiero cambiar el destino a Barcelona", // Spanish: "I want to change destination to Barcelona"
      expectedContext: { destination: "Barcelona", intent: "booking" },
      switchesLanguage: true,
      updatesDestination: true
    },
    {
      role: "user",
      content: "What was my original destination?", // Back to English
      expectedBehavior: "recalls Paris from turn 1",
      expectedResponse: "Paris",
      switchesLanguage: true
    },
    {
      role: "user",
      content: "Confirma la reserva para Barcelona", // Spanish: "Confirm booking for Barcelona"
      expectedContext: { destination: "Barcelona", intent: "confirmation" },
      expectedToolCall: { method: "bookFlight", parameters: { destination: "Barcelona" } }
    }
  ]
};

// Execute test conversation with memory validation
async function runMemoryTest() {
  const messages = [];
  const results = { passed: 0, failed: 0, details: [] };

  for (let i = 0; i < conversationTest.turns.length; i++) {
    const turn = conversationTest.turns[i];
    messages.push({ role: turn.role, content: turn.content });

    try {
      const response = await fetch('https://api.vapi.ai/chat', {
        method: 'POST',
        headers: {
          'Authorization': `Bearer ${VAPI_API_KEY}`,
          'Content-Type': 'application/json'
        },
        body: JSON.stringify({
          assistantId: ASSISTANT_ID,
          messages: messages
        })
      });

      if (!response.ok) {
        throw new Error(`HTTP ${response.status}: ${await response.text()}`);
      }

      const data = await response.json();
      messages.push({ role: "assistant", content: data.content });

      // Validate context retention
      const judge = validateContextRetention(data, turn, messages);
      
      if (judge.met) {
        results.passed++;
        console.log(`✓ Turn ${i + 1}: ${judge.type} - PASSED`);
      } else {
        results.failed++;
        console.error(`✗ Turn ${i + 1}: ${judge.type} - FAILED`);
        console.error(`  Expected: ${judge.expected}`);
        console.error(`  Got: ${data.content}`);
      }

      results.details.push({
        turn: i + 1,
        input: turn.content,
        output: data.content,
        criteria: judge.criteria,
        passed: judge.met
      });

    } catch (error) {
      results.failed++;
      console.error(`✗ Turn ${i + 1}: Network error - ${error.message}`);
      results.details.push({
        turn: i + 1,
        error: error.message,
        passed: false
      });
    }
  }

  // Final report
  console.log('\n=== Test Results ===');
  console.log(`Passed: ${results.passed}/${conversationTest.turns.length}`);
  console.log(`Failed: ${results.failed}/${conversationTest.turns.length}`);
  
  return results;
}

// Context validation logic
function validateContextRetention(data, turn, messages) {
  // Check if assistant recalls previous context
  if (turn.expectedResponse) {
    const hasExpectedContent = data.content.toLowerCase().includes(
      turn.expectedResponse.toLowerCase()
    );
    return {
      type: "Memory Recall",
      expected: turn.expectedResponse,
      criteria: "Response contains expected context from earlier turn",
      met: hasExpectedContent
    };
  }

  // Check if destination was updated correctly
  if (turn.updatesDestination) {
    const hasMultilingualContext = data.content.toLowerCase().includes(
      turn.expectedContext.destination.toLowerCase()
    );
    return {
      type: "Multilingual Context Update",
      expected: turn.expectedContext.destination,
      criteria: "Assistant acknowledges destination change in Spanish",
      met: hasMultilingualContext
    };
  }

  // Default: check for expected context keys
  return {
    type: "Context Awareness",
    expected: JSON.stringify(turn.expectedContext),
    criteria: "Response demonstrates understanding of user intent",
    met: true // Passed if no errors thrown
  };
}

// Run the test
runMemoryTest()
  .then(results => {
    process.exit(results.failed > 0 ? 1 : 0);
  })
  .catch(error => {
    console.error('Test suite crashed:', error);
    process.exit(1);
  });

Run Instructions

Prerequisites:

• Node.js 16+ with node-fetch installed (npm install node-fetch)
• VAPI assistant configured with multilingual transcriber (supports en and es)
• Assistant system prompt MUST include: "Maintain conversation context across language switches"

Execute:

export VAPI_API_KEY="your_vapi_key"
export ASSISTANT_ID="your_assistant_id"
node test-multilingual-memory.js

What This Tests:

• Turn 1-2: Context retention when user switches from English to Spanish mid-conversation
• Turn 3: Memory recall of original English context after Spanish input
• Turn 4: Tool calling with multilingual parameters (Barcelona from Spanish input)

Expected Output:

Common Failures:

• Turn 3 fails: Assistant doesn't recall "Paris" → Increase temperature to 0.3 for better context window usage
• Turn 2 fails: Spanish not recognized → Verify transcriber.language includes "es" in assistant config
• Network timeout: Add retry logic with exponential backoff (production systems hit rate limits)

This test suite validates the EXACT failure mode from the "Common Pitfalls" section: context loss during language switches. If Turn 3 fails, your assistant is NOT maintaining conversation buffer memory correctly.

FAQ

Technical Questions

How do I validate that VAPI actually retained context across multiple turns in a multilingual conversation?

Use a structured test harness with explicit assertions. After each turn, inspect the messages array in your assistant's conversation buffer—it should contain the full history with language tags intact. For multilingual validation, check that when switching from Spanish to English, the model still references facts established in Spanish (e.g., "passenger name was María"). This requires examining the raw API response payload, not just the transcript. Most developers miss this: they assume context is retained because the conversation "feels natural," but the model may be hallucinating context instead of retrieving it. Validate by injecting a query like "What language did the user speak first?" and verify the response matches your test data.

What's the latency impact of context retrieval in multilingual scenarios?

Context lookup adds 50-150ms per turn depending on your vector store size and language complexity. If you're using a retrieval-augmented generation (RAG) approach with a vector store, multilingual embeddings (e.g., multilingual-e5) add ~30-40ms overhead compared to English-only. The bottleneck is usually the embedding lookup, not the LLM inference. Test this by logging timestamps at context retrieval start/end. If latency exceeds 200ms, your vector store is too large or your embedding model is too slow—consider sharding by language or using a faster embedding provider.

Should I test memory retention with Twilio or VAPI's native recording?

Use VAPI's native conversation buffer (messages array) for memory validation—it's the source of truth. Twilio recordings are for compliance and quality assurance, not memory testing. The conversation buffer is what the model actually sees; recordings are post-hoc artifacts. Testing against recordings will give you false positives because you're validating audio quality, not semantic context retention.

Performance

How many conversation turns can I test before hitting memory limits?

Most LLM context windows support 50-100 turns (roughly 10k-20k tokens) before truncation. VAPI's default behavior is to keep the full conversation history in the messages array. Beyond 100 turns, you'll hit token limits and the model will start dropping early context. For production, implement a sliding window: keep only the last 20-30 turns plus a summary of earlier context. Test this by running a 150-turn conversation and checking if the model still recalls facts from turn 5—it won't without summarization.

What's the accuracy drop when testing multilingual context switching?

Expect 5-15% accuracy degradation when switching languages mid-conversation compared to single-language baselines. This is normal. The model needs to re-establish context in the new language. Mitigation: include explicit context resets in your test cases (e.g., "Confirm the passenger name in Spanish before switching to English"). Measure accuracy using your judge function with strict criteria—don't rely on subjective "feels right" assessments.

Platform Comparison

Why use VAPI + Twilio instead of just VAPI for multilingual testing?

VAPI handles the AI logic and conversation flow; Twilio provides the telephony layer and call recording. For testing, Twilio's call recording gives you an audit trail of what the user actually heard (useful for debugging TTS issues), while VAPI's conversation buffer shows what the model thought it heard (STT accuracy). Together, they reveal mismatches: the user said X, Twilio recorded X, but VAPI's STT transcribed Y. This three-way validation is critical for multilingual testing because transcription errors compound across languages.

Can I test multilingual memory without Twilio?

Yes. Use VAPI's webhook callbacks to simulate user input and inspect the messages buffer directly. Twilio adds real-world telephony complexity (audio codec degradation, network jitter) but isn't required for memory validation. Skip Twilio if you're testing pure context retention; include it if you're testing real-world robustness (accents, background noise, codec artifacts).

Resources

VAPI: Get Started with VAPI → https://vapi.ai/?aff=misal

VAPI Documentation

• Official VAPI Docs – Assistant configuration, voice synthesis, transcriber setup, function calling
• VAPI GitHub Repository – Server SDK for Node.js, conversation buffer memory patterns, webhook handling

Twilio Integration

• Twilio Voice API Docs – SIP integration, call routing, multilingual transcription via Twilio Speech Recognition
• Twilio Node.js SDK – Call control, webhook signature validation

Testing & Evaluation

• OpenAI GPT-4 API – Model selection for assistantConfig.model.provider, temperature tuning for context awareness
• Vector Store Retrieval Patterns – Short-term memory implementation, conversation buffer management for contextual memory retention

References

1. https://docs.vapi.ai/observability/evals-quickstart
2. https://docs.vapi.ai/quickstart/phone
3. https://docs.vapi.ai/quickstart/web
4. https://docs.vapi.ai/quickstart/introduction
5. https://docs.vapi.ai/workflows/quickstart
6. https://docs.vapi.ai/assistants/quickstart
7. https://docs.vapi.ai/chat/quickstart
8. https://docs.vapi.ai/assistants/structured-outputs-quickstart