In diesem Artikel erfahren Sie:
- Was das AWS Cloud Development Kit (CDK) ist und wie es zur Definition und Bereitstellung von Cloud-Infrastrukturen verwendet werden kann.
- Warum Sie AWS Bedrock KI-Agenten, die mit AWS CDK erstellt wurden, Zugriff auf Web-Suchergebnisse über ein AI-fähiges Tool wie die SERP-API von Bright Data gewähren sollten.
- Wie Sie einen AWS Bedrock-Agenten erstellen, der mit der SERP-API über AWS CDK in Python integriert ist.
Lassen Sie uns loslegen!
Was ist das AWS Cloud Development Kit (CDK)?
Das AWS Cloud Development Kit, auch bekannt als AWS CDK, ist ein Open-Source-Framework zum Aufbau einer Cloud-Infrastruktur als Code unter Verwendung moderner Programmiersprachen. Es stattet Sie mit allem aus, was Sie benötigen, um AWS-Ressourcen bereitzustellen und Anwendungen über AWS CloudFormation unter Verwendung von Programmiersprachen wie TypeScript, Python, Java, C# und Go bereitzustellen.
Dank AWS CDK können Sie auch KI-Agenten für Amazon Bedrock programmgesteuert erstellen – genau das, was Sie in diesem Tutorial tun werden!
Warum mit AWS CDK erstellte Amazon Bedrock KI-Agenten eine Websuche benötigen
Große Sprachmodelle werden anhand von Datensätzen trainiert, die nur Wissen bis zu einem bestimmten Zeitpunkt repräsentieren. Infolgedessen neigen sie dazu, ungenaue oder halluzinierte Antworten zu produzieren. Das ist besonders problematisch für KI-Agenten, die aktuelle Informationen benötigen.
Dieses Problem lässt sich lösen, indem Sie Ihrem KI-Agenten die Möglichkeit geben, aktuelle, zuverlässige Daten in einer RAG-Umgebung (Retrieval-Augmented Generation) abzurufen. Der KI-Agent könnte beispielsweise Websuchen durchführen, um verifizierbare Informationen zu sammeln, sein Wissen zu erweitern und seine Genauigkeit zu verbessern.
Es ist möglich, eine benutzerdefinierte AWS Lambda-Funktion zum Scrapen von Suchmaschinen zu erstellen, aber das ist ziemlich anspruchsvoll. Sie müssten sich mit JavaScript-Rendering, CAPTCHAs, sich ändernden Website-Strukturen und IP-Blöcken auseinandersetzen.
Ein besserer Ansatz ist die Verwendung einer funktionsreichen SERP-API, wie beispielsweise die SERP-API von Bright Data. Diese übernimmt für Sie die Verwaltung von Proxys, die Aufhebung von Sperren, die Skalierbarkeit, die Datenformatierung und vieles mehr. Durch die Integration mit AWS Bedrock mithilfe einer Lambda-Funktion kann Ihr über AWS CDK erstellter KI-Agent auf Live-Suchergebnisse zugreifen, um zuverlässigere Antworten zu liefern.
So entwickeln Sie einen KI-Agenten mit SERP-API-Integration unter Verwendung von AWS CDK in Python
In diesem Schritt-für-Schritt-Abschnitt erfahren Sie, wie Sie AWS CDK mit Python verwenden, um einen AWS Bedrock KI-Agenten zu erstellen. Dieser ist in der Lage, Daten von Suchmaschinen über die Bright Data SERP-API abzurufen.
Die Integration wird über eine Lambda-Funktion (die die SERP-API aufruft) implementiert, die der Agent als Tool aufrufen kann. Um einen Amazon Bedrock-Agenten zu erstellen, sind insbesondere die folgenden Hauptkomponenten erforderlich:
- Aktionsgruppe: Definiert die Funktionen, die der Agent sehen und aufrufen kann.
- Lambda-Funktion: Implementiert die Logik zum Abfragen der Bright Data SERP-API.
- KI-Agent: Koordiniert die Interaktionen zwischen den Basismodellen, Funktionen und Benutzeranfragen.
Diese Konfiguration wird vollständig mit AWS CDK in Python implementiert. Um die gleichen Ergebnisse mit der visuellen AWS Bedrock-Konsole zu erzielen, lesen Sie unseren Leitfaden zu Amazon Bedrock + Bright Data.
Befolgen Sie die folgenden Schritte, um einen AWS Bedrock KI-Agenten mit AWS CDK zu erstellen, der durch die SERP-API um Echtzeit-Websuchfunktionen erweitert wurde!
Voraussetzungen
Um diesem Tutorial folgen zu können, benötigen Sie:
- Node.js 22.x+ lokal installiert, um die AWS CDK-CLI verwenden zu können.
- Python 3.11+ lokal installiert, um AWS CDK in Python zu verwenden.
- Ein aktives AWS-Konto (auch als kostenlose Testversion).
- Die Voraussetzungen für Amazon Bedrock Agents müssen eingerichtet sein. (Amazon Bedrock Agents sind derzeit nur in einigen AWS-Regionenverfügbar.)
- Ein Bright Data-Konto mit einem API-Schlüssel.
- Grundlegende Python-Programmierkenntnisse.
Schritt 1: AWS CLI installieren und autorisieren
Bevor Sie mit AWS CDK fortfahren, müssen Sie die AWS CLI installieren und so konfigurieren, dass Ihr Terminal sich bei Ihrem AWS-Konto authentifizieren kann.
Hinweis: Wenn Sie die AWS CLI bereits installiert und für die Authentifizierung konfiguriert haben, überspringen Sie diesen Schritt und fahren Sie mit dem nächsten fort.
Installieren Sie die AWS CLI gemäß der offiziellen Installationsanleitung für Ihr Betriebssystem. Überprüfen Sie nach der Installation die Installation, indem Sie Folgendes ausführen:
aws --versionSie sollten eine Ausgabe ähnlich der folgenden sehen:
aws-cli/2.31.32 Python/3.13.9 Windows/11 exe/AMD64Führen Sie anschließend den Befehl „configure“ aus, um Ihre Anmeldedaten einzurichten:
aws configureSie werden aufgefordert, Folgendes einzugeben:
- AWS-Zugriffsschlüssel-ID
- AWS-Geheimzugriffsschlüssel
- Standardregionsname (z. B.
us-east-1) - Standardausgabeformat (optional, z. B.
json)
Füllen Sie die ersten drei Felder aus, da diese für die CDK-Entwicklung und -Bereitstellung erforderlich sind. Wenn Sie sich fragen, wo Sie diese Informationen finden können:
- Gehen Sie zu AWS und melden Sie sich an.
- Klicken Sie oben rechts auf Ihren Kontonamen, um das Kontomenü zu öffnen, und wählen Sie die Option „Sicherheitsanmeldeinformationen“.
- Erstellen Sie im Abschnitt „Zugriffsschlüssel“ einen neuen Schlüssel. Speichern Sie sowohl die „Zugriffsschlüssel-ID“ als auch den „geheimen Zugriffsschlüssel“ an einem sicheren Ort.
Fertig! Ihr Computer kann nun über die CLI eine Verbindung zu Ihrem AWS-Konto herstellen. Sie können nun mit der AWS CDK-Entwicklung fortfahren.
Schritt 2: AWS CDK installieren
Installieren Sie AWS CDK global auf Ihrem System mit dem npm-Paket „aws-cdk “:
npm install -g aws-cdkÜberprüfen Sie anschließend die installierte Version, indem Sie folgenden Befehl ausführen:
cdk --versionSie sollten eine Ausgabe ähnlich der folgenden sehen:
2.1031.2 (Build 779352d)Hinweis: Für die Entwicklung und Bereitstellung von KI-Agenten mit AWS CDK und Python ist Version 2.174.3 oder höher erforderlich.
Großartig! Sie haben nun die AWS CDK-CLI lokal installiert.
Schritt 3: Einrichten Ihres AWS CDK Python-Projekts
Erstellen Sie zunächst einen neuen Projektordner für Ihren AWS CDK + Bright Data SERP-API KI-Agenten.
Sie können ihn beispielsweise „aws-cdk-bright-data-web-search-agent” nennen:
mkdir aws-cdk-bright-data-web-search-agentNavigieren Sie in den Ordner:
cd aws-cdk-bright-data-web-search-agentInitialisieren Sie dann eine neue Python-basierte AWS CDK-Anwendung mit dem Befehl „init “:
cdk init app --language pythonDies kann einen Moment dauern. Bitte haben Sie etwas Geduld, während die CDK-CLI Ihre Projektstruktur einrichtet.
Nach der Initialisierung sollte Ihr Projektordner wie folgt aussehen:
aws-cdk-bright-data-web-search-agent
├── .git/
├── venv/
├── aws_cdk_bright_data_web_search_agent/
│ ├── __init__.py
│ └── aws_cdk_bright_data_web_search_agent_stack.py
├── tests/
│ ├── __init__.py
│ └── unit/
│ ├── __init__.py
│ └── test_aws_cdk_bright_data_web_search_agent_stack.py
├── .gitignore
├── app.py
├── cdk.json
├── README.md
├── requirements.txt
├── requirements-dev.txt
└── source.batSie müssen sich auf diese beiden Dateien konzentrieren:
app.py: Enthält die oberste Definition der AWS CDK-Anwendung.aws_cdk_bright_data_web_search_agent/aws_cdk_bright_data_web_search_agent_stack.py: Definiert den Stack für den Web-Suchagenten (hier implementieren Sie Ihre KI-Agentenlogik).
Weitere Informationen finden Sie im offiziellen AWS-Leitfaden zur Arbeit mit CDK in Python.
Laden Sie nun Ihr Projekt in Ihre bevorzugte Python-IDE, z. B. PyCharm oder Visual Studio Code mit der Python-Erweiterung.
Beachten Sie, dass der Befehl „cdk init“ automatisch eine virtuelle Python-Umgebung im Projekt erstellt. Unter Linux oder macOS aktivieren Sie diese mit:
source .venv/bin/activateUnter Windows führen Sie stattdessen Folgendes aus:
.venvScriptsactivateInstallieren Sie dann in der aktivierten virtuellen Umgebung alle erforderlichen Abhängigkeiten:
python -m pip install -r requirements.txtFantastisch! Sie haben nun eine AWS CDK Python-Umgebung für die Entwicklung von KI-Agenten eingerichtet.
Schritt 4: AWS CDK-Bootstrapping ausführen
Bootstrapping ist der Prozess der Vorbereitung Ihrer AWS-Umgebung für die Verwendung mit dem AWS Cloud Development Kit. Bevor Sie einen CDK-Stack bereitstellen können, muss Ihre Umgebung bootstrappt werden.
Einfacher ausgedrückt werden bei diesem Prozess die folgenden Ressourcen in Ihrem AWS-Konto eingerichtet:
- Ein Amazon S3-Bucket: Speichert Ihre CDK-Projektdateien, wie z. B. AWS Lambda-Funktionscode und andere Assets.
- Ein Amazon ECR-Repository: Speichert Docker-Images.
- AWS IAM-Rollen: Erteilen Sie die erforderlichen Berechtigungen für das AWS CDK, um Bereitstellungen durchzuführen. (Weitere Informationen finden Sie in der AWS-Dokumentation zu IAM-Rollen, die während des Bootstrapping erstellt werden.
Um den CDK-Bootstrap-Prozess zu starten, führen Sie den folgenden Befehl im Ordner Ihres Projekts aus:
cdk bootstrapIm AWS CloudFormation- Dienst erstellt dieser Befehl einen Stack namens „CDKToolkit“, der alle Ressourcen enthält, die für die Bereitstellung von CDK-Anwendungen erforderlich sind.
Überprüfen Sie dies, indem Sie die CloudFormation -Konsole aufrufen und die Seite „Stacks“ überprüfen:
Sie sehen einen „CDKToolkit“-Stack. Folgen Sie dem Link, um eine Anzeige wie die folgende zu erhalten:
Weitere Informationen darüber, wie der Bootstrap-Prozess funktioniert, warum er erforderlich ist und was hinter den Kulissen geschieht, finden Sie in der offiziellen AWS CDK-Dokumentation.
Schritt 5: Bereiten Sie sich mit der SERP-API von Bright Data vor
Nachdem Sie Ihre AWS CDK-Umgebung für die Entwicklung und Bereitstellung eingerichtet haben, schließen Sie die vorbereitenden Schritte ab, indem Sie Ihr Bright Data-Konto einrichten und den SERP-API-Dienst konfigurieren. Sie können entweder der offiziellen Bright Data-Dokumentation folgen oder die folgenden Schritte ausführen.
Wenn Sie noch kein Konto haben, erstellen Sie ein Bright Data-Konto. Alternativ können Sie sich einfach anmelden. Rufen Sie in Ihrem Bright Data-Konto die Seite „Proxy & Scraping“ auf. Suchen Sie im Abschnitt „My Zones“ in der Tabelle nach einer Zeile mit der Bezeichnung „SERP-API“:
Wenn Sie keine Zeile mit der Bezeichnung „SERP-API“ sehen, bedeutet dies, dass Sie noch keine Zone eingerichtet haben. Scrollen Sie nach unten zum Abschnitt „SERP-API“ und klicken Sie auf „Zone erstellen“, um eine hinzuzufügen:
Erstellen Sie eine SERP-API-Zone und geben Sie ihr einen Namen wie serp_api (oder einen beliebigen anderen Namen). Merken Sie sich den von Ihnen gewählten Zonennamen, da Sie ihn benötigen, um über die API auf den Dienst zuzugreifen.
Aktivieren Sie auf der SERP-API-Produktseite den Schalter „Aktivieren“, um die Zone zu aktivieren:
Befolgen Sie abschließend die offizielle Anleitung, um Ihren Bright Data API-Schlüssel zu generieren. Bewahren Sie ihn an einem sicheren Ort auf, da Sie ihn in Kürze benötigen werden.
Großartig! Sie haben nun alles eingerichtet, um die SERP-API von Bright Data in Ihrem mit AWS CDK entwickelten AWS Bedrock KI-Agenten zu verwenden.
Schritt 6: Speichern Sie Ihre CDK-Anwendungsgeheimnisse im AWS Secrets Manager
Sie haben gerade sensible Informationen erhalten (z. B. Ihren Bright Data-API-Schlüssel und den Namen der SERP-API-Zone). Anstatt diese Werte fest in den Code Ihrer Lambda-Funktion einzubauen, sollten Sie sie sicher aus dem AWS Secrets Manager auslesen.
Führen Sie den folgenden Bash-Befehl aus, um ein Geheimnis mit dem Namen BRIGHT_DATA zu erstellen, das Ihren Bright Data API-Schlüssel und die SERP-API-Zone enthält:
aws secretsmanager create-secret
--name "BRIGHT_DATA"
--description "API credentials for Bright Data SERP-API integration"
--secret-string '{
"BRIGHT_DATA_API_KEY": "<YOUR_BRIGHT_DATA_API_KEY>",
"BRIGHT_DATA_SERP_API_ZONE": "<YOUR_BRIGHT_DATA_SERP_API_ZONE>"
}'Oder, gleichwertig, in PowerShell:
aws secretsmanager create-secret `
--name "BRIGHT_DATA" `
--description "API-Anmeldedaten für die Bright Data SERP-API-Integration" `
--secret-string '{"BRIGHT_DATA_API_KEY":"<YOUR_BRIGHT_DATA_API_KEY>","BRIGHT_DATA_SERP_API_ZONE":"<YOUR_BRIGHT_DATA_SERP_API_ZONE>"}'Ersetzen Sie <YOUR_BRIGHT_DATA_API_KEY> und <YOUR_BRIGHT_DATA_SERP_API_ZONE> durch die Werte, die Sie zuvor abgerufen haben.
Dieser Befehl richtet das BRIGHT_DATA -Geheimnis ein, wie Sie in der AWS Secrets Manager -Konsole auf der Seite „Secrets“ (Geheimnisse) überprüfen können:
Wenn Sie auf die Schaltfläche „Geheimwert abrufen” klicken, sollten Sie die Geheimnisse BRIGHT_DATA_API_KEY und BRIGHT_DATA_SERP_API_ZONE sehen:
Großartig! Diese Geheimnisse werden verwendet, um Anfragen an die SERP-API in einer Lambda-Funktion zu authentifizieren, die Sie in Kürze definieren werden.
Schritt 7: Implementieren Sie Ihren AWS CDK-Stack
Nachdem Sie nun alles Notwendige für die Erstellung Ihres KI-Agenten eingerichtet haben, besteht der nächste Schritt darin, den AWS CDK-Stack in Python zu implementieren. Zunächst ist es wichtig zu verstehen, was ein AWS CDK-Stack ist.
Ein Stack ist die kleinste deploybare Einheit in CDK. Er stellt eine Sammlung von AWS-Ressourcen dar, die mit CDK-Konstrukten definiert wurden. Wenn Sie eine CDK-App deployen, werden alle Ressourcen im Stack zusammen als ein einziger CloudFormation-Stack deployt.
Die Standard-Stack-Datei befindet sich unter:
aws_cdk_bright_data_web_search_agent/aws_cdk_bright_data_web_search_agent_stack.pyÜberprüfen Sie sie in Visual Studio Code:
Diese enthält eine generische Stack-Vorlage, in der Sie Ihre Logik definieren. Ihre Aufgabe besteht darin, den vollständigen AWS CDK-Stack zu implementieren, um den KI-Agenten mit Bright Data SERP-API-Integration zu erstellen, einschließlich Lambda-Funktionen, IAM-Rollen, Aktionsgruppen und dem Bedrock KI-Agenten.
Erreichen Sie all dies mit:
import aws_cdk.aws_iam as iam
from aws_cdk import (
Aws,
CfnOutput,
Duration,
Stack)
from aws_cdk import aws_bedrock as bedrock
from aws_cdk import aws_lambda as _lambda
from constructs import Construct
# Definieren Sie die erforderlichen Konstanten
AI_MODEL_ID = "amazon.nova-lite-v1:0" # Der Name des LLM, der für den Agenten verwendet wird
ACTION_GROUP_NAME = "action_group_web_search"
LAMBDA_FUNCTION_NAME = "serp_api_lambda"
AGENT_NAME = "web_search_agent"
# Definieren Sie den CDK-Stack für die Bereitstellung des von Bright Data betriebenen Web-Suchagenten
class AwsCdkBrightDataWebSearchAgentStack(Stack):
def __init__(self, scope: Construct, construct_id: str, **kwargs) -> None:
super().__init__(scope, construct_id, **kwargs)
# Gewährt Lambda-Berechtigungen für die Protokollierung und das Lesen von Geheimnissen
lambda_policy = iam.Policy(
self,
"LambdaPolicy",
statements=[
# Berechtigung zum Erstellen von CloudWatch-Protokollgruppen
iam.PolicyStatement(
sid="CreateLogGroup",
effect=iam.Effect.ALLOW,
actions=["logs:CreateLogGroup"],
resources=[f"arn:aws:logs:{Aws.REGION}:{Aws.ACCOUNT_ID}:*"],
),
# Berechtigung zum Erstellen von Protokollströmen und zum Einfügen von Protokollereignissen
iam.PolicyStatement(
sid="CreateLogStreamAndPutLogEvents",
effect=iam.Effect.ALLOW,
actions=["logs:CreateLogStream", "logs:PutLogEvents"],
resources=[
f"arn:aws:logs:{Aws.REGION}:{Aws.ACCOUNT_ID}:log-group:/aws/lambda/{LAMBDA_FUNCTION_NAME}",
f"arn:aws:logs:{Aws.REGION}:{Aws.ACCOUNT_ID}:log-group:/aws/lambda/{LAMBDA_FUNCTION_NAME}:log-stream:*",
],
),
# Berechtigung zum Lesen von BRIGHT_DATA-Geheimnissen aus Secrets Manager
iam.PolicyStatement(
sid="GetSecretsManagerSecret",
effect=iam.Effect.ALLOW,
actions=["secretsmanager:GetSecretValue"],
resources=[
f"arn:aws:secretsmanager:{Aws.REGION}:{Aws.ACCOUNT_ID}:secret:BRIGHT_DATA*",
],
),
],
)
# Definieren Sie die IAM-Rolle für die Lambda-Funktionen.
lambda_role = iam.Role(
self,
"LambdaRole",
role_name=f"{LAMBDA_FUNCTION_NAME}_role",
assumed_by=iam.ServicePrincipal("lambda.amazonaws.com"),
)
# Die Richtlinie an die Lambda-Rolle anhängen
lambda_role.attach_inline_policy(lambda_policy)
# Lambda-Funktionsdefinition
lambda_function = _lambda.Function(
self,
LAMBDA_FUNCTION_NAME,
function_name=LAMBDA_FUNCTION_NAME,
runtime=_lambda.Runtime.PYTHON_3_12, # Python-Laufzeitumgebung
architecture=_lambda.Architecture.ARM_64,
code=_lambda.Code.from_asset("lambda"), # Lambda-Code aus dem Ordner „lambda/“ lesen
handler=f"{LAMBDA_FUNCTION_NAME}.lambda_handler",
timeout=Duration.seconds(120),
role=lambda_role, # IAM-Rolle anhängen
environment={"LOG_LEVEL": "DEBUG", "ACTION_GROUP": f"{ACTION_GROUP_NAME}"},
)
# Bedrock-Dienst darf Lambda-Funktionen aufrufen
bedrock_account_principal = iam.PrincipalWithConditions(
iam.ServicePrincipal("bedrock.amazonaws.com"),
conditions={
"StringEquals": {"aws:SourceAccount": f"{Aws.ACCOUNT_ID}"},
},
)
lambda_function.add_permission(
id="LambdaResourcePolicyAgentsInvokeFunction",
principal=bedrock_account_principal,
action="lambda:invokeFunction",
)
# IAM-Richtlinie für den Bedrock-Agenten definieren
agent_policy = iam.Policy(
self,
"AgentPolicy",
statements=[
iam.PolicyStatement(
sid="AmazonBedrockAgentBedrockFoundationModelPolicy",
effect=iam.Effect.ALLOW,
actions=["bedrock:InvokeModel"], # Erteilen Sie ihm die Berechtigung, das Basismodell aufzurufen
resources=[f"arn:aws:bedrock:{Aws.REGION}::foundation-model/{AI_MODEL_ID}"],
),
],
)
# Vertrauensbeziehung für die Agentenrolle, damit Bedrock diese übernehmen kann
agent_role_trust = iam.PrincipalWithConditions(
iam.ServicePrincipal("bedrock.amazonaws.com"),
conditions={
"StringLike": {"aws:SourceAccount": f"{Aws.ACCOUNT_ID}"},
"ArnLike": {"aws:SourceArn": f"arn:aws:bedrock:{Aws.REGION}:{Aws.ACCOUNT_ID}:agent/*"},
},
)
# IAM-Rolle für den Bedrock-Agenten definieren
agent_role = iam.Role(
self,
"AmazonBedrockExecutionRoleForAgents",
role_name=f"AmazonBedrockExecutionRoleForAgents_{AGENT_NAME}",
assumed_by=agent_role_trust,
)
agent_role.attach_inline_policy(agent_policy)
# Definieren Sie die Aktionsgruppe für den KI-Agenten
action_group = bedrock.CfnAgent.AgentActionGroupProperty(
action_group_name=ACTION_GROUP_NAME,
description="Rufen Sie die SERP-API von Bright Data auf, um Websuchen durchzuführen und aktuelle Informationen aus Suchmaschinen abzurufen.",
action_group_executor=bedrock.CfnAgent.ActionGroupExecutorProperty(lambda_=lambda_function.function_arn),
function_schema=bedrock.CfnAgent.FunctionSchemaProperty(
functions=[
bedrock.CfnAgent.FunctionProperty(
name=LAMBDA_FUNCTION_NAME,
description="Integration mit der SERP-API von Bright Data, um Websuchen durchzuführen.",
parameters={
"search_query": bedrock.CfnAgent.ParameterDetailProperty(
type="string",
description="Die Suchanfrage für die Google-Websuche.",
required=True,
)
},
),
]
),
)
# Bedrock AI Agent erstellen und festlegen
agent_description = """
Ein KI-Agent, der sich mit der SERP-API von Bright Data verbinden kann, um aktuelle Websuchkontexte aus Suchmaschinen abzurufen.
"""
agent_instruction = """
Sie sind ein Agent, der für Anwendungsfälle entwickelt wurde, in denen aktuelle Informationen abgerufen und verarbeitet werden müssen.
Sie können über Websuchen, die von der SERP-API von Bright Data unterstützt werden, auf aktuelle Daten zugreifen, darunter Nachrichten und Suchmaschinenergebnisse.
"""
agent = bedrock.CfnAgent(
self,
AGENT_NAME,
description=agent_description,
agent_name=AGENT_NAME,
foundation_model=AI_MODEL_ID,
action_groups=[action_group],
auto_prepare=True,
instruction=agent_instruction,
agent_resource_role_arn=agent_role.role_arn,
)
# Exportieren Sie die wichtigsten Ausgaben für die Bereitstellung.
CfnOutput(self, "agent_id", value=agent.attr_agent_id)
CfnOutput(self, "agent_version", value=agent.attr_agent_version)Der obige Code ist eine modifizierte Version der offiziellen AWS CDK-Stack-Implementierung für einen KI-Agenten für die Websuche.
Was in diesen über 150 Codezeilen geschieht, spiegelt die zuvor in diesem Leitfaden beschriebenen Schritte wider: Schritt 1, Schritt 2 und Schritt 3 unseres Artikels„So integrieren Sie die Bright Data SERP-API in AWS Bedrock AI-Agenten”.
Um besser zu verstehen, was in dieser Datei vor sich geht, teilen wir den Code in fünf Funktionsblöcke auf:
- Lambda-IAM-Richtlinie und -Rolle: Legt die Berechtigungen für die Lambda-Funktion fest. Die Lambda-Funktion benötigt Zugriff auf CloudWatch-Protokolle, um Ausführungsdetails aufzuzeichnen, sowie auf AWS Secrets Manager, um den Bright Data API-Schlüssel und die Zone sicher zu lesen. Für die Lambda-Funktion wird eine IAM-Rolle erstellt und die entsprechende Richtlinie angehängt, um sicherzustellen, dass sie nur mit den erforderlichen Berechtigungen sicher funktioniert.
- Lambda-Funktionsdefinition: Hier wird die Lambda-Funktion selbst definiert und konfiguriert. Sie gibt die Python-Laufzeitumgebung und -Architektur an, verweist auf den Ordner mit dem Lambda-Code (der im nächsten Schritt implementiert wird) und richtet Umgebungsvariablen wie Protokollstufe und Aktionsgruppenname ein. Es werden Berechtigungen erteilt, damit AWS Bedrock die Lambda-Funktion aufrufen kann, sodass der KI-Agent Websuchen über die SERP-API von Bright Data auslösen kann.
- Bedrock-Agent-IAM-Rolle: Erstellt die Ausführungsrolle für den Bedrock-KI-Agenten. Der Agent benötigt Berechtigungen, um das ausgewählte KI-Basismodell aus den unterstützten Modellen (in diesem Fall
amazon.nova-lite-v1:0) aufzurufen. Es wird eine Vertrauensbeziehung definiert, sodass nur Bedrock die Rolle innerhalb Ihres Kontos übernehmen kann. Es wird eine Richtlinie angehängt, die den Zugriff auf das Modell gewährt. - Definition der Aktionsgruppe: Eine Aktionsgruppe definiert die spezifischen Aktionen, die der KI-Agent ausführen kann. Sie verknüpft den Agenten mit der Lambda-Funktion, die es ihm ermöglicht, Websuchen über die SERP-API von Bright Data durchzuführen. Die Aktionsgruppe enthält auch Metadaten für Eingabeparameter, damit der Agent versteht, wie er mit der Funktion interagieren muss und welche Informationen für jede Suche erforderlich sind.
- Definition des Bedrock-KI-Agenten: Definiert den KI-Agenten selbst. Er verknüpft den Agenten mit der Aktionsgruppe und der Ausführungsrolle und enthält eine klare Beschreibung und Anweisungen für seine Verwendung.
Nach der Bereitstellung des CDK-Stacks wird ein KI-Agent in Ihrer AWS-Konsole angezeigt. Dieser Agent kann autonom Websuchen durchführen und aktuelle Informationen abrufen, indem er die Bright Data SERP-API-Integration in der Lambda-Funktion nutzt. Fantastisch!
Schritt 8: Implementieren Sie Lambda für die SERP-API-Integration
Sehen Sie sich diesen Ausschnitt aus dem vorherigen Code an:
lambda_function = _lambda.Function(
self,
LAMBDA_FUNCTION_NAME,
function_name=LAMBDA_FUNCTION_NAME,
runtime=_lambda.Runtime.PYTHON_3_12, # Python-Laufzeit
architecture=_lambda.Architecture.ARM_64,
code=_lambda.Code.from_asset("lambda"), # Lesen Sie den Lambda-Code aus dem Ordner „lambda/“
handler=f"{LAMBDA_FUNCTION_NAME}.lambda_handler",
timeout=Duration.seconds(120),
role=lambda_role, # IAM-Rolle hinzufügen
environment={"LOG_LEVEL": "DEBUG", "ACTION_GROUP": f"{ACTION_GROUP_NAME}"},
)Die Zeile code=_lambda.Code.from_asset("lambda") gibt an, dass der Lambda-Funktionscode aus dem Ordner lambda/ geladen wird. Erstellen Sie daher einen Ordner lambda/ in Ihrem Projekt und fügen Sie darin eine Datei mit dem Namen serp_api_lambda.py hinzu:
Die Datei serp_api_lambda.py muss die Implementierung der Lambda-Funktion enthalten, die vom zuvor definierten KI-Agenten verwendet wird. Implementieren Sie diese Funktion, um die Integration mit der Bright Data SERP-API wie folgt zu handhaben:
import json
import logging
import os
import urllib.parse
import urllib.request
import boto3
# ----------------------------
# Logging-Konfiguration
# ----------------------------
log_level = os.environ.get("LOG_LEVEL", "INFO").strip().upper()
logging.basicConfig(
format="[%(asctime)s] p%(process)s {%(filename)s:%(lineno)d} %(levelname)s - %(message)s"
)
logger = logging.getLogger(__name__)
logger.setLevel(log_level)
# ----------------------------
# AWS-Region aus der Umgebung
# ----------------------------
AWS_REGION = os.environ.get("AWS_REGION")
if not AWS_REGION:
logger.warning("AWS_REGION-Umgebungsvariable nicht gesetzt; boto3 verwendet Standardregion")
# ----------------------------
# Abrufen des geheimen Objekts aus AWS Secrets Manager
# ----------------------------
def get_secret_object(key: str) -> str:
"""
Geheimen Wert aus AWS Secrets Manager abrufen.
"""
session = boto3.session.Session()
client = session.client(
service_name='secretsmanager',
region_name=AWS_REGION
)
try:
get_secret_value_response = client.get_secret_value(
SecretId=key
)
except Exception as e:
logger.error(f"Der geheime Wert '{key}' konnte nicht aus dem Secrets Manager abgerufen werden: {e}")
raise e
secret = json.loads(get_secret_value_response["SecretString"])
return secret
# Bright Data-Anmeldedaten abrufen
bright_data_secret = get_secret_object("BRIGHT_DATA")
BRIGHT_DATA_API_KEY = bright_data_secret["BRIGHT_DATA_API_KEY"]
BRIGHT_DATA_SERP_API_ZONE = bright_data_secret["BRIGHT_DATA_SERP_API_ZONE"]
# ----------------------------
# SERP-API-Websuche
# ----------------------------
def serp_api_web_search(search_query: str) -> str:
"""
Ruft die Bright Data SERP-API auf, um Google-Suchergebnisse abzurufen.
"""
logger.info(f"Ausführung der Bright Data SERP-API-Suche für search_query='{search_query}'")
# Codierung der Abfrage für die URL
encoded_query = urllib.parse.quote(search_query)
# Erstellen der Google-URL zum Scrapen der SERP
search_engine_url = f"https://www.google.com/search?q={encoded_query}"
# Bright Data API-Anfrage (Dokumentation: https://docs.brightdata.com/scraping-automation/serp-api/send-your-first-request)
url = "https://api.brightdata.com/request"
headers = {
"Content-Type": "application/json",
"Authorization": f"Bearer {BRIGHT_DATA_API_KEY}"
}
data = {
"zone": BRIGHT_DATA_SERP_API_ZONE,
"url": search_engine_url,
"format": "raw",
"data_format": "markdown" # Um die SERP als KI-fähiges Markdown-Dokument zu erhalten
}
payload = json.dumps(data).encode("utf-8")
request = urllib.request.Request(url, data=payload, headers=headers)
try:
response = urllib.request.urlopen(request)
response_data: str = response.read().decode("utf-8")
logger.debug(f"Antwort von SERP-API: {response_data}")
return response_data
except urllib.error.HTTPError as e:
logger.error(f"Aufruf der Bright Data SERP-API fehlgeschlagen. HTTP-Fehler {e.code}: {e.reason}")
except urllib.error.URLError as e:
logger.error(f"Aufruf der Bright Data SERP-API fehlgeschlagen. URL-Fehler: {e.reason}")
return ""
# ----------------------------
# Lambda-Handler
# ----------------------------
def lambda_handler(event, _):
"""
AWS Lambda-Handler.
Erwartet Ereignis mit actionGroup, Funktion und optionalen Parametern (einschließlich search_query).
"""
logger.debug(f"lambda_handler mit Ereignis aufgerufen: {event}")
action_group = event.get("actionGroup")
function = event.get("function")
parameters = event.get("parameters", [])
# Extract search_query from parameters
search_query = next(
(param["value"] for param in parameters if param.get("name") == "search_query"),
None,
)
logger.debug(f"Eingabe der Suchanfrage: {search_query}")
serp_page = serp_api_web_search(search_query) if search_query else ""
logger.debug(f"Ergebnisse der Suchanfrage: {serp_page}")
# Lambda-Antwort vorbereiten
function_response_body = {"TEXT": {"body": serp_page}}
action_response = {
"actionGroup": action_group,
"function": function,
"functionResponse": {"responseBody": function_response_body},
}
response = {"response": action_response, "messageVersion": event.get("messageVersion")}
logger.debug(f"lambda_handler response: {response}")
return responseDiese Lambda-Funktion übernimmt drei Hauptaufgaben:
- Sichere Abfrage von API-Anmeldedaten: Ruft den Bright Data API-Schlüssel und die SERP-API aus AWS Secrets Manager ab, sodass sensible Informationen niemals fest codiert werden.
- Durchführung von Websuchen über die SERP-API: Die Suchanfrage wird verschlüsselt, die Google-Such-URL erstellt und eine Anfrage an die Bright Data SERP-API gesendet. Die API gibt die Suchergebnisse im Markdown-Format zurück, einem idealen Datenformat für die Verwendung durch KI.
- Antwort an AWS Bedrock: Gibt die Ergebnisse in einer strukturierten Antwort zurück, die der KI-Agent verwenden kann.
Das war’s schon! Ihre AWS Lambda-Funktion für die Verbindung mit der Bright Data SERP-API wurde nun erfolgreich definiert.
Schritt 9: Bereitstellen Ihrer AWS CDK-Anwendung
Nachdem Ihr CDK-Stack und die zugehörige Lambda-Funktion implementiert wurden, besteht der letzte Schritt darin, Ihren Stack in AWS bereitzustellen. Führen Sie dazu in Ihrem Projektordner den Befehl „deploy“ aus:
cdk deployWenn Sie aufgefordert werden, die Berechtigung zum Erstellen der IAM-Rolle zu erteilen, geben Sie y ein, um zuzustimmen.
Nach einigen Augenblicken sollten Sie, wenn alles wie erwartet funktioniert, eine Ausgabe wie diese sehen:
Wechseln Sie als Nächstes zur Amazon Bedrock -Konsole. Auf der Seite „Agents“ sollten Sie einen Eintrag „web_search_agent“ sehen:
Öffnen Sie den Agenten, um die Details des bereitgestellten Agenten anzuzeigen:
Überprüfen Sie ihn, indem Sie auf die Schaltfläche „Edit and Agent Builder“ klicken. Sie sehen dann genau denselben KI-Agenten,der in„How to Integrate Bright Data SERP-API with AWS Bedrock“ implementiert wurde.
Beachten Sie abschließend, dass Sie den Agenten direkt über die Chat-Oberfläche in der rechten Ecke testen können. Das werden Sie im nächsten und letzten Schritt tun!
Schritt 10: Testen Sie den KI-Agenten
Um die Websuche und die Live-Datenabruf-Funktionen Ihres KI-Agenten zu testen, versuchen Sie es mit einer Eingabe wie:
„Gib mir die drei aktuellsten Nachrichtenartikel zum Shutdown der US-Regierung.“(Hinweis: Dies ist nur ein Beispiel. Sie können also jede Eingabe testen, die Web-Suchergebnisse erfordert.
Dies ist eine ideale Eingabeaufforderung, da sie nach aktuellen Informationen fragt, die das Basismodell allein nicht kennt. Der Agent ruft die in die SERP-API integrierte Lambda-Funktion auf, ruft die Ergebnisse ab und verarbeitet die Daten, um eine kohärente Antwort zu generieren.
Führen Sie diese Eingabeaufforderung im Abschnitt „Agent testen“ Ihres Agenten aus, und Sie sollten eine Ausgabe ähnlich der folgenden sehen:
Hinter den Kulissen ruft der Agent die SERP-API-Lambda-Funktion auf, ruft die neuesten Google-Suchergebnisse für die Abfrage „US government shutdown“ ab und extrahiert die relevantesten Artikel (zusammen mit ihren URLs). Dies ist etwas, was ein Standard-LLM, wie das konfigurierte Nova Lite, nicht alleine leisten kann.
Im Detail ist dies die vom Agenten generierte Antwort:
Die ausgewählten Nachrichtenartikel (und ihre URLs) entsprechen dem, was Sie manuell bei Google für die Suchanfrage „US government shutdown“ finden würden (zumindest zum Zeitpunkt, als der Agent getestet wurde):
Jeder, der schon einmal versucht hat, Google-Suchergebnisse zu scrapen, weiß, wie schwierig dies aufgrund von Bot-Erkennung, IP-Sperren, JavaScript-Rendering und anderen Herausforderungen sein kann. Die Bright Data SERP-API übernimmt all diese Aufgaben für Sie und gibt die gescrapten SERPs im KI-optimierten Markdown-Format (oder HTML, JSON usw.) zurück.
Um zu überprüfen, ob Ihr Agent tatsächlich die SERP-API-Lambda-Funktion aufgerufen hat, klicken Sie im Antwortfeld auf die Schaltfläche „Show trace“ (Verfolgung anzeigen). Scrollen Sie im Abschnitt „Trace step 1“ (Verfolgungsschritt 1) nach unten zum Gruppenaufrufprotokoll, um die Ausgabe des Lambda-Aufrufs zu überprüfen:
Dadurch wird überprüft, ob die Lambda-Funktion erfolgreich ausgeführt wurde und der Agent wie vorgesehen mit der SERP-API interagiert hat. Sie können auch die AWS CloudWatch-Protokolle für Ihre Lambda-Funktion überprüfen, um die Ausführung zu bestätigen.
Zeit, Ihren Agenten weiterzuentwickeln! Testen Sie Eingabeaufforderungen in Bezug auf Faktenprüfung, Markenüberwachung, Markt-Trend-Analyse oder andere Szenarien, um zu sehen, wie er in verschiedenen Anwendungsfällen für Agenten und RAGs abschneidet.
Et voilà! Sie haben erfolgreich einen AWS Bedrock-Agenten erstellt, der mit der SERP-API von Bright Data unter Verwendung von Python und der AWS CDK-Bibliothek integriert ist. Dieser KI-Agent ist in der Lage, aktuelle, zuverlässige und kontextbezogene Web-Suchdaten auf Abruf abzurufen.
Fazit
In diesem Blogbeitrag haben Sie gelernt, wie Sie die SERP-API von Bright Data mithilfe eines AWS CDK Python-Projekts in einen AWS Bedrock KI-Agenten integrieren können. Dieser Workflow ist ideal für Entwickler, die kontextbewusstere KI-Agenten auf AWS erstellen möchten.
Um noch ausgefeiltere KI-Agenten zu erstellen, entdecken Sie die Infrastruktur von Bright Data für KI. Diese bietet eine Reihe von Tools zum Abrufen, Validieren und Transformieren von Live-Webdaten.
Erstellen Sie noch heute kostenlos ein Bright Data-Konto und probieren Sie unsere KI-fähigen Webdatenlösungen aus!
