Entwickeln Sie Echtzeit-KI-Voice-Assistenten mit Pipecat, AgentCore und Vonage

Einführung

Entwickler können nun KI-Agenten direkt in laufende Telefonate integrieren. Anstelle von statischen IVR-Menüs oder vorprogrammierten Bots können Sie KI-Agenten entwickeln, die zuhören, natürlich reagieren und konkrete Maßnahmen ergreifen – und das alles über ein normales Vonage-Telefonat.

In diesem Tutorial werden Sie einen KI-Agenten für Voice-Anrufe mithilfe des Vonage Audio Serializer für Pipecat und AWS Nova Sonic. 

Am Ende dieses Tutorials werden Sie Folgendes wissen:

• Ein funktionierender KI-Voice-Assistent, der echte Anrufe über Ihre Vonage-Nummer entgegennimmt

• Eine Pipecat-Pipeline auf Basis von Amazon Nova Sonic für Sprach-zu-Sprache-Gespräche in Echtzeit

• Eine KI-Agenten-Laufzeitumgebung, die innerhalb von AWS Bedrock AgentCore bereitgestellt wurde und dort ausgeführt wird

• Eine vollständig containerisierte App, bei der Ihr Vonage-Server als authentifizierte Brücke zwischen Vonage-Voice-Anrufen und Ihrem von AgentCore gehosteten Agenten fungiert

Fahren Sie fort und finden Sie den Arbeitscode für dieses Beispiel auf GitHub.

In diesem Tutorial wird der Vonage Audio Serializer für Pipecat, das Pipecat-Plugin (VonageFrameSerializer), das eine Verbindung zum Vonage Voice WebSocket herstellt und PCM-Audio-Frames zwischen dem WebSocket-Format von Vonage und dem internen Pipeline-Format von Pipecat konvertiert. Es ist für reine Audio-Anwendungsfälle mit KI sowohl über die Vonage Voice API als auch über die Video API konzipiert (keine Videoverarbeitung erforderlich). 

Dieser Pfad verbindet Vonage-Voice- und Video-Sitzungen über WebSocket mit Pipecat-Pipelines. Wenn Sie eine vollständige Videobildverarbeitung oder Video-Avatare benötigen, lesen Sie den Abschnitt Vonage Video Transport für Pipecat .

Dies ist Teil 2 einer zweiteiligen Serie über die Entwicklung von KI-Voice-Assistenten mit Vonage und Pipecat:

• Teil 1 behandelt den Vonage Video Transport für Pipecat, den WebRTC-Pfad für KI-Agenten, die an Vonage-Video-Sitzungen teilnehmen.

• Teil 2 (dieser Beitrag) befasst sich mit dem Vonage Audio Serializer für Pipecat, den WebSocket-Pfad für Anwendungsfälle im Bereich Voice und Telefonie.

Voraussetzungen

Bevor Sie beginnen, vergewissern Sie sich, dass Sie die folgenden Informationen haben:

• Ein AWS-Account mit Zugriff auf Amazon Bedrock und Nova Sonic (amazon.nova-2-sonic-v1:0) in us-east-1

• Python 3.12 oder höher – das Paket „aws_sdk_bedrock_runtime“ (für Nova Sonic erforderlich) wird nur für Python 3.12 und höher bereitgestellt.

• Docker Desktop — Die App läuft in Docker und bietet so eine isolierte, reproduzierbare Laufzeitumgebung

• ngrok mit einer reservierten Domain für eine stabile Vonage-Webhook-URL

• AWS-CLI konfiguriert (aws configure --profile vonage-dev)

• bedrock-agentcore-starter-toolkit CLI (pip install bedrock-agentcore-starter-toolkit) für die Bereitstellung zur Laufzeit

• A Vonage-API-Account mit aktivierter Voice API und einer mit einer Voice-Anwendung verknüpften Telefonnummer

Wichtige Komponenten

Hinweis: AgentCore ist das zugrunde liegende Framework, auf dem Bedrock Agents selbst aufbaut. Durch die direkte Nutzung von AgentCore erhalten Sie als Entwickler die volle Kontrolle über die Agentenlogik, Frameworks und Modelle, ohne die übergeordneten Abstraktionen von Bedrock Agents.

Überblick über die Architektur

Vonage Voice API -> App Runner /answer -> AgentCore Runtime -> Vonage Audio Serializer for Pipecat -> Pipecat Pipeline -> AWS Nova Sonic

Lokale Entwicklung

Vonage-Voice-Anruf
  ↓ GET /answer
ngrok → FastAPI /answer (app/main.py, Port 8000)
  ↓ gibt NCCO mit wss://your-reserved-domain.ngrok.app/ws zurück
Vonage stellt eine Verbindung zu FastAPI /ws her
  ↓
VonageFrameSerializer + FastAPIWebsocketTransport
  ↓
Pipecat-Pipeline → Amazon Nova Sonic

Produktion

Vonage-Voice-Anruf
  ↓ GET /answer
App Runner (answer/server.py – öffentlicher HTTPS-Endpunkt)
  ↓ AgentCoreRuntimeClient.generate_presigned_url()
  ↓ gibt NCCO mit wss://bedrock-agentcore.us-east-1.amazonaws.com/runtimes/{arn}/ws zurück
Vonage stellt eine direkte Verbindung zu AgentCore Runtime /ws her
  ↓
AgentCore Runtime (runtime/agent.py, Port 8080)
  ↓ BedrockAgentCoreApp @app.websocket /ws
  ↓ await websocket.accept()
VonageFrameSerializer + FastAPIWebsocketTransport
  ↓
Pipecat-Pipeline → Amazon Nova Sonic

Schritt 1: Klonen des Repositorys

git clone https://github.com/Vonage-Community/vonage-pipecat-serializer-voice-aws-agentcore.git
cd vonage-pipecat-serializer-voice-aws-agentcore

Das Repository hat zwei Bereitstellungsziele:

├── app/ ← Lokale Entwicklung: vollständige FastAPI-App (Port 8000)
├── runtime/ ← Produktion: AgentCore-Runtime-Container (Port 8080)
└── answer/ ← Produktion: App Runner / Antwort-Handler

Schritt 2: Konfigurieren Sie Ihre Umgebung

Verwenden Sie in der Produktion immer IAM-Rollen oder temporäre Anmeldeinformationen. Geben Sie AWS-Geheimnisse niemals fest in Ihren Code ein oder übergeben Sie sie an die Versionskontrolle.

Um loszulegen, duplizieren Sie die bereitgestellte .env.example Datei wie folgt .env:

cp .env.example .env

Öffnen Sie die .env Datei und geben Sie Ihre Anmeldedaten ein:

# Vonage Voice API
VONAGE_APPLICATION_ID=your-vonage-application-id
VONAGE_PRIVATE_KEY=private.key
VONAGE_NUMBER=+14155551234
VONAGE_CALL_ID=your-vonage-call-id          # local/tests only

# AWS
AWS_PROFILE=vonage-dev
AWS_REGION=us-east-1
BEDROCK_MODEL_ID=amazon.nova-2-sonic-v1:0
BEDROCK_CONNECT_TIMEOUT_SECONDS=10
BEDROCK_READ_TIMEOUT_SECONDS=60
BEDROCK_MAX_ATTEMPTS=4
BEDROCK_VALIDATE_MODEL_ID=true

# AgentCore
AGENTCORE_AGENT_ARN=arn:aws:bedrock-agentcore:us-east-1:123456789012:runtime/your-runtime-id   # local bootstrap (optional)
AGENTCORE_RUNTIME_ARN=arn:aws:bedrock-agentcore:us-east-1:123456789012:runtime/your-runtime-id  # production /answer webhook

# Nova Sonic session guard
NOVA_SESSION_WARN_SECONDS=410
NOVA_SESSION_LIMIT_SECONDS=470
NOVA_SESSION_STOP_ON_LIMIT=false

# Agent behavior (local dev via .env; production via runtime/agent.py defaults)
BEDROCK_SYSTEM_INSTRUCTION=You are a helpful voice assistant. Respond warmly and briefly.
BEDROCK_INITIAL_USER_MESSAGE=Hello! How can I help you today?
AGENTCORE_BOOTSTRAP_PROMPT=Provide one short greeting plus one helpful follow-up question for a live voice assistant session.

# App
PORT=8000

Konfigurieren Sie Ihr AWS-Profil:

aws configure --profile vonage-dev
export AWS_PROFILE=vonage-dev
aws sts get-caller-identity --profile vonage-dev

Hinweis: Der Webhook-Ablauf der Produktions-App erfordert keine VONAGE_CALL_ID zur Laufzeit. Vonage ruft /answer, empfängt den NCCO und verbindet die Medien anschließend /ws automatisch.

Schritt 3: Erstellen des Vonage-Audio-Serialisierers für die Pipecat-Pipeline

app/agent.py (lokale Entwicklung) und runtime/agent.py (Produktion) implementieren die Voice-Pipeline – eine Instanz pro eingehender Vonage-WebSocket-Verbindung. Der Vonage Audio Serializer für Pipecat übernimmt die gesamte Konvertierung von PCM-Audio-Frames zwischen dem WebSocket-Format von Vonage und dem internen Pipeline-Format von Pipecat.

from pipecat.audio.vad.silero import SileroVADAnalyzer
from pipecat.pipeline.pipeline import Pipeline
from pipecat.pipeline.runner import PipelineRunner
from pipecat.pipeline.task import PipelineParams, PipelineTask
from pipecat.serializers.vonage import VonageFrameSerializer
from pipecat.services.aws.nova_sonic.llm import AWSNovaSonicLLMService, Params
from pipecat.transports.websocket.fastapi import (
    FastAPIWebsocketParams,
    FastAPIWebsocketTransport,
)

# Vonage telephony-grade audio framing: 640 bytes = 20ms @ 16kHz PCM16 mono
# 16kHz is the standard sample rate used in this tutorial. The Vonage Voice WebSocket
# also supports 8kHz and up to 24kHz, but 16kHz is the recommended default for Nova Sonic.

serializer = VonageFrameSerializer(
    params=VonageFrameSerializer.InputParams(
        vonage_sample_rate=16000,
    )
)

transport = FastAPIWebsocketTransport(
    websocket=websocket,
    params=FastAPIWebsocketParams(
        audio_in_enabled=True,
        audio_out_enabled=True,
        add_wav_header=False,
        fixed_audio_packet_size=640,  # 20ms PCM frame at 16kHz
        serializer=serializer,
        vad_analyzer=SileroVADAnalyzer(),
    ),
)

# AWS Nova Sonic — speech-to-speech AI
nova_sonic = AWSNovaSonicLLMService(
    access_key_id=frozen_credentials.access_key,
    secret_access_key=frozen_credentials.secret_key,
    session_token=frozen_credentials.token,
    region=aws_region,
    model=bedrock_model_id,
    params=Params(
        input_sample_rate=16000,
        input_channel_count=1,
        output_sample_rate=16000,
        output_channel_count=1,
    ),
    system_instruction=system_instruction,
)

# 3-stage speech-to-speech pipeline
pipeline = Pipeline([
    transport.input(),   # Audio in from Vonage phone call
    nova_sonic,          # Speech-to-speech AI processing
    transport.output(),  # Audio out back to caller
])

Beachten Sie, dass 16 kHz die in diesem Tutorial verwendete Standard-Abtastrate ist. Der Vonage Voice WebSocket unterstützt auch 8 kHz und bis zu 24 kHz, jedoch ist 16 kHz die empfohlene Standardeinstellung für Nova Sonic.

Schritt 4: Stellen Sie Ihren Agenten mit AgentCore bereit

AgentCore ist die verwaltete Laufzeitumgebung von AWS Bedrock für die Bereitstellung und Skalierung von KI-Agenten in der Produktion, ohne dass Sie Server oder die Container-Infrastruktur selbst verwalten müssen. Sie ist allgemein verfügbar (GA).

In diesem Projekt fungiert AgentCore als Laufzeitumgebung – der gesamte Pipecat-Agent läuft innerhalb der AgentCore-Laufzeitumgebung.

Wie Bedrock und AgentCore zusammenarbeiten

Kurzfassung: Bedrock liefert die Antworten. AgentCore steuert Ihren Agenten.

So funktioniert es in dieser App

Wenn ein Vonage-Anruf eingeht, verarbeitet App Runner den /answer Webhook, generiert eine neue, vorab signierte AgentCore-WebSocket-URL und gibt diese im NCCO zurück. Vonage stellt über diese URL eine direkte Verbindung zur AgentCore-Laufzeitumgebung her. AgentCore leitet die Verbindung an den /ws Handler weiter, wo VonageFrameSerializer und die Pipecat-Pipeline die weitere Bearbeitung übernehmen.

Die runtime/agent.py Datei ist Ihrem Produktionsagenten – sie wird innerhalb AgentCore aus, nicht als Aufrufer desselben.

Wesentliche strukturelle Unterschiede gegenüber app/agent.py (lokale Entwicklung)

# runtime/agent.py — runs inside AgentCore Runtime
from bedrock_agentcore.runtime import BedrockAgentCoreApp
from starlette.websockets import WebSocket

app = BedrockAgentCoreApp()

@app.websocket
async def ws_handler(websocket: WebSocket, context) -> None:
    await websocket.accept()  # mandatory — BedrockAgentCoreApp does not auto-accept
    # VonageFrameSerializer + FastAPIWebsocketTransport + Nova Sonic pipeline run here

await websocket.accept() muss explizit aufgerufen werden. BedrockAgentCoreApp WebSocket-Verbindungen werden nicht automatisch akzeptiert. Wird diese Funktion weggelassen, schließt AgentCore die Verbindung mit dem Fehler 1008 „Schreibpuffergrenze überschritten“.

Sie können die Begrüßung und den Charakter anpassen, indem Sie runtime/agent.py , indem du die BEDROCK_SYSTEM_INSTRUCTION und BEDROCK_INITIAL_USER_MESSAGE Standardwerte. Stellen Sie die Warteschlange LLMRunFrame() bei der Verbindung, um ein Timeout des Nova Sonic 532 zu verhindern.

Stellen Sie Ihren eigenen AgentCore-Agenten bereit

pip install bedrock-agentcore-starter-toolkit

cd runtime/

agentcore configure \
  -e agent.py \
  -r us-east-1 \
  -n your_agent_name \
  --non-interactive \
  --deployment-type direct_code_deploy \
  --runtime PYTHON_3_12 \
  -rf requirements.txt

AWS_PROFILE=vonage-dev agentcore deploy -a your_agent_name
# → Copy Runtime ARN from output — you'll need it for App Runner configuration

AWS_PROFILE=vonage-dev agentcore deploy -a your_agent_name --auto-update-on-conflict  # redeploy after changes

Ihr Agent läuft nun in AgentCore. Vonage stellt über die vorab signierte URL eine direkte Verbindung zum /ws Endpunkt von AgentCore; EC2, ECS oder EKS sind nicht erforderlich.

App Runner bereitstellen /answer Handler

App Runner verarbeitet den Webhook „Vonage Answer URL“. App Runner ist ein kleiner Docker-Container, der in die AWS Elastic Container Registry hochgeladen und mithilfe des AWS apprunner Befehl bereitgestellt. Er generiert für jeden Anruf eine neue, vorab signierte AgentCore-WebSocket-URL und gibt diese im NCCO zurück:

# answer/answer.py
from bedrock_agentcore.runtime import AgentCoreRuntimeClient
import uuid

client = AgentCoreRuntimeClient(region="us-east-1")

def get_presigned_url(runtime_arn: str) -> str:
    return client.generate_presigned_url(
        runtime_arn,
        session_id=str(uuid.uuid4()),  # unique session per call
    )

Verwenden Sie NICHT das „boto3“-Raw-Modul generate_presigned_url('invoke_agent_runtime', ...). Dies erzeugt eine HTTPS-POST-URL, die beim WebSocket-Upgrade den HTTP-Status 405 zurückgibt. Verwenden Sie AgentCoreRuntimeClient aus bedrock_agentcore.runtime.

# Build and push to ECR
docker build --platform linux/amd64 -t vonage-agentcore-answer ./answer
docker push {account}.dkr.ecr.us-east-1.amazonaws.com/vonage-agentcore-answer:latest

# App Runner environment variables:
# AGENTCORE_RUNTIME_ARN = <runtime-arn-from-agentcore-deploy>
# VONAGE_NUMBER = <your-vonage-number>
# AWS_DEFAULT_REGION = us-east-1

Legen Sie die „Answer URL“ Ihrer Vonage Voice-Anwendung auf Ihren App Runner-Endpunkt fest:

https://{service-id}.us-east-1.awsapprunner.com/answer

Wos {​service-id} her? AWS generiert diese eindeutige ID automatisch, wenn Sie den App Runner-Dienst erstellen. Die vollständige Dienst-URL finden Sie in der App Runner-Konsole oder durch Ausführen des folgenden Befehls:

aws apprunner describe-service \ --service-arn <your-service-arn> \ --query 'Service.ServiceUrl'

Die URL wird außerdem in der Ausgabe von „aws apprunner create-service“ angezeigt, wenn Sie den Dienst zum ersten Mal bereitstellen.

Siehe hier README.md für die vollständigen Schritte zur Bereitstellung von App Runner (Docker → ECR → aws apprunner create-service).

Schritt 5: Führen Sie einen Testanruf durch

Rufen Sie Ihre Vonage-Nummer an. Wenn Vonage eine GET /answer Anfrage sendet, generiert App Runner eine neue, vorab signierte AgentCore-WebSocket-URL und gibt diese im NCCO zurück:

[
  {
    "action": "connect",
    "from": "VONAGE_NUMBER",
    "endpoint": [
      {
        "type": "websocket",
        "uri": "wss://bedrock-agentcore.us-east-1.amazonaws.com/runtimes/{arn}/ws?X-Amz-Algorithm=...",
        "content-type": "audio/l16;rate=16000"
      }
    ]
  }
]

Warum verweist das NCCO direkt auf AgentCore?

App Runner generiert zum Zeitpunkt der Antwort eine neue, vorab signierte SigV4-URL, und Vonage stellt über diese URL sofort eine Verbindung her. Die vorab signierte URL läuft nach 300 Sekunden ab, doch die WebSocket-Verbindung bleibt, sobald sie hergestellt ist, für die gesamte Dauer des Anrufs bestehen. App Runner übernimmt die AWS-Authentifizierung; Vonage nutzt lediglich die URL.

Für die lokale Entwicklung verweist die NCCO stattdessen über ngrok auf Ihren lokalen Server:

[
  {
    "action": "connect",
    "from": "VONAGE_NUMBER",
    "endpoint": [
      {
        "type": "websocket",
        "uri": "wss://your-reserved-domain.ngrok.app/ws",
        "content-type": "audio/l16;rate=16000"
      }
    ]
  }
]

Der gesamte Anrufablauf

1. Der Anrufer wählt Ihre Vonage-Nummer

2. Vonage sendet GET /answer an App Runner

3. App Runner ruft AgentCoreRuntimeClient.generate_presigned_url(), generiert eine neue, vorab signierte AgentCore-WSS-URL

4. App Runner gibt NCCO mit einer vorab signierten URL zurück

5. Vonage stellt eine direkte Verbindung zu AgentCore Runtime her /ws über eine vorab signierte URL

6. runtime/agent.py Anrufe await websocket.accept(), VonageFrameSerializer initialisiert

7. Pipecat-Pipeline startet, Nova Sonic verarbeitet Sprache-zu-Sprache-Umwandlung in Echtzeit

8. Die Audioantwort wird an den Anrufer zurückgesendet

Für die lokale Entwicklung stellen Sie Ihren Server mit ngrok bereit:

ngrok http --domain=your-reserved-domain.ngrok.app 8000

Legen Sie Ihre Vonage-Antwort-URL https://your-reserved-domain.ngrok.app/answer im Vonage-Dashboard ein.

Stellen Sie für die Produktion Ihre Vonage-Antwort-URL auf Ihre App-Runner-Domain ein (siehe diese Seite zur Einrichtung der Antwort-URL der Voice-App im Vonage-Dashboard):

https://{service-id}.us-east-1.awsapprunner.com/answer

Um den Anruf programmgesteuert zu beenden (lokale Entwicklung):

curl -X POST http://localhost:8000/hangup

Bereitstellung für die Produktion

Diese App nutzt zwei verwaltete AWS-Dienste für den Produktivbetrieb; EC2, ECS, EKS, ALB oder nginx sind nicht erforderlich.

Produktionsarchitektur

Vonage-Voice-Anruf
  ↓ GET /answer
App Runner (answer/ — öffentlicher HTTPS-Endpunkt, automatisch generierte URL)
  ↓ AgentCoreRuntimeClient.generate_presigned_url()
  ↓ gibt eine NCCO mit einer vorab signierten AgentCore-WSS-URL zurück
Vonage stellt eine direkte Verbindung zu AgentCore Runtime /ws her
  ↓
AgentCore Runtime (runtime/ — Port 8080)
  ↓ VonageFrameSerializer + Pipecat-Pipeline
  ↓
Nova Sonic (Speech-to-Speech)

Was ändert sich zwischen der lokalen Entwicklungsumgebung und der Produktionsumgebung?

Was sich nie ändert: VonageFrameSerializer, die Pipecat-Pipeline und Nova Sonic, die in beiden Umgebungen identisch sind.

Schritt 1: AgentCore-Laufzeitumgebung bereitstellen

cd runtime/
agentcore configure -e agent.py -r us-east-1 -n your_agent_name \
  --non-interactive --deployment-type direct_code_deploy --runtime PYTHON_3_12 -rf requirements.txt
AWS_PROFILE=vonage-dev agentcore deploy -a your_agent_name
# → Copy Runtime ARN from output

Schritt 2: App-Runner-Image erstellen und hochladen

TMPDIR=$(mktemp -d)
ECR="{account}.dkr.ecr.us-east-1.amazonaws.com/vonage-agentcore-answer"

docker build --platform linux/amd64 -t vonage-agentcore-answer ./answer
docker tag vonage-agentcore-answer:latest $ECR:latest

ECR_PASS=$(aws ecr get-login-password --region us-east-1)
echo "$ECR_PASS" | DOCKER_CONFIG="$TMPDIR" docker login \
  --username AWS --password-stdin {account}.dkr.ecr.us-east-1.amazonaws.com
DOCKER_CONFIG="$TMPDIR" docker push $ECR:latest

App-Runner-Dienst bei der ersten Bereitstellung erstellen: siehe README.md für den vollständigen aws apprunner create-service JSON-Daten. Nach answer/ Änderungen:

aws apprunner start-deployment \
  --service-arn "arn:aws:apprunner:us-east-1:{account-id}:service/vonage-agentcore-answer/{service-id}" \
  --region us-east-1

Schritt 3: Umgebungsvariablen des App Runners aktualisieren

aws apprunner update-service --service-arn <arn> \
  --source-configuration '{
    "ImageRepository": {
      "ImageConfiguration": {
        "RuntimeEnvironmentVariables": {
          "AGENTCORE_RUNTIME_ARN": "<runtime-arn-from-step-1>",
          "VONAGE_NUMBER": "<your-vonage-number>",
          "AWS_DEFAULT_REGION": "us-east-1"
        }
      }
    }
  }'

Schritt 4: Vonage-Antwort-URL festlegen

Im Vonage-Dashboardaktualisieren Sie die Antwort-URL Ihrer Voice-Anwendung auf Ihren App-Runner-Endpunkt:

https://{your-app-runner-url}.us-east-1.awsapprunner.com/answer

Verify, ob ein gültiger NCCO zurückgegeben wird:

curl "https://{service-id}.{region}.awsapprunner.com/answer"

Einrichtung von App Runner IAM

Ein Hinweis zu den URLs von Lambda-Funktionen

Die AWS-Referenzimplementierung für dieses Muster kann eine Lambda-Funktions-URL als /answer Handler verwenden. Sofern Ihr AWS-Account dies zulässt lambda:InvokeFunctionUrl, ist Lambda eine einfachere Alternative – die Logik zur Generierung der vorsignierten URL ist identisch. App Runner wird hier verwendet, da es mit allen AWS-Account-Konfigurationen funktioniert, einschließlich solcher mit SCPs auf Organisationsebene, die öffentliche Lambda-Aufrufe einschränken.

Gesamtzahl der AWS-Ressourcen: 1 AgentCore-Laufzeitumgebung + 1 App Runner-Dienst + 1 ECR-Repository.

Checkliste Produktion

• Laufzeit: Verwenden Sie Python 3.12 für die AgentCore-Laufzeitumgebung; Nova Sonic stürzt unter 3.11 ohne Fehlermeldung ab

• WebSocket: await websocket.accept() als erste Zeile im runtime/agent.py @app.websocket Handler

• Erste Begrüßung: set BEDROCK_INITIAL_USER_MESSAGE ein, um ein Timeout von Nova Sonic 532 zu verhindern

• Vorgesignierte URL: Verwende AgentCoreRuntimeClient.generate_presigned_url(), nicht rohes boto3 invoke_agent_runtime presign

• IAM: Verwenden Sie in der Produktion IAM-Rollen und niemals statische AWS-Schlüssel

• Geheimnisse: speichern VONAGE_NUMBER und AGENTCORE_RUNTIME_ARN Umgebungsvariablen im App Runner speichern

• Vonage-Antwort-URL: muss auf den App Runner verweisen /answer vor der Inbetriebnahme

• Verify: curl den /answer Endpunkt und stellen Sie sicher, dass NCCO die wss://bedrock-agentcore... URI enthält, bevor Sie einen echten Anruf testen

• Verhalten der Sitzung: tune NOVA_SESSION_WARN_SECONDS und NOVA_SESSION_LIMIT_SECONDS bei lang andauernden Aufrufen

Weitere Ressourcen

• Dokumentation zur Vonage Voice API

• Vonage Audio Serializer für Pipecat

• Dokumentation zum Vonage Audio Serializer für Pipecat

• AWS Nova Sonic-Dokumente

• AWS Bedrock AgentCore-Dokumente

• Quellcode auf GitHub

Schlussfolgerung

Sie haben einen Echtzeit-KI-Agenten für Voice-Anrufe bereitgestellt, der den „Vonage Audio Serializer for Pipecat“ und „AWS Nova Sonic“ nutzt und vollständig innerhalb der AWS Bedrock AgentCore Runtime mit einem öffentlichen App Runner-Webhook-Endpunkt ausgeführt wird.

Zusammen mit Teil 1 (Vonage Video Transport für Pipecat) stehen Ihnen nun zwei sich ergänzende Möglichkeiten zur Bereitstellung von KI-Agenten auf Vonage zur Verfügung.