Esta página foi traduzida pela API Cloud Translation.

API bidirecional

A API BiDiStreamingAnalyzeContent é a API principal para experiências de áudio e multimodais de próxima geração nos agentes conversacionais e no Agent Assist. Esta API facilita o streaming de dados de áudio e devolve transcrições ou sugestões de agentes humanos.

Ao contrário das APIs anteriores, a configuração de áudio simplificada tem um suporte otimizado para conversas entre humanos e um limite de prazo alargado de 15 minutos. Exceto para a tradução em tempo real, esta API também suporta todas as funcionalidades do Agent Assist suportadas pelo StreamingAnalyzeContent.

Noções básicas de streaming

O diagrama seguinte ilustra como funciona a stream.

Inicie uma stream enviando uma configuração de áudio para o servidor. Em seguida, envia ficheiros de áudio e o servidor envia-lhe uma transcrição ou sugestões para um agente humano. Envie mais dados de áudio para ter mais transcrições e sugestões. Esta troca continua até a terminar fechando parcialmente a stream.

Guia de streaming

Para usar a API BiDiStreamingAnalyzeContent no tempo de execução da conversa, siga estas diretrizes.

Chame o método BiDiStreamingAnalyzeContent e defina os seguintes campos:
- BiDiStreamingAnalyzeContentRequest.participant
- (Opcional) BiDiStreamingAnalyzeContentRequest.voice_session_config.input_audio_sample_rate_hertz (Quando especificado, substitui a configuração de ConversationProfile.stt_config.sample_rate_hertz.)
- (Opcional) BiDiStreamingAnalyzeContentRequest.voice_session_config.input_audio_encoding (Quando especificado, substitui a configuração de ConversationProfile.stt_config.audio_encoding.)
Prepare a stream e defina a configuração de áudio com o seu primeiro pedido BiDiStreamingAnalyzeContent.
Em pedidos subsequentes, envie bytes de áudio para a stream através de BiDiStreamingAnalyzeContentRequest.audio.
Depois de enviar o segundo pedido com uma carga útil de áudio, deve receber alguns BidiStreamingAnalyzeContentResponses da stream.
- Os resultados de transcrição intermédios e finais estão disponíveis com o seguinte comando: BiDiStreamingAnalyzeContentResponse.recognition_result.
- Pode aceder às sugestões de agentes humanos e às mensagens de conversas processadas com o seguinte comando: BiDiStreamingAnalyzeContentResponse.analyze_content_response.
Pode fechar parcialmente a stream em qualquer altura. Depois de fechar parcialmente a transmissão, o servidor envia de volta a resposta com os resultados de reconhecimento restantes, juntamente com potenciais sugestões do Agent Assist.
Inicie ou reinicie uma nova stream nos seguintes casos:
- O stream está danificado. Por exemplo, a stream parou quando não devia.
- A sua conversa está a aproximar-se do máximo de 15 minutos.
Para ter a melhor qualidade, quando iniciar uma stream, envie os dados de áudio gerados após o último speech_end_offset do BiDiStreamingAnalyzeContentResponse.recognition_result com is_final=true para BidiStreamingAnalyzeContent.

Use a API através da biblioteca cliente Python

As bibliotecas cliente ajudam a aceder às APIs Google a partir de uma linguagem de programação específica. Pode usar a biblioteca cliente Python para o Agent Assist com o BidiStreamingAnalyzeContent da seguinte forma.

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)

Ative a integração do SipRec de telefonia

Pode ativar a integração SipRec de telefonia para usar o BidiStreamingAnalyzeContent para o processamento de áudio. Configure o processamento de áudio com a consola do Agent Assist ou um pedido direto da API.

Consola

Siga estes passos para configurar o processamento de áudio de modo a usar o BidiStreamingAnalyzeContent.

Aceda à consola do Agent Assist e selecione o seu projeto.

Consola do Agent Assist
Clique em Perfis de conversa > o nome de um perfil.
Navegue para Definições de telefonia.
Clique para ativar a opção Usar API de streaming bidirecional> Guardar.

API

Pode chamar a API diretamente para criar ou atualizar um perfil de conversa configurando a flag em ConversationProfile.use_bidi_streaming.

Exemplo de configuração:

{
"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"
}

Quotas

O número de pedidos BidiStreamingAnalyzeContent simultâneos está limitado por uma nova quota ConcurrentBidiStreamingSessionsPerProjectPerRegion. Consulte o Google Cloud guia de quotas para ver informações sobre a utilização de quotas e como pedir um aumento do limite de quotas.

Para quotas, a utilização de pedidos BidiStreamingAnalyzeContent para o ponto final global do Dialogflow está na região us-central1.

API bidirecional Mantenha tudo organizado com as coleções Salve e categorize o conteúdo com base nas suas preferências.