AWS Germany – Amazon Web Services in Deutschland

Vorschau: Amazon Bedrock Agents

von Antje Barth, übersetzt von Tobias Nitzsche.

Im April hat Swami Sivasubramanian, unser Vizepräsident für Daten und maschinelles Lernen, in seinem Post zu neuen Werkzeugen, welche für die Erstellung generativer Künstlicher Intelligenz auf AWS genutzt werden können, Amazon Bedrock und unsere Amazon Titan Modelle angekündigt.

Amazon Bedrock ist derzeit als Vorschau verfügbar. Amazon Bedrock ist einen neuer, vollständig verwalteter Service. Dieser stellt Grundmodelle (engl. Foundation Models, FMs) von Amazon sowie führenden KI-Startups wie AI21 Labs [Extern], Anthropic [EN, Extern], Cohere [EN, Extern] und Stability AI [EN, Extern] über eine API bereit.

Heute freuen wir uns Ihnen eine Vorschau auf eine neue Funktion namens Amazon Bedrock Agents [EN] vorstellen zu können. Diese werden es Entwickler:innen ermöglichen voll verwaltete Agents mit nur wenigen Klicks zu erstellen. Agents beschleunigen die Bereitstellung von generativen KI-Anwendungen, indem sie bestimmte Aufgaben verwalten und durchführen können. Sie tun dies, indem sie unter anderem API-Anfragen an Unternehmenssysteme senden. Dabei sind die Agents in der Lage Benutzeranfragen zu verstehen, komplexe Aufgaben in mehrere Schritte zu unterteilen, Gespräche zu führen, sowie zusätzliche Informationen zu sammeln und Maßnahmen zu ergreifen, um die ursprünglichen Anfragen der Nutzer:innen bestmöglich zu erfüllen.

Mit den Agents für Amazon Bedrock können Sie verschiedene Aufgaben für Ihre internen und externen Kund:innen automatisieren. Hierzu gehören beispielsweise das Verwalten von Einzelhandelsbestellungen oder die Bearbeitung von Versicherungsansprüchen. Mit einer durch Agents gesteuerten generativen KI-e-Commerce-Anwendung können Sie nicht nur auf Kundenfragen wie „Haben Sie diese Jacke auch in Blau?“ mit einer simplen Antwort reagieren – Sie können Ihren Kund:innen auch bei der Aktualisierung ihrer Bestellungen oder beim Austausch von Produkten unterstützen.

Um diese Funktionen zu ermöglichen, sind zwei Hauptaspekte zu beachten:

  1. Zugriff auf Externe Datenquellen: Sie müssen ihrem Agent Zugang zu externen Datenquellen ermöglichen und ihn eventuell mit den APIs anderer Anwendungen verbinden. Das ermöglicht dem FM, welches den Agent treibt, mit der Außenwelt zu interagieren und seinen Nutzer:innen durch natürliche Sprachverarbeitung behilflich zu sein.
  2. Planung der Aktionen: Das FM muss bestimmen, welche Maßnahmen zu ergreifen sind, welche Informationen verwendet werden sollen und in welcher Reihenfolge die Aktionen durchgeführt werden müssen. Dies wird durch eine neue Fähigkeit der FMs möglich – die Fähigkeit zum strukturierten Durchdenken.

Zusätzlich können Sie FMs durch eigene Eigaben (engl. Prompts) auch dazu anleiten, wie sie mit diesen Interaktionen umgehen sollen, und wie sie die Aufgaben durchdenken sollen. Dieser Prozess, bei dem Sie Prompts entwerfen, um das Modell zu den gewünschten Ergebnissen zu führen, wird auch als Prompt Engineering bezeichnet.

Amazon Bedrock Agents

Amazon Bedrock Agents automatisieren komplexe Aufgaben, indem sie Anfragen in natürlicher Sprache bearbeiten und entsprechende Aktionen durchführen. Sobald ein Agent aktiv ist, generiert dieser automatisch Prompts und integriert dabei unternehmensspezifische Informationen, um in natürlicher Sprache zu antworten. Der Agent analysiert die vom Benutzer geforderten Aufgaben, zerlegt sie ggf. in kleinere Schritte und koordiniert die nötigen Aktionen wie API-Aufrufe und Datenabfragen, um die Aufgabe bestmöglich abzuschließen.

Die Amazon Bedrock Agents sind vollständig verwaltet, sodass Sie sich nicht mit technischen Details befassen müssen. Sie unterstützen Funktionen wie Überwachung, Verschlüsselung und Benutzerberechtigungen – all das ohne benutzerdefinierten Code schreiben zu müssen. Entwickler:innen können die Bedrock-Konsole [EN] oder ein SDK verwenden, um Ihr API-Schema bereitzustellen. Der Agent koordiniert dann die Aufgaben mit FMs und führt API-Aufrufe über entsprechende AWS Lambda-Funktionen durch.

Advanced Reasoning und ReAct

Mit der Prompt-Engineering-Technik ReAct (eine Kombination aus REASONING und ACTING) [EN, Extern] ist es möglich, FMs darin zu unterstützen, ihre “Gedanken“ zu strukturieren und Problemlösungsstrategien zu entwickeln. ReAct ermöglicht es Ihnen, Anweisungen so zu gestalten, dass sie den FMs klar vermitteln, wie eine bestimmte Aufgabe geplant und durchgeführt werden kann. Dies erleichtert die Entscheidungsfindung über die zu ergreifenden Maßnahmen, um die vom Benutzer gestellten Aufgaben zu lösen. Die durch ReAct strukturierten Anweisungen bestehen aus einer geordneten Serie von Fragen, Gedanken, Handlungen und Beobachtungsbeispielen, die den Lösungsweg deutlich aufzeigen.

Die “Frage” bezeichnet hierbei die Aufgabe oder das Problem, das von Benutzer:innen gestellt wurde. Unter „Gedanke“ versteht man einen Schritt der Überlegung, der dem FM hilft, das Problem zu analysieren und eine entsprechende Lösung zu finden. Die „Aktion“ wiederum ist ein bestimmter Befehl aus einem vorgegebenen Set von APIs, den das Modell aufrufen kann, um eine Aufgabe zu erfüllen. Das „Ergebnis“ oder die „Beobachtung“ beschreibt das Resultat, das nach Durchführung der Aktion erzielt wurde. Die möglichen Aktionen, die das FM nutzen kann, sind durch eine Reihe von Anweisungen festgelegt, die dem eigentlichen Beispieltext oder der Aufforderung vorausgehen. Hier folgt eine Erläuterung, wie Sie eine ReAct-Aufforderung entsprechend aufbauen könnten:

Die gute Nachricht: Bedrock übernimmt die schwere Arbeit für Sie!
Im Hintergrund erstellen die Agents Anfragen an Amazon Bedrock. Diese basieren auf Ihren bereitgestellten Informationen und Aufforderungen.

Nun möchten wir Ihnen zeigen, wie Sie mit Amazon Bedrock Agents starten können.

Einen Amazon Bedrock Agent erstellen

Nehmen wir an, Sie sind als Entwickler:in bei einer Versicherungsgesellschaft tätig und Ihre Aufgabe besteht darin, eine generative KI-Anwendung zu entwickeln. Diese soll Inhaber:innen von Versicherungsagenturen unterstützen, indem sie wiederkehrende Aufgaben automatisiert. Sie nutzen Bedrock, um Agents zu erstellen und in Ihre Anwendung zu integrieren.

Folgen Sie diesen Schritten:

  1. Öffnen Sie die Bedrock-Konsole [EN], wählen Sie dann im linken Navigationsbereich „Agents“ und klicken Sie auf „Create Agent„.
  2. Beginnen Sie mit der Agentenerstellung:
    1. Füllen Sie die Details aus (Agentenname, Beschreibung, Berechtigungen).
    2. Wählen Sie eine AWS Identity and Access Management (IAM) Rolle, welche Zugang zu den Diensten Amazon Simple Storage Service (Amazon S3) und AWS Lambda erlaubt.

  3. Wählen Sie ein FM aus Bedrock und geben Sie dem Agent eine Anweisung in natürlicher Sprache, z. B.: „You are an agent designed to help with processing insurance claims and managing pending paperwork.“.
  4. Fügen Sie Aktionsgruppen hinzu:
    1. Definieren Sie eine Aktionsgruppe, z. B. „ClaimManagementActionGroup“.
    2. Legen Sie die APIs fest und implementieren Sie eine Lambda-Funktion, die die Geschäftslogik repräsentiert.


    Die Logik könnte in einer Lambda-Funktion namens „InsuranceClaimsLambda “ erfasst sein, die die API-Aufrufe wie open-claims, identify-missing-documents und send-reminders verwaltet. Hier ist ein kurzer Auszug aus meiner OrderManagementLambda:

    import json
    import time
     
    def open_claims():
        ...
    
    def identify_missing_documents(parameters):
        ...
     
    def send_reminders():
        ...
     
    def lambda_handler(event, context):
        responses = []
     
        for prediction in event['actionGroups']:
            response_code = ...
            action = prediction['actionGroup']
            api_path = prediction['apiPath']
            
            if api_path == '/claims':
                body = open_claims() 
            elif api_path == '/claims/{claimId}/identify-missing-documents':
    			parameters = prediction['parameters']
                body = identify_missing_documents(parameters)
            elif api_path == '/send-reminders':
                body =  send_reminders()
            else:
                body = {"{}::{} is not a valid api, try another one.".format(action, api_path)}
     
            response_body = {
                'application/json': {
                    'body': str(body)
                }
            }
            
            action_response = {
                'actionGroup': prediction['actionGroup'],
                'apiPath': prediction['apiPath'],
                'httpMethod': prediction['httpMethod'],
                'httpStatusCode': response_code,
                'responseBody': response_body
            }
            
            responses.append(action_response)
     
        api_response = {'response': responses}
     
        return api_response

    Beachten Sie, dass Sie das API-Schema im OpenAPI-Schema-JSON-Format (EN) angeben, z. B. in einer Datei namens insurance_claim_schema.json.

    "openapi": "3.0.0",
        "info": {
            "title": "Insurance Claims Automation API",
            "version": "1.0.0",
            "description": "APIs for managing insurance claims by pulling a list of open claims, identifying outstanding paperwork for each claim, and sending reminders to policy holders."
        },
        "paths": {
            "/claims": {
                "get": {
                    "summary": "Get a list of all open claims",
                    "description": "Get the list of all open insurance claims. Return all the open claimIds.",
                    "operationId": "getAllOpenClaims",
                    "responses": {
                        "200": {
                            "description": "Gets the list of all open insurance claims for policy holders",
                            "content": {
                                "application/json": {
                                    "schema": {
                                        "type": "array",
                                        "items": {
                                            "type": "object",
                                            "properties": {
                                                "claimId": {
                                                    "type": "string",
                                                    "description": "Unique ID of the claim."
                                                },
                                                "policyHolderId": {
                                                    "type": "string",
                                                    "description": "Unique ID of the policy holder who has filed the claim."
                                                },
                                                "claimStatus": {
                                                    "type": "string",
                                                    "description": "The status of the claim. Claim can be in Open or Closed state"
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            },
            "/claims/{claimId}/identify-missing-documents": {
                "get": {
                    "summary": "Identify missing documents for a specific claim",
                    "description": "Get the list of pending documents that need to be uploaded by policy holder before the claim can be processed. The API takes in only one claim id and returns the list of documents that are pending to be uploaded by policy holder for that claim. This API should be called for each claim id",
                    "operationId": "identifyMissingDocuments",
                    "parameters": [{
                        "name": "claimId",
                        "in": "path",
                        "description": "Unique ID of the open insurance claim",
                        "required": true,
                        "schema": {
                            "type": "string"
                        }
                    }],
                    "responses": {
                        "200": {
                            "description": "List of documents that are pending to be uploaded by policy holder for insurance claim",
                            "content": {
                                "application/json": {
                                    "schema": {
                                        "type": "object",
                                        "properties": {
                                            "pendingDocuments": {
                                                "type": "string",
                                                "description": "The list of pending documents for the claim."
                                            }
                                        }
                                    }
                                }
                            }
    
                        }
                    }
                }
            },
            "/send-reminders": {
                "post": {
                    "summary": "API to send reminder to the customer about pending documents for open claim",
                    "description": "Send reminder to the customer about pending documents for open claim. The API takes in only one claim id and its pending documents at a time, sends the reminder and returns the tracking details for the reminder. This API should be called for each claim id you want to send reminders for.",
                    "operationId": "sendReminders",
                    "requestBody": {
                        "required": true,
                        "content": {
                            "application/json": {
                                "schema": {
                                    "type": "object",
                                    "properties": {
                                        "claimId": {
                                            "type": "string",
                                            "description": "Unique ID of open claims to send reminders for."
                                        },
                                        "pendingDocuments": {
                                            "type": "string",
                                            "description": "The list of pending documents for the claim."
                                        }
                                    },
                                    "required": [
                                        "claimId",
                                        "pendingDocuments"
                                    ]
                                }
                            }
                        }
                    },
                    "responses": {
                        "200": {
                            "description": "Reminders sent successfully",
                            "content": {
                                "application/json": {
                                    "schema": {
                                        "type": "object",
                                        "properties": {
                                            "sendReminderTrackingId": {
                                                "type": "string",
                                                "description": "Unique Id to track the status of the send reminder Call"
                                            },
                                            "sendReminderStatus": {
                                                "type": "string",
                                                "description": "Status of send reminder notifications"
                                            }
                                        }
                                    }
                                }
                            }
                        },
                        "400": {
                            "description": "Bad request. One or more required fields are missing or invalid."
                        }
                    }
                }
            }
        }
    }

    Wenn eine Nutzer:in nun ihren Agent anweist, eine bestimmte Aufgabe auszuführen, greift Amazon Bedrock auf das von Ihnen festgelegte FM für ihren Agent zurück.
    Dieses FM bestimmt die Reihenfolge der durchzuführenden Aktionen. Anschließend ruft Bedrock die dazugehörigen Lambda-Funktionen in der festgelegten Reihenfolge auf, um die von der Kund:in gewünschte Aufgabe zu erfüllen.

  5. Überprüfen Sie Ihre Konfiguration und wählen Sie „Create Agent„:
  6. Fertigstellung: Herzlichen Glückwunsch! Sie haben soeben Ihren ersten Amazon Bedrock Agent erstellt!

Einen Amazon Bedrock Agent erstellen

Um einen Agent in Ihrer Anwendung zu erstellen, müssen Sie einen Alias erstellen. Bedrock erstellt dann automatisch eine Version für diesen Alias.

  1. Agent auswählen: Öffnen Sie die Bedrock-Konsole, wählen Sie Ihren Agent, und klicken Sie auf „Deploy“ und „Create„, um einen Alias zu erstellen.
  2. Alias-Daten eingeben: Geben Sie einen Alias-Namen und eine Beschreibung ein. Entscheiden Sie außerdem, ob Sie eine neue Version erstellen oder eine vorhandene Version Ihres Agent mit diesem Alias verknüpfen möchten.
  3. Alias mit Momentaufnahme verknüpfen: Dieser Schritt speichert eine Momentaufnahme des Agentencodes und der Konfiguration und verknüpft den Alias mit dieser Momentaufnahme oder Version. Mit dem Alias können Sie dann den Agent in Ihre Anwendungen integrieren.
  4. Testen Sie Ihren Versicherungsagenten: Dies können Sie direkt in der Bedrock-Konsole tun.
    Fragen Sie den Agent, „Send reminder to all policy holders with open claims and pending paper work“ Beobachten Sie, wie der FM-betriebene Agent die Benutzeranfrage versteht, die Aufgabe in Schritte unterteilt (zum Beispiel die offenen Versicherungsansprüche erheben, die Anspruchs-IDs abfragen, Erinnerungen senden) und die erforderlichen Aktionen durchführt.

    Fragen wir den Agent, „Send reminder to all policy holders with open claims and pending paper work“ Sie können sehen, wie der FM-betriebene Agent in der Lage ist, die Benutzeranfrage zu verstehen, die Aufgabe in Schritte zu unterteilen (die offenen Versicherungsansprüche erheben, die Anspruchs-IDs abfragen, Erinnerungen senden) und die entsprechenden Aktionen auszuführen.

    Amazon Bedrock Agents können in vielfältigen Bereichen eingesetzt werden, sei es zur Steigerung der Produktivität, Verbesserung des Kundenservice-Erlebnisses oder zur Automatisierung von DevOps-Aufgaben. Wir freuen uns zu sehen, welche Anwendungsfälle Sie mit dieser Technologie umsetzen werden!

Grundlagen generativer KI verstehen

Wenn Sie daran interessiert sind, sich mit den Grundlagen der generativen KI und der Arbeit mit FMs auseinanderzusetzen, einschließlich fortschrittlicher Techniken zur Aufforderung und dem Umgang mit Agents, sollten Sie den neuen praxisorientierten Kurs in Erwägung ziehen. Dieser wurde in Zusammenarbeit von AWS-Kollegen und Experten bei DeepLearning.AI [EN, Extern] entwickelt:

„Generative KI mit großen Sprachmodellen (LLMs)“ [EN, Extern] ist ein dreiwöchiger On-Demand-Kurs, der sich an Datenwissenschaftler und Ingenieure richtet. Hier lernen Sie, wie generative KI-Anwendungen mit LLMs erstellt werden können. Der Kurs bildet die ideale Grundlage, um mit Amazon Bedrock zu starten. Melden Sie sich noch heute an, um mehr über generative KI mit LLMs zu erfahren [EN, Extern].

Mehr über Amazon Bedrock erfahren

Amazon Bedrock [EN] ist derzeit in der Vorschauphase. Wenn Sie an einem Zugang zu den Agents für Amazon Bedrock im Rahmen dieser Vorschau interessiert sind, stehen wir für Sie zur Verfügung. Neue Kund:innen erhalten regelmäßig Zugang. Um auf dem neuesten Stand zu bleiben, besuchen Sie bitte die Amazon Bedrock Features-Seite [EN] und melden Sie sich noch heute an [EN].

Antje [Extern] & Tobi [Extern]

Über die Autoren

Antje Barth

Antje Barth

Antje Barth ist Principal Developer Advocate für AI und ML bei AWS. Sie ist Co-Autorin des O’Reilly-Buchs – Data Science auf AWS. Antje spricht häufig auf AI/ML-Konferenzen, Veranstaltungen und Meetups auf der ganzen Welt. Sie hat auch das Düsseldorfer Kapitel von Women in Big Data mitbegründet.