AI Video-Agenten mit Vonage, Pipecat und AgentCore

Einführung

Entwickler können jetzt KI-Teilnehmer für Konversationen direkt in Live-Videositzungen einbinden. Anstelle von passiven Videoanrufen können Sie KI-Agenten erstellen, die während Live-Gesprächen zuhören, reagieren und natürlich interagieren.

In diesem Tutorial werden Sie einen KI-Agenten für Video-Sitzungen mithilfe des Vonage Video Transport für Pipecat und AWS Nova Sonic bereitstellen. Das Repository unterstützt zwei Vorgehensweisen: die lokale Entwicklung mit Docker für schnelle Iterationen und die Produktionsbereitstellung, bei der der Agent vollständig innerhalb der AWS Bedrock AgentCore Runtime ausgeführt wird. Dieses Tutorial führt Sie durch beide Vorgehensweisen – beginnen Sie lokal, um Ihre Pipeline zu validieren, und stellen Sie sie anschließend mit `agentcore deploy` und AWS App Runner in der Produktion bereit.

Mit dem Vonage Video Transport für Pipecat können Sie KI-gestützte Applications entwickeln, die sich nahtlos in Vonage Video API-Sitzungen einbinden lassen. Dieser Transport ermöglicht es Ihnen, Audio- und Videodaten von Sitzungsteilnehmern zu empfangen und die verarbeiteten Audio- und Videodaten in Echtzeit an die Sitzung zurückzusenden.

Pipecat ist ein Open-Source-Framework zur Entwicklung von Voice- und multimodalen KI-Applications für den Dialog. Der Vonage Video Connector verbindet die Medienverarbeitungs-Pipeline von Pipecat mit den Sitzungen der Vonage Video API und ermöglicht so eine Vielzahl von Anwendungsfällen. AWS Nova Sonic ist für sprachbasierte Konversationsinteraktionen mit geringer Latenz optimiert und eignet sich daher besonders gut für Live-Videositzungen. AWS Bedrock AgentCore Runtime ist eine sichere, serverlose Infrastruktur, die dafür ausgelegt ist, Voice- und KI-Agenten mit geringer Latenz in Echtzeit in großem Maßstab bereitzustellen und zu skalieren, ohne dass die Verwaltung der zugrunde liegenden Server erforderlich ist.

Sie werden es benutzen:

• Vonage Video Connector WebRTC-Transport für Pipecat für AI-Pipeline-Orchestrierung

• AWS Nova Sonic für Voice AI

• AWS Bedrock AgentCore ermöglicht Entwicklern die Bereitstellung und Skalierung von KI-Agenten.

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

Was Sie bauen werden

Am Ende dieses Tutorials werden Sie Folgendes wissen:

• Ein KI-Agent, der innerhalb der AWS Bedrock AgentCore Runtime bereitgestellt wird – einem vollständig verwalteten, serverlosen Container, auf dem Ihre Pipecat-Pipeline ausgeführt wird

• Ein öffentlicher App-Runner-Endpunkt, der den Webhook des Agent-Triggers verarbeitet und den Sitzungskontext an AgentCore weiterleitet

• Echtzeit-Sprachantworten der KI mithilfe von AWS Nova Sonic (Sprach-zu-Sprache, keine STT/TTS-Kette)

• Eine Produktionsarchitektur, die weder EC2 noch ECS noch ALB benötigt – lediglich ein Agentcore-Deployment und einen App Runner-Dienst

• Ein validierter Testablauf unter Verwendung von Vonage Playground vor der Integration der Vonage Video React Reference App

Voraussetzungen

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

• A Vonage API-Konto mit aktivierter Video API

• Ein AWS Account mit Amazon Bedrock-Zugang zu Nova Sonic (amazon.nova-2-sonic-v1:0)

• Python 3.13 wird von vonage-video-connector>=1.0.0 benötigt

• uv Paketmanager (brew install uv unter macOS)

• Docker-Arbeitsplatz - erforderlich, da das Vonage Video Connector SDK derzeit nur unter Linux läuft

• ngrok für die lokale Entwicklung

• AWS CLI konfiguriert (aws configure --profile profile-name)

Wie Bedrock und AgentCore zusammenarbeiten

Dieses Projekt nutzt zwei sich ergänzende AWS-Services:

Wie sie in diesem Repository zusammenarbeiten:

1. Bedrock + Agent Core (Endprodukt) - zusammen für einen produktionsreifen Agenten mit Management-Tools

2. Grundgestein allein - eine leichtere Option für schnelle Experimente und einfache Konversationsagenten

3. Erweitert - Hinzufügen realer Funktionen wie RAG, API-Aufrufe und CRM-Lookups neben der Sprache mit niedriger Latenz

Kurzfassung: Bedrock antwortet; AgentCore führt die einsatzfähige Agentenanwendungslogik aus.

Überblick über die Architektur

Die Integration erfolgt über einen WebRTC-basierten Ablauf: Der KI-Agent tritt der Vonage Video-Sitzung als Teilnehmer mit dem Vonage Video Connector SDK bei. Pipecat orchestriert dann die KI-Pipeline und leitet Audio über AWS Nova Sonic für die Sprachverarbeitung weiter. Falls konfiguriert, bereitet AgentCore den Agenten zu Beginn der Sitzung mit benutzerdefiniertem Kontext oder Tool-Zugriff vor.Architecture overview: Vonage Video session → Pipecat pipeline → AWS Nova Sonic → AgentCore.

Lokale Entwicklung

1. Browser (Vonage Playground) stellt eine Verbindung zur WebRTC-Vonage-Video-Sitzung her.

2. POST /join {vonage_session_id, vonage_token} wird an FastAPI (app/main.py, Port 8000).

3. FastAPI initiiert VonageVideoConnectorTransport (WebRTC) und tritt der Sitzung als nativer Teilnehmer bei.

4. Die Pipecat-Pipeline verarbeitet die Medien.

5. AWS Nova Sonic übernimmt die KI-Verarbeitung.

6. Der Ton wird an die Teilnehmer der Video-Sitzung zurückgesendet.

Produktion

1. Browser (Vonage Video React Reference App) sendet POST /answer {vonage_session_id, vonage_token}.

2. App-Laufzeitumgebung (answer/server.py — öffentlicher HTTPS-Endpunkt) ruft AgentCoreRuntimeClient.generate_presigned_url().

3. Das funktioniert vonage_session_id + vonage_token an AgentCore Aufrufkontext.

4. AgentCore-Laufzeitumgebung (runtime/agent.py, Port 8080, ARM64, Python 3.13) initialisiert den BedrockAgentCoreApp.

5. @app.websocket /ws wartet websocket.accept().

6. VonageVideoConnectorTransport nimmt als regulärer Teilnehmer an der Vonage-Video-Konferenz teil.

7. Die Pipecat Pipeline leitet Audio an AWS Nova Sonic.

8. Der Ton wird an die Teilnehmer der Video-Sitzung zurückgesendet.

Wichtige Komponenten

Bevor Sie beginnen: Erstellen Sie eine Vonage-Video-Application und eine Sitzung

Bevor Sie Ihre Umgebung einrichten, benötigen Sie eine Vonage Video-Anwendung und eine Sitzungs-ID.

Vonage-Video-Application erstellen

1. Anmeldung beim Vonage Dashboard

2. Weiter zu Applications → Neue Anwendung erstellen

3. Aktivieren Video Funktionalität

4. Klicken Sie auf „Öffentlichen und privaten Schlüssel generieren“ — dadurch wird Folgendes heruntergeladen private.key

5. Speichern Sie die Anwendung – kopieren Sie die Anwendungs-ID

Erstellen einer Vonage Video-Sitzung

1. Gehen Sie im Vonage-Dashboard zu Video → Extras → Playground

2. Wählen Sie Ihre Anwendung aus

3. Klicken Sie auf „Sitzung erstellen“ — kopieren Sie die Sitzungs-ID

Verwenden Sie den „Routed Media“-Modus bei der Verwendung des Video-Connectors. Verwenden Sie ein Publisher-Token-Rolle für den Teilnehmer der KI-Sitzung.

Sie haben nun:

• VONAGE_APPLICATION_ID — Ihre Vonage-Anwendungs-ID

• VONAGE_SESSION_ID — Ihre Vonage-Video-Konferenz-ID

• private.key — auf Ihren Computer heruntergeladen

Schritt 1: Klonen des Repositorys

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

Das Repository-Layout:

vonage-pipecat-aws-agentcore/
├── app/ # LOKALE ENTWICKLUNG — FastAPI-App (main.py, agent.py), Port 8000
├── runtime/ # PRODUKTION — BedrockAgentCoreApp (agent.py), agentcore-Bereitstellung, Python 3.13 ARM64
├── answer/ # PRODUKTION — /answer-Handler (App Runner)
├── tests/ # Validierungsstufen C1–C6
├── docker-compose.yml
├── .env.example
└── README.md

Schritt 2: Richten Sie Ihre Umgebung ein

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.

cp .env.example .env

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

# Vonage Video API
VONAGE_APPLICATION_ID=your-vonage-application-id
VONAGE_PRIVATE_KEY=private.key
VONAGE_SESSION_ID=your-vonage-session-id

# AWS
AWS_PROFILE=your-aws-profile
AWS_DEFAULT_REGION=us-east-1
BEDROCK_MODEL_ID=amazon.nova-2-sonic-v1:0

Das vollständige .env.example im Repo enthält zusätzliche Konfigurationen für Timeouts, Sitzungslimits und Produktionseinstellungen. Die drei oben genannten Variablen sind alles, was Sie benötigen, um die lokale Demo auszuführen.

Konfigurieren Sie Ihr AWS-Profil

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

Erstellen einer Vonage Video-Sitzung

Um eine Vonage Video-Sitzung zu erstellen, melden Sie sich im Vonage Dashboardund navigieren Sie zu Video → Tools → Playgroundund erstellen Sie eine geroutete Sitzung. Kopieren Sie die Sitzungs-ID in Ihre .env Datei.

Verwenden Sie routed Medienmodus, wenn Sie den Video Connector verwenden. Verwenden Sie eine publisher Token-Rolle für den AI-Sitzungsteilnehmer.

Schritt 3: Lokale Ausführung mit Docker

Das Vonage Video Connector SDK erfordert Linux. Unter macOS oder Windows übernimmt Docker dies automatisch.

Starten Sie die vollständige Anwendung aus dem Stammverzeichnis des Repo:

docker compose --profile app up --build

Verify, ob es läuft:

curl http://localhost:8000/
# {"status": "ok"}

curl http://localhost:8000/status
# {"running": true, "connected": false, "last_error": null}

Die App verbindet sich automatisch VONAGE_SESSION_ID beim Start automatisch. Öffnen Sie Vonage Playground, treten Sie derselben Sitzung bei und sprechen Sie. Der Agent antwortet mit gesprochenen Live-Antworten mithilfe von AWS Nova Sonic.

Sitzungsverwaltung:

# Force the agent to leave the session
curl -X POST http://localhost:8000/leave

# Rejoin with a new or existing session
curl -X POST http://localhost:8000/join \
  -H "Content-Type: application/json" \
  -d '{"session_id": "your-session-id"}'

AWS Nova Sonic hat ein ~8-minütiges Verbindungsfenster pro Sitzung. Die App sendet ein session_renewal_recommended Ereignis aus, bevor das Limit erreicht ist. Verwenden Sie /leave dann /join um die Sitzung zu aktualisieren, ohne den Container neu zu starten.

Sobald der Agent lokal läuft, fahren Sie mit den Schritten 5–7 fort, um die Bereitstellung in der Produktionsumgebung durchzuführen.

Schritt 4: Aufbau der Pipecat AI Pipeline

Der Kern der Anwendung ist die VonagePipecatAgent Klasse in agent.py. Die Vonage Video Connector Pipecat Integration fungiert als Transportschicht, empfängt Audio-Frames von der Video-Sitzung und sendet AI-Antworten zurück.

from pipecat.transports.vonage.video_connector import (
    VonageVideoConnectorTransport,
    VonageVideoConnectorTransportParams,
)
from pipecat.services.aws.nova_sonic.llm import AWSNovaSonicLLMService, Params
from pipecat.processors.aggregators.llm_response_universal import LLMContextAggregatorPair

# Vonage Video Connector transport — joins session as WebRTC participant
transport = VonageVideoConnectorTransport(
    application_id=application_id,
    session_id=session_id,
    token=token,
    params=VonageVideoConnectorTransportParams(
        audio_in_enabled=True,
        audio_out_enabled=True,
        video_in_enabled=False,
        video_out_enabled=False,
        publisher_name="Vonage AI Assistant",
        audio_in_sample_rate=16000,
        audio_in_channels=1,
        # Nova Sonic returns 24kHz audio — output sample rate must match
        audio_out_sample_rate=24000,
        audio_out_channels=1,
        vad_analyzer=SileroVADAnalyzer(),
        audio_in_auto_subscribe=True,
        video_in_auto_subscribe=False,
    ),
)

# 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,
        # Must match audio_out_sample_rate above
        output_sample_rate=24000,
        output_channel_count=1,
    ),
    system_instruction="You are a helpful voice assistant for a Vonage video session. Keep responses brief and conversational.",
)

# LLMContextAggregatorPair maintains conversational memory across user and assistant turns
context_aggregator = LLMContextAggregatorPair(context)

# 5-stage pipeline with context aggregators for conversation memory
pipeline = Pipeline([
    transport.input(),              # Audio in from Vonage Video session
    context_aggregator.user(),      # Accumulate user speech turns
    nova_sonic,                     # Speech-to-speech AI processing
    context_aggregator.assistant(), # Accumulate assistant responses
    transport.output(),             # Audio out back to Vonage Video session
])

Schritt 5: Bereitstellen Ihres Agenten mit AgentCore

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

In diesem Projekt ist AgentCore der Laufzeit-Host, und somit läuft der gesamte Pipecat-Agent innerhalb der AgentCore-Laufzeitumgebung. Der Agent tritt der Vonage-Video-Sitzung als nativer WebRTC-Teilnehmer von innerhalb von AgentCore bei.

Wenn ein Benutzer den Agenten auslöst, generiert App Runner eine neue, vorab signierte AgentCore-WebSocket-URL und übergibt vonage_session_id und vonage_token über den Aufrufkontext an AgentCore weiter. AgentCore leitet die Verbindung an den Handler Ihres Agenten weiter /ws Handler weiter, wo VonageVideoConnectorTransport als nativer WebRTC-Teilnehmer der Video-Sitzung beitritt.

# runtime/agent.py — runs inside AgentCore Runtime
from bedrock_agentcore.runtime import BedrockAgentCoreApp
from pipecat.transports.vonage.video_connector import (
    VonageVideoConnectorTransport,
    VonageVideoConnectorTransportParams,
)
from pipecat.audio.vad.silero import SileroVADAnalyzer

app = BedrockAgentCoreApp()

@app.websocket("/ws")
async def ws_handler(websocket: WebSocket, context: dict) -> None:
    await websocket.accept()  # mandatory — BedrockAgentCoreApp does not auto-accept

    # Session context from AgentCore invoke payload — dynamic per call
    session_id = context.get("vonage_session_id")
    token = context.get("vonage_token")

    transport = VonageVideoConnectorTransport(
        application_id=application_id,
        session_id=session_id,
        token=token,
        params=VonageVideoConnectorTransportParams(
            audio_in_enabled=True,
            audio_out_enabled=True,
            video_in_enabled=False,
            video_out_enabled=False,
            vad_analyzer=SileroVADAnalyzer(),
            audio_in_auto_subscribe=True,
        ),
    )

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

Stellen Sie Ihren Agenten auf AgentCore bereit:

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_13 \
  -rf requirements.txt

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

Für diese App ist Python 3.13 erforderlich. vonage-video-connector>=1.0.0 erfordert >=3.13,<3.14. Verwenden --runtime PYTHON_3_13 in agentcore configure.

Ihr Agent läuft nun in AgentCore. Vonage stellt eine direkte Verbindung zum integrierten Endpunkt von AgentCore her /ws – EC2, ECS oder EKS sind nicht erforderlich.

Schritt 6: App Runner bereitstellen /answer Handler

App Runner verarbeitet den Webhook zum Auslösen des Agenten. Es generiert für jede Sitzung eine neue, vorab signierte AgentCore-WebSocket-URL und übergibt den Sitzungskontext an AgentCore:

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

client = AgentCoreRuntimeClient(region=region)

presigned_url = client.generate_presigned_url(
    runtime_arn,
    session_id=session_id
)
# Returns presigned_url in JSON response
# vonage_session_id and vonage_token passed to AgentCore invoke context

Erstellen und an ECR übertragen:

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

docker build --platform linux/amd64 -t vonage-agentcore-video-answer ./answer
docker tag vonage-agentcore-video-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

Erstellen Sie den App-Runner-Dienst:

Siehe README.md für den vollständigen aws apprunner create-service Befehl.

Umgebungsvariablen von App Runner aktualisieren:

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

Einrichtung von App Runner IAM:

Ihr App Runner-Endpunkt ist jetzt verfügbar:

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

Schritt 7: Testen mit Vonage Playground

Nachdem Ihr Agent in AgentCore ausgeführt wird und App Runner bereitgestellt ist, überprüfen Sie den gesamten Produktions-Stack mit Vonage Playground– es ist keine eigene Client-App erforderlich.

Schritt 7.1: Eine Vonage-Video-Sitzung erstellen

Melden Sie sich bei Ihrem Vonage-Dashboard → Video → Tools → Playground. Erstellen Sie eine geroutete Sitzung und kopieren Sie die Sitzungs-ID.

Schritt 7.2: Erstellen Sie ein Publisher-Token für den Agenten

Erstellen Sie in Vonage Playground ein Publisher-Token für die Agenten-Sitzung.

Schritt 7.3: Den Agenten über den App Runner auslösen

curl -X POST https://{service-id}.us-east-1.awsapprunner.com/answer \
  -H "Content-Type: application/json" \
  -d '{
    "vonage_session_id": "<your-session-id>",
    "vonage_token": "<publisher-token>"
  }'
# Expected response:
# {"status": "started", "vonage_session_id": "..."}

Schritt 7.4: An der Sitzung in Vonage Playground teilnehmen

1. Weiter zu Vonage Playground

2. Geben Sie Ihren API-Schlüssel und Sitzungs-ID

3. Erstelle ein Abonnententoken für sich selbst

4. Klicken „Verbinden“— Sie befinden sich nun in derselben Sitzung wie der Agent

5. Sprechen Sie – der Mitarbeiter antwortet in Echtzeit über Nova Sonic

Der Agent sollte nun als zweiter Teilnehmer in der Sitzung angezeigt werden. Wenn Sie sprechen, verarbeitet Nova Sonic Ihre Audioübertragung, und der Agent antwortet. Die Audioübertragung des Agenten wird an alle Teilnehmer der Sitzung zurückgesendet.

Protokollieren Sie die Logs während des Tests:

AWS_PROFILE=vonage-dev aws logs tail \
/aws/bedrock-agentcore/runtimes/{runtime-id}-DEFAULT \
  --log-stream-name-prefix "$(date +%Y/%m/%d)/[runtime-logs]" \
  --follow \
  --region us-east-1

Checkliste Produktion

• Laufzeit: Verwenden Sie Python 3.13 für die AgentCore-Laufzeitumgebung – vonage-video-connector erfordert >=3.13,<3.14

• ARM64: Erstellen Sie den AgentCore-Container mit --platform linux/arm64

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

• Sitzungskontext: Übergeben Sie vonage_session_id und vonage_token dynamisch über den AgentCore-Aufrufkontext – niemals über statische Umgebungsvariablen

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

• TURN: VonageVideoConnectorTransport unterstützt TURN nativ – es ist kein externer TURN-Server erforderlich

• Zuerst testen: Testen Sie mit Vonage Playground, bevor Sie die React-Referenz-App integrieren

• Geheimnisse: Speichern Sie VONAGE_APPLICATION_ID und AGENTCORE_RUNTIME_ARN in den Umgebungsvariablen von App Runner

• Verhalten von Sitzungen: Passen Sie NOVA_SESSION_WARN_SECONDS und NOVA_SESSION_LIMIT_SECONDS für lang andauernde Video-Sitzungen an

• Verify: Rufen Sie den Endpunkt /answer mit curl auf und überprüfen Sie die Antwort, bevor Sie eine echte Sitzung testen

Weitere Ressourcen

• Vonage Video Spielplatz

• Vonage Video Transport für Pipecat

• AWS Nova Sonic-Dokumente

• AWS Bedrock AgentCore-Dokumente

• GitHub - vonage-pipecat-aws-agentcore

Schlussfolgerung

Sie haben einen Echtzeit-KI-Video-Agenten mithilfe von „Vonage Video Transport for Pipecat“ und „AWS Nova Sonic“ bereitgestellt, der vollständig innerhalb der „AWS Bedrock AgentCore Runtime“ mit einem öffentlichen „App Runner“-Webhook-Endpunkt ausgeführt wird.

Der Vonage Video Transport für Pipecat (VonageVideoConnectorTransport) tritt der Vonage Video-Sitzung als nativer WebRTC-Teilnehmer bei. Nova Sonic übernimmt die Sprach-zu-Sprache-Verarbeitung in Echtzeit. AgentCore bietet eine verwaltete Laufzeitumgebung für die Bereitstellung und Skalierung, ohne dass eine EC2-, ECS- oder EKS-Infrastruktur verwaltet werden muss.

In Teil 2 wechseln wir vom Video zur Telefonie und nutzen dazu den „Vonage Audio Serializer for Pipecat“ sowie die „Vonage Voice API“ – eine WebSocket-basierte Lösung für KI-Agenten, die Live-Anrufe entgegennehmen und ebenfalls vollständig innerhalb der AgentCore Runtime bereitgestellt wird.