Внедрение платформы Retell AI для голосовых AI-агентов

Отметим: когда заказчик просит голосового агента, который не тупит на паузах и не ждёт три секунды перед ответом — стандартные IVR решения отпадают. Мы столкнулись с этим в проекте для финтех-компании: требовалось обрабатывать 500+ звонков в час с минимальной задержкой и возможностью прерывания. Retell AI оказался единственной платформой, где latency остаётся ниже 800 мс даже при кастомной LLM-логике. Мы внедрили его под ключ: настроили WebSocket стриминг, stateful-диалоги и интеграцию с CRM. Ниже — детали, как это работает и какие проблемы решает.

Проблемы, которые мы решаем

Разработка production-grade голосовых агентов — это не только про ASR и TTS. Основные технические сложности:

• Высокая задержка (latency): готовые решения вроде VAPI или Play.ht дают 1.5–3 секунды, что убивает конверсию. Retell с WebSocket стримингом укладывается в 500–800 мс, а с настройками streaming буферизации — ещё быстрее.
• Управление состоянием диалога: многоходовые сценарии (квалификация лида, запись на встречу, оплата) требуют хранения контекста. Retell позволяет держать stateful-сессию на вашем сервере, а не передавать историю с каждым запросом.
• Прерывания и backchannel: в реальном разговоре пользователь может перебить агента. Retell поддерживает interruption sensitivity и автоматические backchannel'ы ("угу", "да") — имитация живого общения.
• Интеграция с CRM и аналитикой: без webhook'ов и REST API агент слепой. Мы подключаем любые системы (Bitrix24, AmoCRM, Salesforce) и собираем полную аналитику звонков.

Снижение затрат на обработку звонков составляет 35-50% по сравнению с традиционным колл-центром, что подтверждают наши проекты.

Как мы добиваемся low-latency?

Ключевой элемент — двунаправленный WebSocket между инфраструктурой Retell и нашим LLM-сервером. В отличие от конкурентов, где запрос идёт через посредника, Retell передаёт голос напрямую, а текстовые транскрипты стримится в реальном времени. Согласно документации Retell AI, latency составляет 500-800 мс. Ниже — пример кастомного сервера на Python, который обрабатывает диалог через OpenAI gpt-4o:

import asyncio
import json
import websockets
from typing import AsyncGenerator


class RetellAgentServer:
    """ Кастомный LLM сервер для Retell AI.
    Retell подключается по WebSocket и ожидает streaming ответы.
    """

    def __init__(self, openai_client, system_prompt: str):
        self.openai = openai_client
        self.system_prompt = system_prompt

    async def handle_connection(self, websocket, path):
        """Обработка WebSocket сессии от Retell"""
        async for message in websocket:
            data = json.loads(message)

            if data.get("interaction_type") == "call_details":
                # Начало звонка — получаем метаданные
                call_info = data.get("call", {})
                print(f"New call: {call_info.get('call_id')}")
                continue

            if data.get("interaction_type") in ("response_required", "reminder_required"):
                # Пользователь что-то сказал или наступил таймаут
                transcript = data.get("transcript", [])

                # Генерируем ответ через OpenAI streaming
                async for chunk in self._generate_response(transcript):
                    response_message = {
                        "response_id": data.get("response_id"),
                        "content": chunk,
                        "content_complete": False,
                        "end_call": False,
                    }
                    await websocket.send(json.dumps(response_message))

                # Финальный чанк
                await websocket.send(json.dumps({
                    "response_id": data.get("response_id"),
                    "content": "",
                    "content_complete": True,
                    "end_call": False,
                }))

    async def _generate_response(self, transcript: list) -> AsyncGenerator[str, None]:
        """Стриминг ответа через OpenAI"""
        messages = [{"role": "system", "content": self.system_prompt}]

        for turn in transcript:
            role = "assistant" if turn["role"] == "agent" else "user"
            messages.append({"role": role, "content": turn["content"]})

        stream = await self.openai.chat.completions.create(
            model="gpt-4o",
            messages=messages,
            stream=True,
            temperature=0.7,
        )

        async for chunk in stream:
            delta = chunk.choices[0].delta.content
            if delta:
                yield delta


class RetellAPIClient:
    """Управление агентами через Retell REST API"""

    def __init__(self, api_key: str):
        import requests
        self.api_key = api_key
        self.base_url = "https://api.retellai.com"
        self.session = requests.Session()
        self.session.headers.update({
            "Authorization": f"Bearer {api_key}",
            "Content-Type": "application/json"
        })

    def create_agent(self, agent_name: str, llm_websocket_url: str, voice_id: str = "11labs-Adrian", language: str = "russian") -> dict:
        """
        Создание агента с кастомным LLM бэкендом.
        llm_websocket_url: ваш сервер для обработки диалога
        """
        payload = {
            "agent_name": agent_name,
            "llm_websocket_url": llm_websocket_url,
            "voice_id": voice_id,
            "language": language,
            "response_engine": {
                "type": "retell-llm",  # Или "custom-llm"
            },
            "responsiveness": 1.0,  # 0-1, насколько быстро реагирует
            "interruption_sensitivity": 1.0,
            "enable_backchannel": True,  # "угу", "да" во время пауз
            "backchannel_frequency": 0.9,
            "end_call_after_silence_ms": 600000,
            "max_call_duration_ms": 3600000,
        }
        return self.session.post(
            f"{self.base_url}/create-agent",
            json=payload
        ).json()

    def create_phone_call(self, from_number: str, to_number: str, agent_id: str, retell_llm_dynamic_variables: dict = None) -> dict:
        """Инициирование исходящего звонка"""
        payload = {
            "from_number": from_number,
            "to_number": to_number,
            "agent_id": agent_id,
        }
        if retell_llm_dynamic_variables:
            payload["retell_llm_dynamic_variables"] = retell_llm_dynamic_variables
        return self.session.post(
            f"{self.base_url}/create-phone-call",
            json=payload
        ).json()

Сравнение Retell AI с альтернативами

Сравните с типовым Twilio Autopilot или Dialogflow CX: у них latency 1.5–3 сек, нет встроенного прерывания, stateful-диалоги строятся через context — медленно и с ограничениями. Retell AI даёт выигрыш в 3–5 раз по скорости отклика и в 10 раз по гибкости сценариев. Например, в проекте для логистики мы внедрили агента, который в реальном времени сверяет статус заказа по API — time-to-response на запрос клиента снизился с 4 секунд до 700 мс.

Как работает управление прерываниями?

Механизм interruption sensitivity в Retell настраивается от 0 до 1. При значении 1.0 агент замолкает мгновенно, как только пользователь начинает говорить. Это критично для сценариев, где клиент хочет поправить ответ или задать уточняющий вопрос. В наших проектах мы дополнительно настраиваем backchannel'ы — короткие "угу" и "да" во время пауз, чтобы диалог звучал естественно. Без этого агент выглядит как робот, который ждёт полную тишину перед ответом.

Что такое stateful-диалог в Retell?

Это возможность хранить историю разговора на вашем сервере, а не передавать весь контекст с каждым запросом к LLM. Например, в сценарии квалификации лида агент может помнить, что клиент уже назвал бюджет и сроки, и не переспрашивать заново. Ниже — упрощённая реализация state-менеджера:

class ConversationStateManager:
    """Управление состоянием разговора для Retell"""

    def __init__(self, call_id: str, customer_id: str):
        self.call_id = call_id
        self.customer_id = customer_id
        self.state = "greeting"
        self.collected_data = {}
        self.escalation_triggers = ["оператор", "жалоба", "претензия", "руководитель"]

    def should_escalate(self, user_message: str) -> bool:
        """Определяем нужна ли передача живому оператору"""
        msg_lower = user_message.lower()
        return any(trigger in msg_lower for trigger in self.escalation_triggers)

    def get_context_prompt(self) -> str:
        """Динамический промпт на основе текущего состояния"""
        base = f"Текущий шаг: {self.state}. Уже собрано: {self.collected_data}."
        if self.state == "qualification":
            base += " Узнай: есть ли бюджет, сроки принятия решения, лицо принимающее решение."
        elif self.state == "scheduling":
            base += " Предложи 3 слота для встречи на следующей неделе."
        return base

Как мы внедряем Retell AI: пошаговая инструкция

1. Аналитика и проектирование: разбираем сценарии, пишем decision tree, определяем точки эскалации.
2. Настройка инфраструктуры: разворачиваем WebSocket сервер, подключаем модель (GPT-4o, Claude, YaGPT), настраиваем MLOps (MLflow, Weights & Biases).
3. Разработка логики: пишем state machine, интеграции с CRM, динамические промпты.
4. Тестирование: симуляция звонков, замеры latency, A/B тесты ответов.
5. Деплой и мониторинг: запуск в production, настройка алертов по p99 latency и rate limit'ам.

Что входит в работу

• Документация: архитектурная схема, описание webhook'ов, инструкция по обслуживанию агента.
• Интеграция: подключение CRM, базы знаний, внешних API через webhook и REST.
• Обучение: передача скриптов и регламентов для поддержки агента.
• Поддержка: гарантия 30 дней после внедрения, дальше — SLA.

Платформа идеальна для сложных сценариев: квалификация лидов с динамическим скорингом, запись на встречи с интеграцией календаря, обработка заказов с проверкой статуса по API. Прототип — 3-4 дня, production с интеграциями — 4-6 недель.

Метрики Retell AI

Сравнение Retell AI с альтернативами

Закажите внедрение Retell AI в вашу инфраструктуру. Получите консультацию по вашему проекту — оценим feasibility и сроки. Свяжитесь с нами для детального обсуждения вашего проекта. Мы гарантируем, что внедрённый агент будет работать с latency < 1 сек и обрабатывать до 1000 одновременных звонков.