API bidireccional

La API BiDiStreamingAnalyzeContent es la API principal para las experiencias de audio y multimodales de nueva generación tanto en Conversational Agents como en Agent Assist. Esta API facilita la emisión de datos de audio y te devuelve transcripciones o sugerencias de agentes humanos.

A diferencia de las APIs anteriores, la configuración de audio simplificada tiene una compatibilidad optimizada con las conversaciones entre personas y un plazo ampliado de 15 minutos. Además de la traducción en tiempo real, esta API también admite todas las funciones de Asistente que ofrece StreamingAnalyzeContent.

Conceptos básicos sobre el streaming

En el siguiente diagrama se muestra cómo funciona el flujo.

Inicia una emisión enviando una configuración de audio al servidor. Después, envías archivos de audio y el servidor te envía una transcripción o sugerencias para un agente humano. Envía más datos de audio para obtener más transcripciones y sugerencias. Este intercambio continúa hasta que lo finalizas cerrando el flujo por la mitad.

Guía de streaming

Para usar la API BiDiStreamingAnalyzeContent en el tiempo de ejecución de la conversación, sigue estas directrices.

  1. Llama al método BiDiStreamingAnalyzeContent y define los siguientes campos:
    • BiDiStreamingAnalyzeContentRequest.participant
    • (Opcional) BiDiStreamingAnalyzeContentRequest.voice_session_config.input_audio_sample_rate_hertz (si se especifica, se anula la configuración de ConversationProfile.stt_config.sample_rate_hertz).
    • (Opcional) BiDiStreamingAnalyzeContentRequest.voice_session_config.input_audio_encoding (si se especifica, se anula la configuración de ConversationProfile.stt_config.audio_encoding).
  2. Prepara la emisión y configura el audio con tu primera solicitud BiDiStreamingAnalyzeContent.
  3. En las solicitudes posteriores, envía bytes de audio a la emisión a través de BiDiStreamingAnalyzeContentRequest.audio.
  4. Después de enviar la segunda solicitud con una carga útil de audio, deberías recibir algunos BidiStreamingAnalyzeContentResponses de la emisión.
    • Los resultados de transcripción intermedios y finales están disponibles con el siguiente comando: BiDiStreamingAnalyzeContentResponse.recognition_result.
    • Puedes acceder a las sugerencias de agentes humanos y a los mensajes de conversaciones procesados con el siguiente comando: BiDiStreamingAnalyzeContentResponse.analyze_content_response.
  5. Puedes cerrar el stream a medias en cualquier momento. Después de cerrar el flujo por la mitad, el servidor envía la respuesta que contiene los resultados de reconocimiento restantes, junto con posibles sugerencias de Asistente para agentes.
  6. Inicia o reinicia una nueva emisión en los siguientes casos:
    • El flujo no funciona. Por ejemplo, la emisión se ha detenido cuando no debería.
    • Tu conversación se acerca al máximo de 15 minutos.
  7. Para obtener la mejor calidad, cuando inicies una emisión, envía los datos de audio generados después del último speech_end_offset del BiDiStreamingAnalyzeContentResponse.recognition_result con is_final=true a BidiStreamingAnalyzeContent.

Usar la API a través de la biblioteca de cliente de Python

Las bibliotecas de cliente te ayudan a acceder a las APIs de Google desde un lenguaje de programación concreto. Puedes usar la biblioteca de cliente de Python para Agent Assist con BidiStreamingAnalyzeContent de la siguiente manera.

from google.cloud import dialogflow_v2beta1
from google.api_core.client_options import ClientOptions
from google.cloud import storage

import time
import google.auth
import participant_management
import conversation_management


PROJECT_ID="your-project-id"
CONVERSATION_PROFILE_ID="your-conversation-profile-id"
BUCKET_NAME="your-audio-bucket-name"

SAMPLE_RATE =48000
# Calculate the bytes with Sample_rate_hertz * bit Depth / 8 -> bytes
# 48000(sample/second) * 16(bits/sample) / 8 = 96000 byte per second,
# 96000 / 10 = 9600 we send 0.1 second to the stream API
POINT_ONE_SECOND_IN_BYTES = 9600
FOLDER_PTAH_FOR_CUSTOMER_AUDIO="your-customer-audios-files-path" 
FOLDER_PTAH_FOR_AGENT_AUDIO="your-agent-audios-file-path"
client_options = ClientOptions(api_endpoint="dialogflow.googleapis.com")
credentials, _ = google.auth.default(scopes=["https://www.googleapis.com/auth/cloud-platform",
                                             "https://www.googleapis.com/auth/dialogflow"])

storage_client = storage.Client(credentials = credentials, project=PROJECT_ID)

participant_client = dialogflow_v2beta1.ParticipantsClient(client_options=client_options,
                                                           credentials=credentials)

def download_blob(bucket_name, folder_path, audio_array : list):
    """Uploads a file to the bucket."""
    bucket = storage_client.bucket(bucket_name, user_project=PROJECT_ID)
    blobs = bucket.list_blobs(prefix=folder_path)
    for blob in blobs:
      if not blob.name.endswith('/'):
          audio_array.append(blob.download_as_string())

def request_iterator(participant : dialogflow_v2beta1.Participant, audios):
    """Iterate the request for bidi streaming analyze content
    """

    yield dialogflow_v2beta1.BidiStreamingAnalyzeContentRequest(
        config={
            "participant": participant.name,
            "voice_session_config": {
                "input_audio_encoding": dialogflow_v2beta1.AudioEncoding.AUDIO_ENCODING_LINEAR_16,
                "input_audio_sample_rate_hertz": SAMPLE_RATE,
            },
        }
    )
    print(f"participant {participant}")

    for i in range(0, len(audios)):
      audios_array = audio_request_iterator(audios[i])
      for chunk in audios_array:
        if not chunk:
            break
        yield dialogflow_v2beta1.BidiStreamingAnalyzeContentRequest(
        input={
            "audio":chunk
            },
        )
        time.sleep(0.1)
    yield dialogflow_v2beta1.BidiStreamingAnalyzeContentRequest(
        config={
            "participant": participant.name,
        }
    )
    time.sleep(0.1)

def participant_bidi_streaming_analyze_content(participant, audios):
    """call bidi streaming analyze content API
    """
    bidi_responses = participant_client.bidi_streaming_analyze_content(
        requests=request_iterator(participant, audios)
    )

    for response in bidi_responses:
        bidi_streaming_analyze_content_response_handler(response)

def bidi_streaming_analyze_content_response_handler(response: dialogflow_v2beta1.BidiStreamingAnalyzeContentResponse):
    """Call Bidi Streaming Analyze Content
    """
    if  response.recognition_result:
         print(f"Recognition result: { response.recognition_result.transcript}", )

def audio_request_iterator(audio):
    """Iterate the request for bidi streaming analyze content
    """
    total_audio_length = len(audio)
    print(f"total audio length {total_audio_length}")
    array = []
    for i in range(0, total_audio_length, POINT_ONE_SECOND_IN_BYTES):
        chunk = audio[i : i + POINT_ONE_SECOND_IN_BYTES]
        array.append(chunk)
        if not chunk:
            break
    return array

def python_client_handler():
    """Downloads audios from the google cloud storage bucket and stream to
    the Bidi streaming AnalyzeContent site.
    """
    print("Start streaming")
    conversation = conversation_management.create_conversation(
        project_id=PROJECT_ID, conversation_profile_id=CONVERSATION_PROFILE_ID_STAGING
    )
    conversation_id = conversation.name.split("conversations/")[1].rstrip()
    human_agent = human_agent = participant_management.create_participant(
        project_id=PROJECT_ID, conversation_id=conversation_id, role="HUMAN_AGENT"
    )

    end_user =    end_user = participant_management.create_participant(
        project_id=PROJECT_ID, conversation_id=conversation_id, role="END_USER"
    )

    end_user_requests = []
    agent_request= []
    download_blob(BUCKET_NAME, FOLDER_PTAH_FOR_CUSTOMER_AUDIO, end_user_requests)
    download_blob(BUCKET_NAME, FOLDER_PTAH_FOR_AGENT_AUDIO, agent_request)

    participant_bidi_streaming_analyze_content( human_agent, agent_request)
    participant_bidi_streaming_analyze_content( end_user, end_user_requests)

    conversation_management.complete_conversation(PROJECT_ID, conversation_id)

Habilitar la integración de SipRec para telefonía

Puedes habilitar la integración de telefonía SipRec para usar BidiStreamingAnalyzeContent en el procesamiento de audio. Configura el procesamiento de audio con la consola de Asistente o con una solicitud directa a la API.

Consola

Sigue estos pasos para configurar el procesamiento de audio y usar BidiStreamingAnalyzeContent.

  1. Ve a la consola de Asistente y selecciona tu proyecto.

    Consola de Agent Assist

  2. Haz clic en Perfiles de conversación > el nombre de un perfil.

  3. Ve a Configuración de telefonía.

  4. Haga clic para habilitar Usar API de streaming bidireccional> Guardar.

API

Puedes llamar a la API directamente para crear o actualizar un perfil de conversación configurando la marca en ConversationProfile.use_bidi_streaming.

Ejemplo de configuración:

{
"name": "projects/PROJECT_ID/locations/global/conversationProfiles/CONVERSATION_PROFILE_ID",f
"displayName": "CONVERSATION_PROFILE_NAME",
"automatedAgentConfig": {
},
"humanAgentAssistantConfig": {
  "notificationConfig": {
    "topic": "projects/PROJECT_ID/topics/FEATURE_SUGGESTION_TOPIC_ID",
    "messageFormat": "JSON"
      },
  },
"useBidiStreaming": true,
"languageCode": "en-US"
}

Cuotas

El número de solicitudes simultáneas de BidiStreamingAnalyzeContent está limitado por una nueva cuota ConcurrentBidiStreamingSessionsPerProjectPerRegion. Consulta la Google Cloud guía de cuotas para obtener información sobre el uso de las cuotas y cómo solicitar un aumento del límite de cuota.

En el caso de las cuotas, el uso de solicitudes BidiStreamingAnalyzeContent al endpoint global de Dialogflow se encuentra en la región us-central1.