<!-- Beispiel TwiML-Antwort -->
<Response>
  <Say>Hallo, danke für Ihren Anruf. Ich verbinde Sie mit unserem KI-Assistenten.</Say>
  <Connect>
    <Stream url="wss://ihr-server.de/media-stream" />
  </Connect>
</Response>

┌─────────────────────────────────────────────────────────────────┐
│                         Anrufer                                 │
└─────────────────────┬───────────────────────────────────────────┘
                      │ Telefonanruf
                      ▼
┌─────────────────────────────────────────────────────────────────┐
│                        Twilio                                   │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │  Telefonnummer → TwiML-Webhook → Media Stream (WebSocket) │   │
│  └─────────────────────────────────────────────────────────┘   │
└─────────────────────┬───────────────────────────────────────────┘
                      │ WebSocket
                      ▼
┌─────────────────────────────────────────────────────────────────┐
│                     n8n-Workflow                                │
│  ┌──────────────┐    ┌──────────────┐    ┌──────────────────┐  │
│  │  WebSocket   │───▶│  KI-Agent    │───▶│  ElevenLabs TTS  │  │
│  │   Server     │◄───│  Verarbeitung│◄───│   (Sprachausgabe)│  │
│  └──────────────┘    └──────────────┘    └──────────────────┘  │
│         │                   │                       │          │
│         ▼                   ▼                       ▼          │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │              Geschäftssystem-Integrationen               │   │
│  │  CRM | Kalender | Datenbank | Zahlung | Benachrichtigungen│   │
│  └─────────────────────────────────────────────────────────┘   │
└─────────────────────────────────────────────────────────────────┘

1. Anrufer wählt Telefonnummer
         ↓
2. Twilio empfängt Anruf, löst Webhook zu n8n aus
         ↓
3. n8n-Workflow initiiert KI-Agenten-Sitzung
         ↓
4. ElevenLabs generiert Begrüßung ("Hallo, wie kann ich helfen?")
         ↓
5. Twilio streamt Begrüßung zum Anrufer
         ↓
6. Anrufer spricht → Audio wird via WebSocket zu n8n gestreamt
         ↓
7. n8n transkribiert Sprache (Deepgram/Whisper)
         ↓
8. Transkript wird an LLM gesendet (OpenAI/Claude/Ollama)
         ↓
9. LLM generiert Antwort
         ↓
10. ElevenLabs synthetisiert Antwort-Audio
         ↓
11. Audio wird zum Anrufer zurückgestreamt
         ↓
12. Schritte 6-11 wiederholen, bis Anruf endet oder Weiterleitung gewünscht
         ↓
13. n8n protokolliert Anruf, aktualisiert CRM, sendet Benachrichtigungen

┌─────────────────────────────────────────────────────────────────┐
│              ElevenLabs Konversationelle KI                     │
│  ┌──────────────┐    ┌──────────────┐    ┌──────────────┐      │
│  │   Sprach-    │───▶│   LLM mit    │───▶│    Sprach-   │      │
│  │  Erkennung   │    │  Tool-Aufrufen│   │  Synthese    │      │
│  └──────────────┘    └──────┬───────┘    └──────────────┘      │
│                             │                                  │
│                             ▼                                  │
│                    ┌────────────────┐                          │
│                    │  n8n-Webhook   │◄── Tool-Ausführung        │
│                    │  (Tool-Aufrufe)│                          │
│                    └───────┬────────┘                          │
│                            │                                   │
└────────────────────────────┼───────────────────────────────────┘
                             │ API/WebSocket
                             ▼
                    ┌────────────────┐
                    │ Geschäftslogik │
                    │  CRM/Kalender  │
                    └────────────────┘

# Verwendung der Twilio CLI
twilio phone-numbers:buy:local --country-code DE --area-code 89

# Oder über die Konsole: Telefonnummern → Verwalten → Nummer kaufen

Sie sind Sarah, die freundliche Empfangsdame der Zahnarztpraxis Müller.
Sie kümmern sich um die Terminplanung, beantworten Fragen zu Leistungen 
und geben allgemeine Informationen. Seien Sie herzlich, professionell 
und effizient.

Wichtige Informationen:
- Öffnungszeiten: Montag-Freitag 9-18 Uhr
- Leistungen: Allgemeine Zahnheilkunde, Kieferorthopädie, Zahnbleaching
- Neue Patienten-Beratungen sind kostenlos
- Notfalldienst verfügbar

Bestätigen Sie immer Termindetails vor dem Beenden von Anrufen.

# 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=ihr_sicheres_passwort
      - GENERIC_TIMEZONE=Europe/Berlin
      - WEBHOOK_URL=https://ihre-domain.de/
    volumes:
      - ./n8n-data:/home/node/.n8n
    networks:
      - automation-network

  # Optional: Webhook-Tunnel für lokale Entwicklung
  ngrok:
    image: ngrok/ngrok:latest
    command: http n8n:5678 --authtoken=${NGROK_AUTH_TOKEN}
    networks:
      - automation-network

networks:
  automation-network:
    driver: bridge

# Verzeichnisse erstellen
mkdir -p n8n-data

# Dienste starten
docker-compose up -d

# Logs prüfen
docker-compose logs -f n8n

// Node: TwiML generieren
const twiml = `<?xml version="1.0" encoding="UTF-8"?>
<Response>
  <Say voice="Polly.Vicki">
    Hallo! Danke, dass Sie Tropical Media anrufen.
    Unser KI-Assistent befindet sich derzeit in der Entwicklung.
    Bitte hinterlassen Sie eine Nachricht nach dem Ton.
  </Say>
  <Record maxLength="120" />
</Response>`;

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

[Twilio-Anruf] → [Webhook: Initiales Setup] → [WebSocket-Server]
                                              ↓
[ElevenLabs] ← [n8n-KI-Verarbeitung] ← [Speech-to-Text]
     ↓              ↓
[Sprachausgabe] → [Anrufer]

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

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

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

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

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

Sie sind ein hilfreicher KI-Empfangsdame/ein hilfreicher KI-Empfangsmitarbeiter 
für eine Zahnarztpraxis. Ihr Name ist Sarah.

Ihre Fähigkeiten:
- Termine für bestehende und neue Patienten planen
- Fragen zu Leistungen und Preisen beantworten
- Öffnungszeiten und Standortinformationen bereitstellen
- Notfälle durch Weiterleitung an den diensthabenden Zahnarzt behandeln

Bei der Terminplanung:
1. Vollständigen Namen des Patienten erfassen
2. Telefonnummer bestätigen
3. Nach bevorzugtem Datum und Uhrzeit fragen
4. Grund des Besuchs fragen (Kontrolle, Reinigung, etc.)
5. Alle Details vor dem Buchen bestätigen

Seien Sie immer herzlich, professionell und geduldig. Wenn Sie etwas nicht 
wissen, bieten Sie an, dass ein menschlicher Mitarbeiter zurückruft.

{
  "name": "check_availability",
  "description": "Verfügbare Terminslots für ein gegebenes Datum prüfen",
  "parameters": {
    "type": "object",
    "properties": {
      "date": {
        "type": "string",
        "format": "date",
        "description": "Zu prüfendes Datum (JJJJ-MM-TT)"
      },
      "appointment_type": {
        "type": "string",
        "enum": ["reinigung", "kontrolle", "beratung", "notfall"],
        "description": "Art des Termins"
      }
    },
    "required": ["date", "appointment_type"]
  }
}

{
  "name": "book_appointment",
  "description": "Termin für einen Patienten buchen",
  "parameters": {
    "type": "object",
    "properties": {
      "patient_name": {
        "type": "string",
        "description": "Vollständiger Name des Patienten"
      },
      "phone": {
        "type": "string",
        "description": "Telefonnummer des Patienten"
      },
      "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": "Anrufzusammenfassung an Empfangspersonal via Slack senden",
  "parameters": {
    "type": "object",
    "properties": {
      "summary": {
        "type": "string",
        "description": "Zusammenfassung des Anrufs"
      },
      "urgency": {
        "type": "string",
        "enum": ["niedrig", "mittel", "hoch"]
      }
    },
    "required": ["summary"]
  }
}

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

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

// Node: Kalender prüfen
const { date, appointment_type } = $input.first().json.parameters;

// Ihr Buchungssystem abfragen (Beispiel mit 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)
  }
});

// Verfügbare Slots formatieren
const slots = availability.slots.map(slot => 
  new Date(slot.time).toLocaleTimeString('de-DE', { 
    hour: '2-digit', 
    minute: '2-digit',
    hour12: false 
  })
);

return [{
  json: {
    result: {
      available: slots.length > 0,
      slots: slots.slice(0, 5), // Top 5 Slots zurückgeben
      date: date
    }
  }
}];

function getEventTypeId(type) {
  const map = {
    'reinigung': 123,
    'kontrolle': 124,
    'beratung': 125,
    'notfall': 126
  };
  return map[type] || 124;
}

// Node: Termin buchen
const params = $input.first().json.parameters;

// Buchung erstellen
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`, // Platzhalter
    location: 'Telefonische Beratung',
    metadata: {
      phone: params.phone,
      source: 'ai_voice_agent',
      notes: params.notes || ''
    }
  }
});

// In CRM speichern
await $httpRequest({
  method: 'POST',
  url: 'https://ihr-crm.de/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}`
  }
});

// Bestätigungs-SMS senden
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: `Hallo ${params.patient_name}, Ihr Termin am ${params.date} um ${params.time} Uhr ist bestätigt. Antworten Sie mit ABBRECHEN zum Umplanen.`
  },
  auth: {
    username: $env.TWILIO_ACCOUNT_SID,
    password: $env.TWILIO_AUTH_TOKEN
  }
});

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

// Node: An Slack senden
const { summary, urgency = 'niedrig' } = $input.first().json.parameters;

const urgencyEmoji = {
  'hoch': '🔴',
  'mittel': '🟡',
  'niedrig': '🟢'
};

await $httpRequest({
  method: 'POST',
  url: $env.SLACK_WEBHOOK_URL,
  body: {
    text: `${urgencyEmoji[urgency]} *KI-Sprachassistent Zusammenfassung*`,
    blocks: [
      {
        type: 'header',
        text: {
          type: 'plain_text',
          text: 'KI-Sprachassistent Anruf-Zusammenfassung'
        }
      },
      {
        type: 'section',
        fields: [
          {
            type: 'mrkdwn',
            text: `*Dringlichkeit:*\n${urgency}`
          },
          {
            type: 'mrkdwn',
            text: `*Zeit:*\n${new Date().toLocaleString('de-DE')}`
          }
        ]
      },
      {
        type: 'section',
        text: {
          type: 'mrkdwn',
          text: `*Zusammenfassung:*\n${summary}`
        }
      }
    ]
  }
});

return [{
  json: {
    result: {
      sent: true,
      channel: 'empfangsteam'
    }
  }
}];

// Node: An ElevenLabs zurückgeben
const toolResult = $input.first().json.result;

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

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

// Benutzerdefinierte Logik: Prüfen, ob Anrufer blockiert ist
const isBlocked = await checkBlockedList(from);

if (isBlocked) {
  return [{
    json: {
      headers: { 'Content-Type': 'text/xml' },
      body: `<?xml version="1.0"?>
<Response>
  <Say>Diese Nummer wurde blockiert.</Say>
  <Hangup/>
</Response>`
    }
  }];
}

// An ElevenLabs weiterleiten
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: Anruf weiterleiten
const { callSid, transferTo } = $input.first().json.parameters;

// Twilio-Weiterleitung mit Dial
const twiml = `<?xml version="1.0"?>
<Response>
  <Say>Ich verbinde Sie jetzt mit einem Teammitglied. Bitte warten.</Say>
  <Dial>
    <Number>${transferTo}</Number>
  </Dial>
</Response>`;

// Anruf via Twilio API aktualisieren
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": "Anruf an einen menschlichen Vertreter weiterleiten",
  "parameters": {
    "type": "object",
    "properties": {
      "department": {
        "type": "string",
        "enum": ["vertrieb", "support", "buchhaltung", "notfall"]
      },
      "reason": {
        "type": "string",
        "description": "Grund für die Weiterleitung"
      }
    },
    "required": ["department"]
  }
}

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

// OpenAI zur Spracherkennung verwenden
const detection = await $httpRequest({
  method: 'POST',
  url: 'https://api.openai.com/v1/chat/completions',
  body: {
    model: 'gpt-4o-mini',
    messages: [
      {
        role: 'system',
        content: 'Erkennen Sie die Sprache der Eingabenachricht. Geben Sie NUR den ISO 639-1-Code zurück (z.B. "de", "en", "fr", "th").'
      },
      {
        role: 'user',
        content: message
      }
    ]
  },
  headers: {
    'Authorization': `Bearer ${$env.OPENAI_API_KEY}`
  }
});

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

// Auf ElevenLabs-Stimme mappen
const voiceMap = {
  'de': 'XB0fDUnXU5powFXDhCwa',  // Deutsch
  'en': 'TX3AEvVoIzMeN6jBfAjZ',  // Englisch
  'fr': 'Hh1cR3w8I9fHNkEn11VW',  // Französisch
  'th': 'custom-thai-voice-id'     // Thailändisch
};

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

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

// Node: Twilio-Signatur verifizieren
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;

// String zum Signieren erstellen
let data = url;
Object.keys(params).sort().forEach(key => {
  data += key + params[key];
});

// Erwartete Signatur berechnen
const expectedSignature = crypto
  .createHmac('sha1', authToken)
  .update(Buffer.from(data, 'utf8'))
  .digest('base64');

// Verifizieren
if (twilioSignature !== expectedSignature) {
  return [{
    json: {
      statusCode: 403,
      body: { error: 'Ungültige Signatur' }
    }
  }];
}

// Verarbeitung fortsetzen
return $input.all();

// Node: Ratenlimit-Prüfung
const caller = $input.first().json.body.From;
const cacheKey = `rate_limit:${caller}`;

// Redis oder ähnlichen Cache prüfen
const callCount = await cache.get(cacheKey) || 0;

if (callCount > 10) { // Max. 10 Anrufe pro Stunde
  return [{
    json: {
      statusCode: 429,
      body: { error: 'Ratenlimit überschritten' }
    }
  }];
}

// Zähler erhöhen
await cache.set(cacheKey, callCount + 1, 'EX', 3600); // 1 Stunde TTL

return $input.all();

// Node: Anruf protokollieren
const callData = $input.first().json;

await $httpRequest({
  method: 'POST',
  url: 'https://ihr-logging-service.de/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,
    // Volle Transkripte nicht in öffentliche Logs schreiben
    transcript_hash: hashTranscript(callData.Transcript)
  }
});

// Workflow: Gesundheitsprüfung (alle 5 Minuten ausführen)
// 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: 'Sprachassistent-System beeinträchtigt',
      details: results.filter(r => !r.healthy)
    }
  });
}

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

Twilio: 100 Anrufe × 5 Min × $0.0085 = $4.25
Telefonnummer: $1.15
ElevenLabs: 500 Min × $0.05 = $25.00
OpenAI: ~$5.00
Deepgram: 500 Min × $0.0043 = $2.15
----------------------------------------
Gesamt: ~$37.55/Monat

vs. Menschlicher Empfang: $2.500+/Monat

# 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:

# Vom eigenen Netzwerk aus testen
curl -X POST https://ihre-webhook-url.de/webhook/twilio-voice \
  -d "CallSid=test" \
  -d "From=+491234567890"

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