Bidirektionale API

Die BiDiStreamingAnalyzeContent API ist die primäre API für Audio- und multimodale Erlebnisse der nächsten Generation in Conversational Agents und Agent Assist. Diese API erleichtert das Streamen von Audiodaten und gibt entweder Transkriptionen oder Vorschläge für menschliche Agenten zurück.

Im Gegensatz zu früheren APIs bietet die vereinfachte Audiokonfiguration optimierte Unterstützung für Gespräche zwischen Menschen und eine verlängerte Frist von 15 Minuten. Mit Ausnahme der Live-Übersetzung unterstützt diese API auch alle Agent Assist-Funktionen, die von StreamingAnalyzeContent unterstützt werden.

Grundlagen zum Streaming

Das folgende Diagramm veranschaulicht die Funktionsweise des Streams.

Starten Sie einen Stream, indem Sie eine Audiokonfiguration an den Server senden. Anschließend senden Sie Audiodateien und der Server sendet Ihnen eine Transkription oder Vorschläge für einen menschlichen Agenten. Senden Sie weitere Audiodaten, um weitere Transkriptionen und Vorschläge zu erhalten. Dieser Austausch wird fortgesetzt, bis Sie ihn beenden, indem Sie den Stream halb schließen.

Streaming-Anleitung

Wenn Sie die BiDiStreamingAnalyzeContent API während der Unterhaltungslaufzeit verwenden möchten, folgen Sie dieser Anleitung.

  1. Rufen Sie die Methode BiDiStreamingAnalyzeContent auf und legen Sie die folgenden Felder fest:
    • BiDiStreamingAnalyzeContentRequest.participant
    • Optional: BiDiStreamingAnalyzeContentRequest.voice_session_config.input_audio_sample_rate_hertz. Wenn angegeben, wird die Konfiguration von ConversationProfile.stt_config.sample_rate_hertz überschrieben.
    • Optional: BiDiStreamingAnalyzeContentRequest.voice_session_config.input_audio_encoding. Wenn angegeben, wird die Konfiguration von ConversationProfile.stt_config.audio_encoding überschrieben.
  2. Bereiten Sie den Stream vor und legen Sie Ihre Audiokonfiguration mit der ersten BiDiStreamingAnalyzeContent-Anfrage fest.
  3. Senden Sie in nachfolgenden Anfragen Audiobytes über BiDiStreamingAnalyzeContentRequest.audio an den Stream.
  4. Nachdem Sie die zweite Anfrage mit einer Audio-Nutzlast gesendet haben, sollten Sie einige BidiStreamingAnalyzeContentResponses aus dem Stream erhalten.
    • Vorläufige und endgültige Transkriptionsergebnisse sind mit dem folgenden Befehl verfügbar: BiDiStreamingAnalyzeContentResponse.recognition_result.
    • Sie können mit dem folgenden Befehl auf Vorschläge für menschliche Agenten und verarbeitete Unterhaltungsnachrichten zugreifen: BiDiStreamingAnalyzeContentResponse.analyze_content_response.
  5. Sie können den Stream jederzeit halb schließen. Nachdem Sie den Stream halb geschlossen haben, sendet der Server die Antwort mit den verbleibenden Erkennungsergebnissen sowie potenziellen Agent Assist-Vorschlägen zurück.
  6. Starten Sie in den folgenden Fällen einen neuen Stream oder starten Sie ihn neu:
    • Der Stream ist unterbrochen. Beispielsweise wurde der Stream beendet, obwohl er nicht beendet werden sollte.
    • Ihre Unterhaltung nähert sich dem maximalen Limit von 15 Minuten.
  7. Um die beste Qualität zu erzielen, senden Sie beim Starten eines Streams Audiodaten, die nach dem letzten speech_end_offset von BiDiStreamingAnalyzeContentResponse.recognition_result mit is_final=true generiert wurden, an BidiStreamingAnalyzeContent.

API über die Python-Clientbibliothek verwenden

Clientbibliotheken helfen Ihnen, in einer bestimmten Programmiersprache auf Google APIs zuzugreifen. Sie können die Python-Clientbibliothek für Agent Assist mit BidiStreamingAnalyzeContent so verwenden:

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)
    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)

Für die Telefonie-SipRec-Integration aktivieren

Sie können die Telefonie-SipRec-Integration aktivieren, um BidiStreamingAnalyzeContent für die Audioverarbeitung zu verwenden. Konfigurieren Sie die Audioverarbeitung entweder mit der Agent Assist Console oder einer direkten API-Anfrage.

Console

Folgen Sie dieser Anleitung, um die Audioverarbeitung für die Verwendung von BidiStreamingAnalyzeContent zu konfigurieren.

  1. Rufen Sie die Agent Assist Console auf und wählen Sie Ihr Projekt aus.

    Agent Assist Console

  2. Klicken Sie auf Unterhaltungsprofile > den Namen eines Profils.

  3. Rufen Sie die Telefonieeinstellungen auf.

  4. Klicken Sie auf , um Bidirektionale Streaming-API verwenden zu aktivieren> Speichern.

API

Sie können die API direkt aufrufen, um ein Unterhaltungsprofil zu erstellen oder zu aktualisieren, indem Sie das Flag unter ConversationProfile.use_bidi_streaming konfigurieren.

Konfigurationsbeispiel:

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

Kontingente

Die Anzahl der gleichzeitigen BidiStreamingAnalyzeContent-Anfragen ist durch ein neues Kontingent begrenzt: ConcurrentBidiStreamingSessionsPerProjectPerRegion. Im Google Cloud Leitfaden zu Kontingenten finden Sie Informationen zur Kontingentnutzung und dazu, wie Sie eine Erhöhung des Kontingentlimits beantragen können.

Für Kontingente wird die Verwendung von BidiStreamingAnalyzeContent-Anfragen an die globalen und multiregionalen Dialogflow-Endpunkte in der Region us-central1 gezählt.