<!-- Example TwiML response -->
<Response>
  <Say>Hello, thank you for calling. Connecting you to our AI assistant.</Say>
  <Connect>
    <Stream url="wss://your-server.com/media-stream" />
  </Connect>
</Response>

┌─────────────────────────────────────────────────────────────────┐
│                         Caller                                  │
└─────────────────────┬───────────────────────────────────────────┘
                      │ Phone Call
                      ▼
┌─────────────────────────────────────────────────────────────────┐
│                        Twilio                                   │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │  Phone Number → TwiML Webhook → Media Stream (WebSocket) │   │
│  └─────────────────────────────────────────────────────────┘   │
└─────────────────────┬───────────────────────────────────────────┘
                      │ WebSocket
                      ▼
┌─────────────────────────────────────────────────────────────────┐
│                     n8n Workflow                                │
│  ┌──────────────┐    ┌──────────────┐    ┌──────────────────┐  │
│  │  WebSocket   │───▶│  AI Agent    │───▶│  ElevenLabs TTS  │  │
│  │   Server     │◄───│  Processing  │◄───│   (Voice Out)    │  │
│  └──────────────┘    └──────────────┘    └──────────────────┘  │
│         │                   │                       │          │
│         ▼                   ▼                       ▼          │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │              Business System Integrations                │   │
│  │  CRM | Calendar | Database | Payment | Notifications    │   │
│  └─────────────────────────────────────────────────────────┘   │
└─────────────────────────────────────────────────────────────────┘

1. Caller dials phone number
         ↓
2. Twilio receives call, triggers webhook to n8n
         ↓
3. n8n workflow initiates AI agent session
         ↓
4. ElevenLabs generates greeting ("Hello, how can I help?")
         ↓
5. Twilio streams greeting to caller
         ↓
6. Caller speaks → Audio streamed via WebSocket to n8n
         ↓
7. n8n transcribes speech (Deepgram/Whisper)
         ↓
8. Transcript sent to LLM (OpenAI/Claude/Ollama)
         ↓
9. LLM generates response
         ↓
10. ElevenLabs synthesizes response audio
         ↓
11. Audio streamed back to caller
         ↓
12. Repeat 6-11 until call ends or transfer requested
         ↓
13. n8n logs call, updates CRM, sends notifications

┌─────────────────────────────────────────────────────────────────┐
│              ElevenLabs Conversational AI                       │
│  ┌──────────────┐    ┌──────────────┐    ┌──────────────┐      │
│  │   Speech     │───▶│   LLM with   │───▶│    Voice     │      │
│  │  Recognition │    │  Tool Calls  │    │  Synthesis   │      │
│  └──────────────┘    └──────┬───────┘    └──────────────┘      │
│                             │                                  │
│                             ▼                                  │
│                    ┌────────────────┐                          │
│                    │  n8n Webhook   │◄── Tool execution        │
│                    │  (Tool Calls)  │                          │
│                    └───────┬────────┘                          │
│                            │                                   │
└────────────────────────────┼───────────────────────────────────┘
                             │ API/WebSocket
                             ▼
                    ┌────────────────┐
                    │ Business Logic │
                    │  CRM/Calendar  │
                    └────────────────┘

# Using Twilio CLI
twilio phone-numbers:buy:local --country-code US --area-code 555

# Or via Console: Phone Numbers → Manage → Buy a number

You are Sarah, the friendly receptionist at Acme Dental Practice. 
You handle appointment scheduling, answer questions about services, 
and provide general information. Be warm, professional, and efficient.

Key information:
- Office hours: Monday-Friday 9 AM - 6 PM
- Services: General dentistry, orthodontics, teeth whitening
- New patient consultations are free
- Emergency line available 24/7

Always confirm appointment details before ending calls.

# docker-compose.yml
version: '3.8'

services:
  n8n:
    image: n8nio/n8n:latest
    restart: always
    ports:
      - "5678:5678"
    environment:
      - N8N_BASIC_AUTH_ACTIVE=true
      - N8N_BASIC_AUTH_USER=admin
      - N8N_BASIC_AUTH_PASSWORD=your_secure_password
      - GENERIC_TIMEZONE=UTC
      - WEBHOOK_URL=https://your-domain.com/
    volumes:
      - ./n8n-data:/home/node/.n8n
    networks:
      - automation-network

  # Optional: Add webhook tunnel for local development
  ngrok:
    image: ngrok/ngrok:latest
    command: http n8n:5678 --authtoken=${NGROK_AUTH_TOKEN}
    networks:
      - automation-network

networks:
  automation-network:
    driver: bridge

# Create directories
mkdir -p n8n-data

# Start services
docker-compose up -d

# Check logs
docker-compose logs -f n8n

// Node: Generate TwiML
const twiml = `<?xml version="1.0" encoding="UTF-8"?>
<Response>
  <Say voice="Polly.Joanna">
    Hello! Thank you for calling Tropical Media. 
    Our AI assistant is currently in development. 
    Please leave a message after the tone.
  </Say>
  <Record maxLength="120" />
</Response>`;

return [{
  json: {
    headers: {
      'Content-Type': 'text/xml'
    },
    statusCode: 200,
    body: twiml
  }
}];

[Twilio Call] → [Webhook: Initial Setup] → [WebSocket Server]
                                              ↓
[ElevenLabs] ← [n8n AI Processing] ← [Speech-to-Text]
     ↓              ↓
[Voice Output] → [Caller]

// Node: Parse Twilio Payload
const twilioData = $input.first().json.body;

return [{
  json: {
    callSid: twilioData.CallSid,
    from: twilioData.From,
    to: twilioData.To,
    callStatus: twilioData.CallStatus,
    direction: twilioData.Direction
  }
}];

// Node: Generate Stream TwiML
const callSid = $input.first().json.callSid;

const twiml = `<?xml version="1.0" encoding="UTF-8"?>
<Response>
  <Connect>
    <Stream url="wss://your-n8n-instance.com/ws/voice/${callSid}" />
  </Connect>
</Response>`;

return [{
  json: {
    headers: { 'Content-Type': 'text/xml' },
    statusCode: 200,
    body: twiml
  }
}];

// Node: WebSocket Handler (Execute Once for all items)
const WebSocket = require('ws');
const axios = require('axios');

// Configuration
const ELEVENLABS_API_KEY = $env.ELEVENLABS_API_KEY;
const ELEVENLABS_AGENT_ID = $env.ELEVENLABS_AGENT_ID;
const DEEPGRAM_API_KEY = $env.DEEPGRAM_API_KEY;
const OPENAI_API_KEY = $env.OPENAI_API_KEY;

// WebSocket server setup
const wss = new WebSocket.Server({ port: 8080 });

wss.on('connection', (ws, req) => {
  const callSid = req.url.split('/').pop();
  console.log(`Call connected: ${callSid}`);
  
  // Initialize conversation context
  let conversationHistory = [];
  let isProcessing = false;
  
  // Handle audio from Twilio
  ws.on('message', async (data) => {
    const msg = JSON.parse(data);
    
    switch(msg.event) {
      case 'connected':
        // Send greeting via ElevenLabs
        const greeting = await generateSpeech(
          "Hello! I'm your AI assistant. How can I help you today?"
        );
        ws.send(JSON.stringify({
          event: 'media',
          streamSid: msg.streamSid,
          media: { payload: greeting }
        }));
        break;
        
      case 'media':
        // Received audio from caller
        if (isProcessing) return;
        isProcessing = true;
        
        // Convert mulaw to PCM (Twilio format)
        const audioBuffer = Buffer.from(msg.media.payload, 'base64');
        
        // Transcribe with Deepgram
        const transcript = await transcribeAudio(audioBuffer);
        
        if (transcript) {
          // Add to history
          conversationHistory.push({
            role: 'user',
            content: transcript
          });
          
          // Get AI response
          const aiResponse = await getAIResponse(conversationHistory);
          
          // Generate speech
          const audioResponse = await generateSpeech(aiResponse);
          
          // Send back to caller
          ws.send(JSON.stringify({
            event: 'media',
            streamSid: msg.streamSid,
            media: { payload: audioResponse }
          }));
          
          // Update history
          conversationHistory.push({
            role: 'assistant',
            content: aiResponse
          });
        }
        
        isProcessing = false;
        break;
        
      case 'stop':
        console.log(`Call ended: ${callSid}`);
        // Log conversation to CRM
        await logCall(callSid, conversationHistory);
        ws.close();
        break;
    }
  });
});

// Helper: Transcribe audio using Deepgram
async function transcribeAudio(audioBuffer) {
  const response = await axios.post(
    'https://api.deepgram.com/v1/listen?model=nova-2&smart_format=true',
    audioBuffer,
    {
      headers: {
        'Authorization': `Token ${DEEPGRAM_API_KEY}`,
        'Content-Type': 'audio/wav'
      }
    }
  );
  
  return response.data.results?.channels[0]?.alternatives[0]?.transcript;
}

// Helper: Get AI response
async function getAIResponse(history) {
  const response = await axios.post(
    'https://api.openai.com/v1/chat/completions',
    {
      model: 'gpt-4o',
      messages: [
        {
          role: 'system',
          content: 'You are a helpful assistant for a dental practice...'
        },
        ...history
      ],
      max_tokens: 150
    },
    {
      headers: {
        'Authorization': `Bearer ${OPENAI_API_KEY}`,
        'Content-Type': 'application/json'
      }
    }
  );
  
  return response.data.choices[0].message.content;
}

// Helper: Generate speech with ElevenLabs
async function generateSpeech(text) {
  const response = await axios.post(
    `https://api.elevenlabs.io/v1/text-to-speech/${ELEVENLABS_VOICE_ID}/stream`,
    {
      text: text,
      model_id: 'eleven_turbo_v2_5',
      voice_settings: {
        stability: 0.5,
        similarity_boost: 0.5
      }
    },
    {
      headers: {
        'xi-api-key': ELEVENLABS_API_KEY,
        'Content-Type': 'application/json'
      },
      responseType: 'arraybuffer'
    }
  );
  
  // Convert to mulaw format for Twilio
  return Buffer.from(response.data).toString('base64');
}

// Helper: Log call to CRM
async function logCall(callSid, history) {
  await axios.post('https://your-crm.com/api/calls', {
    callSid,
    transcript: history,
    timestamp: new Date().toISOString()
  });
}

You are a helpful AI receptionist for a dental practice. Your name is Sarah.

Your capabilities:
- Schedule appointments for existing and new patients
- Answer questions about services and pricing
- Provide office hours and location information
- Handle emergencies by transferring to the on-call dentist

When scheduling appointments:
1. Collect patient's full name
2. Confirm phone number
3. Ask for preferred date and time
4. Ask for reason for visit (checkup, cleaning, etc.)
5. Confirm all details before booking

Always be warm, professional, and patient. If you don't know something, 
offer to have a human representative call them back.

{
  "name": "check_availability",
  "description": "Check available appointment slots for a given date",
  "parameters": {
    "type": "object",
    "properties": {
      "date": {
        "type": "string",
        "format": "date",
        "description": "Date to check (YYYY-MM-DD)"
      },
      "appointment_type": {
        "type": "string",
        "enum": ["cleaning", "checkup", "consultation", "emergency"],
        "description": "Type of appointment"
      }
    },
    "required": ["date", "appointment_type"]
  }
}

{
  "name": "book_appointment",
  "description": "Book an appointment for a patient",
  "parameters": {
    "type": "object",
    "properties": {
      "patient_name": {
        "type": "string",
        "description": "Patient's full name"
      },
      "phone": {
        "type": "string",
        "description": "Patient's phone number"
      },
      "date": {
        "type": "string",
        "format": "date"
      },
      "time": {
        "type": "string",
        "pattern": "^([0-1]?[0-9]|2[0-3]):[0-5][0-9]$"
      },
      "appointment_type": {
        "type": "string"
      },
      "notes": {
        "type": "string"
      }
    },
    "required": ["patient_name", "phone", "date", "time", "appointment_type"]
  }
}

{
  "name": "send_summary",
  "description": "Send call summary to reception staff via Slack",
  "parameters": {
    "type": "object",
    "properties": {
      "summary": {
        "type": "string",
        "description": "Summary of the call"
      },
      "urgency": {
        "type": "string",
        "enum": ["low", "medium", "high"]
      }
    },
    "required": ["summary"]
  }
}

// Node: Parse Tool Request
const body = $input.first().json.body;

return [{
  json: {
    toolName: body.tool_name,
    parameters: body.parameters,
    callId: body.call_id,
    conversationId: body.conversation_id
  }
}];

// Node: Check Calendar
const { date, appointment_type } = $input.first().json.parameters;

// Query your booking system (example with Cal.com API)
const availability = await $httpRequest({
  method: 'GET',
  url: `https://api.cal.com/v1/availability`,
  qs: {
    apiKey: $env.CAL_API_KEY,
    dateFrom: date,
    dateTo: date,
    eventTypeId: getEventTypeId(appointment_type)
  }
});

// Format available slots
const slots = availability.slots.map(slot => 
  new Date(slot.time).toLocaleTimeString('en-US', { 
    hour: '2-digit', 
    minute: '2-digit',
    hour12: true 
  })
);

return [{
  json: {
    result: {
      available: slots.length > 0,
      slots: slots.slice(0, 5), // Return top 5 slots
      date: date
    }
  }
}];

function getEventTypeId(type) {
  const map = {
    'cleaning': 123,
    'checkup': 124,
    'consultation': 125,
    'emergency': 126
  };
  return map[type] || 124;
}

// Node: Book Appointment
const params = $input.first().json.parameters;

// Create booking
const booking = await $httpRequest({
  method: 'POST',
  url: 'https://api.cal.com/v1/bookings',
  body: {
    apiKey: $env.CAL_API_KEY,
    eventTypeId: getEventTypeId(params.appointment_type),
    start: `${params.date}T${params.time}`,
    name: params.patient_name,
    email: `temp@${params.phone}.placeholder`, // Placeholder
    location: 'Phone consultation',
    metadata: {
      phone: params.phone,
      source: 'ai_voice_agent',
      notes: params.notes || ''
    }
  }
});

// Store in CRM
await $httpRequest({
  method: 'POST',
  url: 'https://your-crm.com/api/appointments',
  body: {
    patient_name: params.patient_name,
    phone: params.phone,
    date: params.date,
    time: params.time,
    type: params.appointment_type,
    booking_id: booking.id,
    source: 'voice_agent'
  },
  headers: {
    'Authorization': `Bearer ${$env.CRM_API_KEY}`
  }
});

// Send confirmation SMS
await $httpRequest({
  method: 'POST',
  url: 'https://api.twilio.com/2010-04-01/Accounts/YOUR_SID/Messages.json',
  body: {
    To: params.phone,
    From: $env.TWILIO_PHONE_NUMBER,
    Body: `Hi ${params.patient_name}, your appointment is confirmed for ${params.date} at ${params.time}. Reply CANCEL to reschedule.`
  },
  auth: {
    username: $env.TWILIO_ACCOUNT_SID,
    password: $env.TWILIO_AUTH_TOKEN
  }
});

return [{
  json: {
    result: {
      success: true,
      booking_id: booking.id,
      confirmation_sent: true
    }
  }
}];

// Node: Send to Slack
const { summary, urgency = 'low' } = $input.first().json.parameters;

const urgencyEmoji = {
  'high': '🔴',
  'medium': '🟡',
  'low': '🟢'
};

await $httpRequest({
  method: 'POST',
  url: $env.SLACK_WEBHOOK_URL,
  body: {
    text: `${urgencyEmoji[urgency]} *AI Voice Agent Summary*`,
    blocks: [
      {
        type: 'header',
        text: {
          type: 'plain_text',
          text: 'AI Voice Agent Call Summary'
        }
      },
      {
        type: 'section',
        fields: [
          {
            type: 'mrkdwn',
            text: `*Urgency:*\n${urgency}`
          },
          {
            type: 'mrkdwn',
            text: `*Time:*\n${new Date().toLocaleString()}`
          }
        ]
      },
      {
        type: 'section',
        text: {
          type: 'mrkdwn',
          text: `*Summary:*\n${summary}`
        }
      }
    ]
  }
});

return [{
  json: {
    result: {
      sent: true,
      channel: 'reception-team'
    }
  }
}];

// Node: Return to ElevenLabs
const toolResult = $input.first().json.result;

return [{
  json: {
    statusCode: 200,
    body: {
      result: toolResult
    }
  }
}];

// Node: Proxy to ElevenLabs
const callSid = $input.first().json.body.CallSid;
const from = $input.first().json.body.From;

// Custom logic: Check if caller is blocked
const isBlocked = await checkBlockedList(from);

if (isBlocked) {
  return [{
    json: {
      headers: { 'Content-Type': 'text/xml' },
      body: `<?xml version="1.0"?>
<Response>
  <Say>This number has been blocked.</Say>
  <Hangup/>
</Response>`
    }
  }];
}

// Forward to ElevenLabs
return [{
  json: {
    headers: { 'Content-Type': 'text/xml' },
    body: `<?xml version="1.0"?>
<Response>
  <Connect>
    <Stream url="wss://api.elevenlabs.io/v1/convai/twilio/connect/${AGENT_ID}" />
  </Connect>
</Response>`
  }
}];

// Node: Transfer Call
const { callSid, transferTo } = $input.first().json.parameters;

// Twilio transfer using Dial
const twiml = `<?xml version="1.0"?>
<Response>
  <Say>I'm transferring you to a team member now. Please hold.</Say>
  <Dial>
    <Number>${transferTo}</Number>
  </Dial>
</Response>`;

// Update call via Twilio API
await $httpRequest({
  method: 'POST',
  url: `https://api.twilio.com/2010-04-01/Accounts/${TWILIO_SID}/Calls/${callSid}`,
  body: {
    Twiml: twiml
  },
  auth: {
    username: $env.TWILIO_ACCOUNT_SID,
    password: $env.TWILIO_AUTH_TOKEN
  }
});

return [{
  json: {
    result: {
      transferred: true,
      to: transferTo
    }
  }
}];

{
  "name": "transfer_to_human",
  "description": "Transfer the call to a human representative",
  "parameters": {
    "type": "object",
    "properties": {
      "department": {
        "type": "string",
        "enum": ["sales", "support", "billing", "emergency"]
      },
      "reason": {
        "type": "string",
        "description": "Reason for transfer"
      }
    },
    "required": ["department"]
  }
}

// Node: Language Detection
const message = $input.first().json.body.message;

// Use OpenAI to detect language
const detection = await $httpRequest({
  method: 'POST',
  url: 'https://api.openai.com/v1/chat/completions',
  body: {
    model: 'gpt-4o-mini',
    messages: [
      {
        role: 'system',
        content: 'Detect the language of the input message. Return ONLY the ISO 639-1 code (e.g., "en", "es", "de", "th").'
      },
      {
        role: 'user',
        content: message
      }
    ]
  },
  headers: {
    'Authorization': `Bearer ${$env.OPENAI_API_KEY}`
  }
});

const language = detection.choices[0].message.content.trim();

// Map to ElevenLabs voice
const voiceMap = {
  'en': 'XB0fDUnXU5powFXDhCwa',  // English
  'es': 'TX3AEvVoIzMeN6jBfAjZ',  // Spanish
  'de': 'Hh1cR3w8I9fHNkEn11VW',  // German
  'th': 'custom-thai-voice-id'     // Thai
};

return [{
  json: {
    language: language,
    voice_id: voiceMap[language] || voiceMap['en'],
    system_prompt: getLocalizedPrompt(language)
  }
}];

function getLocalizedPrompt(lang) {
  const prompts = {
    'en': 'You are a helpful assistant...',
    'es': 'Eres un asistente servicial...',
    'de': 'Sie sind ein hilfsbereiter Assistent...',
    'th': 'คุณเป็นผู้ช่วยที่เป็นประโยชน์...'
  };
  return prompts[lang] || prompts['en'];
}

// Node: Store Call Data
const callData = $input.first().json.body;

// Store in database
await $httpRequest({
  method: 'POST',
  url: 'https://your-analytics-db.com/api/calls',
  body: {
    call_id: callData.call_id,
    duration_seconds: callData.duration,
    transcript: callData.transcript,
    tools_used: callData.tools_used,
    sentiment: await analyzeSentiment(callData.transcript),
    outcome: callData.outcome, // 'appointment_booked', 'transferred', 'completed', etc.
    timestamp: new Date().toISOString()
  }
});

// Generate insights
const insights = {
  total_calls: await getTotalCallsToday(),
  avg_duration: await getAverageDuration(),
  booking_rate: await getBookingRate(),
  transfer_rate: await getTransferRate()
};

// Send daily report
if (isEndOfDay()) {
  await $httpRequest({
    method: 'POST',
    url: $env.SLACK_WEBHOOK_URL,
    body: {
      text: `📊 Daily Voice Agent Report\n\n` +
            `Total Calls: ${insights.total_calls}\n` +
            `Avg Duration: ${insights.avg_duration}s\n` +
            `Booking Rate: ${insights.booking_rate}%\n` +
            `Transfer Rate: ${insights.transfer_rate}%`
    }
  });
}

return [{
  json: {
    stored: true,
    insights: insights
  }
}];

async function analyzeSentiment(text) {
  const response = await $httpRequest({
    method: 'POST',
    url: 'https://api.openai.com/v1/chat/completions',
    body: {
      model: 'gpt-4o-mini',
      messages: [
        {
          role: 'system',
          content: 'Analyze sentiment. Return ONLY: POSITIVE, NEUTRAL, or NEGATIVE'
        },
        {
          role: 'user',
          content: text
        }
      ]
    },
    headers: {
      'Authorization': `Bearer ${$env.OPENAI_API_KEY}`
    }
  });
  
  return response.choices[0].message.content.trim();
}

// Node: Schedule Outbound Calls
// Trigger: Daily at 9 AM (Cron)

// Get tomorrow's appointments
const tomorrow = new Date();
tomorrow.setDate(tomorrow.getDate() + 1);
const dateStr = tomorrow.toISOString().split('T')[0];

const appointments = await $httpRequest({
  method: 'GET',
  url: 'https://your-crm.com/api/appointments',
  qs: {
    date: dateStr,
    status: 'confirmed'
  },
  headers: {
    'Authorization': `Bearer ${$env.CRM_API_KEY}`
  }
});

// Queue reminder calls
for (const appt of appointments) {
  await $httpRequest({
    method: 'POST',
    url: `https://api.twilio.com/2010-04-01/Accounts/${$env.TWILIO_ACCOUNT_SID}/Calls.json`,
    body: {
      To: appt.phone,
      From: $env.TWILIO_PHONE_NUMBER,
      Url: `https://your-n8n-instance.com/webhook/twilio-reminder?appt_id=${appt.id}`,
      StatusCallback: `https://your-n8n-instance.com/webhook/twilio-status`
    },
    auth: {
      username: $env.TWILIO_ACCOUNT_SID,
      password: $env.TWILIO_AUTH_TOKEN
    }
  });
}

return [{
  json: {
    calls_scheduled: appointments.length,
    for_date: dateStr
  }
}];

// Node: Reminder Call TwiML
const apptId = $input.first().json.query.appt_id;

// Get appointment details
const appt = await $httpRequest({
  method: 'GET',
  url: `https://your-crm.com/api/appointments/${apptId}`,
  headers: {
    'Authorization': `Bearer ${$env.CRM_API_KEY}`
  }
});

// Use ElevenLabs for natural reminder
const greeting = await generateSpeech(
  `Hello ${appt.patient_name}, this is a reminder from Tropical Dental. ` +
  `You have an appointment scheduled for tomorrow at ${appt.time}. ` +
  `Press 1 to confirm, 2 to cancel, or 3 to reschedule.`
);

const twiml = `<?xml version="1.0"?>
<Response>
  <Play>${greeting}</Play>
  <Gather numDigits="1" action="/webhook/twilio-reminder-response?appt_id=${apptId}" method="POST">
    <Say>Please press 1 to confirm, 2 to cancel, or 3 to reschedule.</Say>
  </Gather>
  <Say>We didn't receive a response. Goodbye.</Say>
</Response>`;

return [{
  json: {
    headers: { 'Content-Type': 'text/xml' },
    body: twiml
  }
}];

// Node: Verify Twilio Signature
const crypto = require('crypto');

const authToken = $env.TWILIO_AUTH_TOKEN;
const twilioSignature = $input.first().json.headers['x-twilio-signature'];
const url = $input.first().json.originalUrl;
const params = $input.first().json.body;

// Build string to sign
let data = url;
Object.keys(params).sort().forEach(key => {
  data += key + params[key];
});

// Calculate expected signature
const expectedSignature = crypto
  .createHmac('sha1', authToken)
  .update(Buffer.from(data, 'utf8'))
  .digest('base64');

// Verify
if (twilioSignature !== expectedSignature) {
  return [{
    json: {
      statusCode: 403,
      body: { error: 'Invalid signature' }
    }
  }];
}

// Continue processing
return $input.all();

// Node: Rate Limit Check
const caller = $input.first().json.body.From;
const cacheKey = `rate_limit:${caller}`;

// Check Redis or similar cache
const callCount = await cache.get(cacheKey) || 0;

if (callCount > 10) { // Max 10 calls per hour
  return [{
    json: {
      statusCode: 429,
      body: { error: 'Rate limit exceeded' }
    }
  }];
}

// Increment counter
await cache.set(cacheKey, callCount + 1, 'EX', 3600); // 1 hour TTL

return $input.all();

// Node: Log Call
const callData = $input.first().json;

await $httpRequest({
  method: 'POST',
  url: 'https://your-logging-service.com/api/logs',
  body: {
    timestamp: new Date().toISOString(),
    level: 'info',
    service: 'voice-agent',
    call_sid: callData.CallSid,
    from: callData.From,
    to: callData.To,
    duration: callData.CallDuration,
    status: callData.CallStatus,
    // Don't log full transcripts to public logs
    transcript_hash: hashTranscript(callData.Transcript)
  }
});

// Workflow: Health Check (runs every 5 minutes)
// Trigger: Cron - */5 * * * *

const checks = [
  checkTwilioConnectivity(),
  checkElevenLabsAPI(),
  checkDatabaseConnection(),
  checkCRMConnection()
];

const results = await Promise.all(checks);

const allHealthy = results.every(r => r.healthy);

if (!allHealthy) {
  await $httpRequest({
    method: 'POST',
    url: $env.PAGERDUTY_WEBHOOK,
    body: {
      severity: 'warning',
      summary: 'Voice Agent System Degraded',
      details: results.filter(r => !r.healthy)
    }
  });
}

return [{
  json: {
    healthy: allHealthy,
    checks: results,
    timestamp: new Date().toISOString()
  }
}];

Twilio: 100 calls × 5 min × $0.0085 = $4.25
Phone number: $1.15
ElevenLabs: 500 min × $0.05 = $25.00
OpenAI: ~$5.00
Deepgram: 500 min × $0.0043 = $2.15
----------------------------------------
Total: ~$37.55/month

vs. Human receptionist: $2,500+/month

# docker-compose.prod.yml
version: '3.8'

services:
  n8n:
    image: n8nio/n8n:latest
    deploy:
      replicas: 3
      resources:
        limits:
          cpus: '2'
          memory: 4G
    environment:
      - N8N_REDIS_HOST=redis
      - EXECUTIONS_MODE=queue
    networks:
      - voice-agent-network

  redis:
    image: redis:alpine
    networks:
      - voice-agent-network

  nginx:
    image: nginx:alpine
    ports:
      - "80:80"
      - "443:443"
    volumes:
      - ./nginx.conf:/etc/nginx/nginx.conf
    networks:
      - voice-agent-network

networks:
  voice-agent-network:

// Optimization: Streaming OpenAI response
const response = await $httpRequest({
  method: 'POST',
  url: 'https://api.openai.com/v1/chat/completions',
  body: {
    model: 'gpt-4o',
    messages: conversationHistory,
    stream: true  // Enable streaming
  },
  headers: {
    'Authorization': `Bearer ${$env.OPENAI_API_KEY}`,
    'Accept': 'text/event-stream'
  }
});

// Process chunks as they arrive
for await (const chunk of response) {
  const content = parseChunk(chunk);
  if (content) {
    // Generate and send audio incrementally
    await streamAudio(content);
  }
}

# Test from outside your network
curl -X POST https://your-webhook-url.com/webhook/twilio-voice \
  -d "CallSid=test" \
  -d "From=+1234567890"

curl -X POST https://your-n8n-instance.com/webhook/elevenlabs-tools \
  -H "Content-Type: application/json" \
  -d '{
    "tool_name": "check_availability",
    "parameters": {"date": "2026-04-10", "appointment_type": "cleaning"}
  }'