

Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.

# Erstellen Sie eine RAG-Anwendung mit Amazon Bedrock Knowledge Bases
<a name="tutorial-build-rag-with-bedrock"></a>

Viele Unternehmen sammeln auf ihren NFS- und SMB-Fileshares umfangreiche Dokumentenspeicher — Produkthandbücher, Richtliniendokumente, Verträge, Forschungsberichte, technische Spezifikationen und benutzergenerierte Inhalte.

Mit einem Amazon S3 S3-Zugriffspunkt, der an das FSx for ONTAP-Volume angeschlossen ist, nimmt Amazon Bedrock Knowledge Bases Inhalte direkt vom Volume auf. Foundation-model Antworten basieren auf den Dokumenten, in denen Ihre Teams sie über NFS oder SMB speichern. Inhalte, die Autoren beim Teilen aktualisieren, werden bei der nächsten Synchronisierung für die Wissensdatenbank verfügbar.

In diesem Tutorial laden Sie einen kleinen Satz von Beispiel-PDFs über einen Amazon S3 S3-Zugriffspunkt auf Ihr FSx for ONTAP-Volume hoch, erstellen eine Amazon Bedrock-Wissensdatenbank, die auf den Access Point verweist, nehmen die Dokumente auf und führen eine Frage über die API aus. `RetrieveAndGenerate`

**Anmerkung**  
Die Bearbeitung dieses Tutorials dauert etwa **35 bis 45 Minuten**. Für die AWS-Services verwendeten Ressourcen fallen Gebühren für die von Ihnen erstellten Ressourcen an. Wenn Sie alle Schritte, einschließlich des Abschnitts **Aufräumen**, umgehend abschließen, belaufen sich die voraussichtlichen Kosten im Osten der USA (Nord-Virginia) AWS-Region auf weniger als **1$**. In dieser Schätzung sind die laufenden Gebühren für das FSx for ONTAP-Volumen selbst nicht enthalten.

## Voraussetzungen
<a name="tutorial-bedrock-kb-prerequisites"></a>

Stellen Sie vor dem Beginn sicher, dass Sie über das Folgende verfügen:
+ Ein FSx for ONTAP-Volume mit angeschlossenem Amazon S3 S3-Zugriffspunkt. Der Access Point muss über einen **Internetnetzwerk-Ursprung** verfügen, damit der Amazon Bedrock-Service ihn erreichen kann. Anweisungen zum Erstellen eines Access Points finden Sie unter[Erstellen eines Zugriffspunkts](fsxn-creating-access-points.md).
+ Der Modellzugriff ist aktiviert für ein Einbettungsmodell, das von Amazon Bedrock Knowledge Bases unterstützt wird, und für mindestens ein Textgenerierungsmodell (z. B.`amazon.nova-lite-v1:0`), in AWS-Region dem Sie die Wissensdatenbank erstellen werden. In diesem Tutorial werden `amazon.titan-embed-text-v2:0` (1024 Dimensionen) als Einbettungsmodell verwendet. Cohere Embed-Modelle werden ebenfalls unterstützt. Wenn Sie ein anderes Einbettungsmodell wählen, passen Sie die Größe des Vektorindexes in Schritt 2 an die Ausgabedimension des Modells an. Der Modellzugriff ist in der Amazon Bedrock-Konsole unter **Modellzugriff** aktiviert. Weitere Informationen finden Sie unter [Zugriff auf Amazon Bedrock Foundation-Modelle](https://docs.aws.amazon.com/bedrock/latest/userguide/model-access.html) im *Amazon Bedrock-Benutzerhandbuch*.
+ AWS CLI Version 2 wurde mit Anmeldeinformationen installiert und konfiguriert, mit denen IAM-Rollen, Amazon S3 Vectors-Ressourcen und Amazon Bedrock Knowledge Bases erstellt werden können.

## Schritt 1: Laden Sie Beispieldokumente auf den Access Point hoch
<a name="tutorial-bedrock-kb-upload"></a>

Laden Sie einige öffentliche PDF-Dateien herunter, um sie als Beispielkorpus zu verwenden, und laden Sie sie dann mit dem Amazon S3 S3-Zugriffspunkt-Alias auf Ihren Access Point hoch.

1. Erstellen Sie ein lokales Verzeichnis und laden Sie Beispiel-PDFs herunter.

   ```
   $ mkdir -p ~/kb-pdfs && cd ~/kb-pdfs
   curl -sSL -o aws-overview.pdf https://d1.awsstatic.com/whitepapers/aws-overview.pdf
   curl -sSL -o wellarchitected-framework.pdf https://docs.aws.amazon.com/pdfs/wellarchitected/latest/framework/wellarchitected-framework.pdf
   curl -sSL -o s3-userguide.pdf https://docs.aws.amazon.com/pdfs/AmazonS3/latest/userguide/s3-userguide.pdf
   ```

1. Laden Sie jede Datei auf den Access Point hoch. {{access-point-alias}}Ersetzen Sie es durch Ihren Access Point-Alias (z. B.`my-kb-ap-a1b2c3d4e5f6g7h8i9j0kl1mnop2uuse1a-ext-s3alias`). Sie finden den Alias in der Amazon FSx-Konsole unter **Angehängte Amazon S3 S3-Zugriffspunkte** für Ihr Volume oder indem Sie es ausführen`aws fsx describe-s3-access-point-attachments`.

   ```
   $ for f in *.pdf; do
       aws s3 cp "$f" "s3://{{access-point-alias}}/$f"
   done
   ```

1. Überprüfen Sie, ob die Dateien auf dem Volume gelandet sind.

   ```
   $ aws s3 ls s3://{{access-point-alias}}/
   ```

**Anmerkung**  
Amazon Bedrock Knowledge Bases erzwingt eine maximale Dateigröße von 50 MB pro Dokument. Dateien, die größer als 50 MB sind, werden bei der Aufnahme übersprungen.

## Schritt 2: Erstellen Sie einen Vektorspeicher
<a name="tutorial-bedrock-kb-vector-store"></a>

Die Wissensdatenbank speichert eingebettete Dokumente in einem Vektorspeicher. Amazon Bedrock Knowledge Bases unterstützt mehrere Vector Stores. In diesem Tutorial wird Amazon S3 Vectors als Standard verwendet, da es für RAG-Workloads kostenoptimiert ist und nur eine minimale Einrichtung erfordert. Amazon OpenSearch Serverless wird ebenfalls unterstützt. Anweisungen dazu finden Sie im zusammenklappbaren Abschnitt am Ende dieses Schritts.

### Um den Vector Store mit der Konsole zu erstellen
<a name="tutorial-bedrock-kb-vector-store-console"></a>

Wenn Sie die Konsole zum Erstellen der Wissensdatenbank verwenden[Schritt 4: Erstellen Sie die Wissensdatenbank und die Datenquelle](#tutorial-bedrock-kb-create-kb), wählen Sie im Schritt **Vector-Datenbank die Option Schnell einen neuen Vektorspeicher** **erstellen** und wählen Sie entweder **Amazon S3** Vectors (empfohlen) oder **Amazon OpenSearch Serverless** aus. Amazon Bedrock erstellt den Vector Store und alle erforderlichen Konfigurationen automatisch. Fahren Sie mit [Schritt 3: Erstellen Sie eine IAM-Rolle für die Wissensdatenbank](#tutorial-bedrock-kb-iam-role) fort.

### So erstellen Sie einen Amazon S3 Vectors-Vektorspeicher mit dem AWS CLI
<a name="tutorial-bedrock-kb-vector-store-cli"></a>

1. Erstellen Sie einen Amazon S3 S3-Vektor-Bucket. Vektor-Bucket-Namen folgen denselben globalen Eindeutigkeitsregeln wie standardmäßige Amazon S3 S3-Buckets. In diesem Tutorial wird Folgendes verwendet`fsxn-kb-vectors`: durch einen eindeutigen Namen ersetzen.

   ```
   $ aws s3vectors create-vector-bucket --vector-bucket-name fsxn-kb-vectors
   ```

1. Erstellen Sie einen Vektorindex im Bucket. Die Indexdimension muss mit der Ausgabedimension des Einbettungsmodells übereinstimmen; Titan Text Embeddings v2 gibt 1024 Dimensionen aus. `nonFilterableMetadataKeys`Durch die Einstellung werden die Bedrock-Metadatenfelder als nicht filterbar markiert, sodass sie die Obergrenze von 2 KB pro Vektor für filterbare Metadaten nicht überschreiten.

   ```
   $ aws s3vectors create-index --vector-bucket-name fsxn-kb-vectors \
       --index-name bedrock-kb-index \
       --dimension 1024 --distance-metric cosine --data-type float32 \
       --metadata-configuration '{"nonFilterableMetadataKeys":["AMAZON_BEDROCK_METADATA","AMAZON_BEDROCK_TEXT"]}'
   ```

   Beachten Sie das `indexArn` in der Antwort; Sie verwenden es in. [Schritt 4: Erstellen Sie die Wissensdatenbank und die Datenquelle](#tutorial-bedrock-kb-create-kb)

### Alternative: Erstellen Sie einen OpenSearch Service Serverless Vector Store mit dem AWS CLI
<a name="tutorial-bedrock-kb-vector-store-oss"></a>

Wenn Sie OpenSearch Service Serverless bevorzugen (für höhere Abfragen pro Sekunde, erweiterte Suchfunktionen oder bestehende Betriebserfahrung), verwenden Sie die folgenden Schritte anstelle des oben beschriebenen Amazon S3 Vectors-Verfahrens.

1. Erstellen Sie Verschlüsselungs- und Netzwerksicherheitsrichtlinien für die Sammlung.

   ```
   $ aws opensearchserverless create-security-policy --name kb-enc --type encryption \
       --policy '{"Rules":[{"ResourceType":"collection","Resource":["collection/fsxn-kb"]}],"AWSOwnedKey":true}'
   aws opensearchserverless create-security-policy --name kb-net --type network \
       --policy '[{"Rules":[{"ResourceType":"collection","Resource":["collection/fsxn-kb"]},{"ResourceType":"dashboard","Resource":["collection/fsxn-kb"]}],"AllowFromPublic":true}]'
   ```

1. Erstellen Sie eine Datenzugriffsrichtlinie, die der Rolle „Wissensdatenbank“ und Ihrem aktuellen Benutzer die Rechte zum Lesen und Schreiben der Sammlung gewährt. Ersetzen Sie {{account-id}} und {{current-user}} durch Ihre Werte.

   ```
   $ aws opensearchserverless create-access-policy --name kb-data --type data --policy '[{
       "Rules":[
           {"ResourceType":"index","Resource":["index/fsxn-kb/*"],"Permission":["aoss:*"]},
           {"ResourceType":"collection","Resource":["collection/fsxn-kb"],"Permission":["aoss:*"]}
       ],
       "Principal":[
           "arn:aws:iam::{{account-id}}:role/fsxn-kb-role",
           "arn:aws:iam::{{account-id}}:user/{{current-user}}"
       ]
   }]'
   ```

1. Erstelle die Sammlung und warte, bis sie fertig ist`ACTIVE`.

   ```
   $ aws opensearchserverless create-collection --name fsxn-kb --type VECTORSEARCH
   aws opensearchserverless batch-get-collection --names fsxn-kb \
       --query 'collectionDetails[0].{status:status,endpoint:collectionEndpoint}'
   ```

1. Erstellen Sie den Vektorindex für die Sammlung mithilfe eines Python-Skripts mit signierten Anfragen. Der Index muss die Dimension 1024 (für Titan Text Embeddings v2) und Feldnamen verwenden, die Amazon Bedrock Knowledge Bases erwartet. Das vollständige Skript und die nachfolgenden Konfigurationsschritte finden Sie unter [Voraussetzungen für die Nutzung von OpenSearch Service Serverless](https://docs.aws.amazon.com/bedrock/latest/userguide/knowledge-base-setup-oss.html) im *Amazon Bedrock-Benutzerhandbuch*. Verwenden Sie den resultierenden Sammlungs-ARN und den Indexnamen in Schritt 4 mit dem Typ `storage-configuration` of`OPENSEARCH_SERVERLESS`.

## Schritt 3: Erstellen Sie eine IAM-Rolle für die Wissensdatenbank
<a name="tutorial-bedrock-kb-iam-role"></a>

Die Wissensdatenbank benötigt eine IAM-Rolle, die sie übernehmen kann, um das Einbettungsmodell aufzurufen, Objekte über den Amazon S3 S3-Zugriffspunkt zu lesen und auf den Vektorspeicher zuzugreifen. Die unten abgebildete Richtlinie gewährt Zugriff auf einen Amazon S3 Vectors-Vektorspeicher. Wenn Sie stattdessen OpenSearch Service Serverless verwenden, ersetzen Sie die `S3Vectors` Anweisung durch eine, die `aoss:APIAccessAll` der Sammlung ARN gewährt.

### Um die Rolle mit der Konsole zu erstellen
<a name="tutorial-bedrock-kb-iam-role-console"></a>

Wenn Sie die Wissensdatenbank mithilfe der Amazon Bedrock-Konsole in **erstellen[Schritt 4: Erstellen Sie die Wissensdatenbank und die Datenquelle](#tutorial-bedrock-kb-create-kb), wählen Sie Create and use a new service role** aus. Amazon Bedrock erstellt eine Rolle mit dem erforderlichen Vertrauen und den erforderlichen Berechtigungen, die auf Ihre Wissensdatenbank, Ihr Einbettungsmodell, Ihren Vektorspeicher und Ihre Datenquelle zugeschnitten ist. Fahren Sie mit [Schritt 4: Erstellen Sie die Wissensdatenbank und die Datenquelle](#tutorial-bedrock-kb-create-kb) fort.

### Um die Rolle mit dem zu erstellen AWS CLI
<a name="tutorial-bedrock-kb-iam-role-cli"></a>

1. Speichern Sie die folgende Vertrauensrichtlinie unter`kb-trust-policy.json`. Dadurch kann Amazon Bedrock die Rolle übernehmen. Ersetze es {{account-id}} durch deine AWS-Konto ID.

   ```
   {
       "Version": "2012-10-17", 		 	 	 
       "Statement": [{
           "Effect": "Allow",
           "Principal": {"Service": "bedrock.amazonaws.com"},
           "Action": "sts:AssumeRole",
           "Condition": {"StringEquals": {"aws:SourceAccount": "{{account-id}}"}}
       }]
   }
   ```

1. Speichern Sie die folgende Berechtigungsrichtlinie unter`kb-permissions.json`. Es gewährt Zugriff auf das Einbettungsmodell, den Amazon S3 S3-Zugangspunkt und den Vector Store. Ersetzen Sie die Platzhalter durch Ihre Werte.

   ```
   {
       "Version": "2012-10-17", 		 	 	 
       "Statement": [
           {
               "Sid": "FoundationModel",
               "Effect": "Allow",
               "Action": ["bedrock:InvokeModel"],
               "Resource": ["arn:aws:bedrock:{{region}}::foundation-model/amazon.titan-embed-text-v2:0"]
           },
           {
               "Sid": "S3AccessPoint",
               "Effect": "Allow",
               "Action": ["s3:GetObject", "s3:ListBucket"],
               "Resource": [
                   "arn:aws:s3:{{region}}:{{account-id}}:accesspoint/{{access-point-name}}",
                   "arn:aws:s3:{{region}}:{{account-id}}:accesspoint/{{access-point-name}}/object/*"
               ]
           },
           {
               "Sid": "S3Vectors",
               "Effect": "Allow",
               "Action": [
                   "s3vectors:GetIndex",
                   "s3vectors:PutVectors",
                   "s3vectors:GetVectors",
                   "s3vectors:ListVectors",
                   "s3vectors:DeleteVectors",
                   "s3vectors:QueryVectors"
               ],
               "Resource": [
                   "arn:aws:s3vectors:{{region}}:{{account-id}}:bucket/fsxn-kb-vectors",
                   "arn:aws:s3vectors:{{region}}:{{account-id}}:bucket/fsxn-kb-vectors/index/*"
               ]
           }
       ]
   }
   ```

1. Erstellen Sie die Rolle und fügen Sie die Berechtigungsrichtlinie hinzu.

   ```
   $ aws iam create-role --role-name fsxn-kb-role \
       --assume-role-policy-document file://kb-trust-policy.json
   aws iam put-role-policy --role-name fsxn-kb-role --policy-name kb-access \
       --policy-document file://kb-permissions.json
   ```

## Schritt 4: Erstellen Sie die Wissensdatenbank und die Datenquelle
<a name="tutorial-bedrock-kb-create-kb"></a>

Die Datenquelle verweist auf Ihren Amazon S3 S3-Zugangspunkt-Alias. Amazon Bedrock Knowledge Bases akzeptiert den Access Point-Alias anstelle eines Bucket-Namens.

### Um die Wissensdatenbank mit der Konsole zu erstellen
<a name="tutorial-bedrock-kb-create-kb-console"></a>

1. Öffnen Sie die Amazon Bedrock-Konsole unter [https://console.aws.amazon.com/bedrock/](https://console.aws.amazon.com/bedrock/).

1. Wählen Sie im linken Navigationsbereich **Wissensdatenbanken** und dann **Wissensdatenbank erstellen** aus.

1. Geben Sie unter **Wissensdatenbankdetails** einen Namen (z. B.`fsxn-kb`) und eine Beschreibung ein.

1. Wählen Sie unter **IAM-Berechtigungen** die Option **Neue Servicerolle erstellen und verwenden** aus.

1. Wählen Sie als **Datenquelle** **Amazon S3** und dann **Weiter** aus.

1. Geben Sie einen Datenquellennamen ein (z. B.`fsxn-s3ap-source`).

1. Geben Sie für **S3-URI** ein, `s3://` gefolgt von Ihrem Access Point-Alias, zum Beispiel`s3://my-kb-ap-a1b2c3d4e5f6g7h8i9j0kl1mnop2uuse1a-ext-s3alias`. Die Konsole unterscheidet in diesem Feld nicht zwischen einem Bucket-Namen und einem Access Point-Alias. Der Access Point-Alias wird unverändert akzeptiert.

1. Wählen Sie **Weiter** aus.

1. Wählen Sie unter **Embeddings-Modell die Option **Titan Text** Embeddings** v2 aus.

1. Wählen Sie unter **Vector database** die Option **Quick create a new vector store** und wählen Sie **Amazon S3 Vectors** aus. Wählen Sie **Weiter** aus.

1. Überprüfen Sie die Konfiguration und wählen Sie **Wissensdatenbank erstellen** aus. Die Erstellung der Wissensdatenbank kann mehrere Minuten dauern.

### Um die Wissensdatenbank mit dem zu erstellen AWS CLI
<a name="tutorial-bedrock-kb-create-kb-cli"></a>

1. Erstellen Sie die Wissensdatenbank. Ersetzen Sie die Platzhalter durch Ihre Werte. Das `indexArn` ist der ARN des Amazon S3 S3-Vektorindex, den Sie in Schritt 2 erstellt haben.

   ```
   $ aws bedrock-agent create-knowledge-base --name fsxn-kb \
       --role-arn arn:aws:iam::{{account-id}}:role/fsxn-kb-role \
       --knowledge-base-configuration '{
           "type":"VECTOR",
           "vectorKnowledgeBaseConfiguration":{
               "embeddingModelArn":"arn:aws:bedrock:{{region}}::foundation-model/amazon.titan-embed-text-v2:0"
           }
       }' \
       --storage-configuration '{
           "type":"S3_VECTORS",
           "s3VectorsConfiguration":{
               "indexArn":"{{index-arn}}"
           }
       }'
   ```

   Beachten Sie die `knowledgeBaseId` in der Antwort.

1. Erstellen Sie die Datenquelle. Übergeben Sie mithilfe des Formulars den Amazon S3 S3-Zugriffspunkt-Alias als Bucket-Namen in das `bucketArn` Feld`arn:aws:s3:::{{access-point-alias}}`.

   ```
   $ aws bedrock-agent create-data-source \
       --knowledge-base-id {{knowledge-base-id}} \
       --name fsxn-s3ap-source \
       --data-source-configuration '{
           "type":"S3",
           "s3Configuration":{"bucketArn":"arn:aws:s3:::{{access-point-alias}}"}
       }'
   ```

   Beachten Sie die `dataSourceId` in der Antwort.

## Schritt 5: Ingestieren Sie die Dokumente
<a name="tutorial-bedrock-kb-ingest"></a>

Führen Sie einen Ingestion-Job aus, um die Dokumente durch den Access Point zu crawlen, Einbettungen zu generieren und sie im Vector Store zu indizieren.

### Um die Aufnahme mit der Konsole auszuführen
<a name="tutorial-bedrock-kb-ingest-console"></a>

1. Öffnen Sie in der Amazon Bedrock-Konsole Ihre Wissensdatenbank.

1. Wählen Sie im Abschnitt **Datenquelle** Ihre Datenquelle aus und klicken Sie dann auf **Synchronisieren**.

1. Warten Sie, bis für **den Synchronisierungsstatus „****Bereit**“ angezeigt wird.

### Um die Aufnahme mit dem auszuführen AWS CLI
<a name="tutorial-bedrock-kb-ingest-cli"></a>

1. Starten Sie den Aufnahmejob.

   ```
   $ aws bedrock-agent start-ingestion-job \
       --knowledge-base-id {{knowledge-base-id}} \
       --data-source-id {{data-source-id}}
   ```

   Beachten Sie die `ingestionJobId` in der Antwort.

1. Rufen Sie den Job ab, bis er abgeschlossen ist.

   ```
   $ aws bedrock-agent get-ingestion-job \
       --knowledge-base-id {{knowledge-base-id}} \
       --data-source-id {{data-source-id}} \
       --ingestion-job-id {{ingestion-job-id}}
   ```

   Das `status` Feld wechselt von `IN_PROGRESS` zu`COMPLETE`. Das `statistics` Feld zeigt, wie viele Dokumente gescannt und indexiert wurden.

## Schritt 6: Fragen Sie die Wissensdatenbank ab
<a name="tutorial-bedrock-kb-query"></a>

Stellen Sie der Wissensdatenbank eine Frage, die auf den aufgenommenen Dokumenten basiert. Die Antwort enthält Zitate, die über den Alias des Amazon S3 S3-Zugriffspunkts auf die Quelldokumente verweisen.

### Um eine Abfrage über die Konsole durchzuführen
<a name="tutorial-bedrock-kb-query-console"></a>

1. Öffnen Sie in der Amazon Bedrock-Konsole Ihre Wissensdatenbank.

1. Wählen Sie **Wissensdatenbank testen** aus.

1. Wählen Sie unter **Antworten generieren** ein Modell zur Textgenerierung aus (z. B. **Nova Lite**).

1. Geben Sie eine Frage wie ein `What are the pillars of the AWS Well-Architected Framework?` und wählen Sie **Ausführen aus**. Die Antwort wird mit Quellenangaben angezeigt, die auf die Quelldokumente im Amazon S3 S3-Zugriffspunkt verweisen.

### Für die Abfrage verwenden Sie AWS CLI
<a name="tutorial-bedrock-kb-query-cli"></a>

Verwenden Sie den Befehl `retrieve-and-generate`. Ersetzen Sie die Platzhalter durch Ihre Werte. Das `modelArn` muss sich auf ein Inferenzprofil für ein Textgenerierungsmodell beziehen, auf das Sie Zugriff haben.

```
$ aws bedrock-agent-runtime retrieve-and-generate \
    --input '{"text":"What are the pillars of the AWS Well-Architected Framework?"}' \
    --retrieve-and-generate-configuration '{
        "type":"KNOWLEDGE_BASE",
        "knowledgeBaseConfiguration":{
            "knowledgeBaseId":"{{knowledge-base-id}}",
            "modelArn":"arn:aws:bedrock:{{region}}:{{account-id}}:inference-profile/us.amazon.nova-lite-v1:0"
        }
    }'
```

Die Antwort enthält die generierte Antwort in `output.text` und eine Liste von Zitaten im `citations` Array. Jedes Zitat enthält ein `s3Location.uri` Feld, das über den Alias des Zugriffspunkts auf das Quelldokument im Formular `s3://{{access-point-alias}}/{{file.pdf}}` verweist.

## Fehlerbehebung
<a name="tutorial-bedrock-kb-troubleshooting"></a>

Die Dateien mit den Berichten von Ingestion-Jobs wurden ignoriert  
Amazon Bedrock Knowledge Bases erzwingt eine maximale Dateigröße von 50 MB pro Dokument. Dateien, die größer als 50 MB sind, werden unter aufgeführt `failureReasons` und übersprungen. Teilen oder komprimieren Sie große Dokumente vor dem Hochladen.

`ValidationException`: Modell, das als Legacy gekennzeichnet ist  
Das von Ihnen angegebene Textgenerierungsmodell ist für Ihr Konto veraltet. Wählen Sie ein aktives Inferenzprofil, z. B. `us.amazon.nova-lite-v1:0` oder ein anderes derzeit unterstütztes Modell. Ausführen`aws bedrock list-inference-profiles`, um die verfügbaren Profile aufzulisten.

`AccessDeniedException`während der Einnahme  
Stellen Sie sicher, dass die Knowledge-Base-IAM-Rolle `s3:GetObject` und `s3:ListBucket` auf dem Access Point ARN (nicht auf dem zugrunde liegenden Volume) hat und dass der Access Point über einen Internetnetzwerk-Ursprung verfügt, sodass der Amazon Bedrock-Service ihn erreichen kann. Wenn Sie in Schritt 2 die OpenSearch Service Serverless-Alternative gewählt haben, stellen Sie außerdem sicher, dass die Datenzugriffsrichtlinie die Rolle als Prinzipal auflistet.

Der Aufnahmevorgang ist erfolgreich, aber Abfragen geben keine relevanten Passagen zurück  
Vergewissern Sie sich, dass der Vektorindex mit `dimension: 1024` (für Titan Text Embeddings v2) erstellt wurde und dass die Feldnamen in der Indexzuordnung mit den in der Wissensdatenbank konfigurierten Feldnamen übereinstimmen.

## Bereinigen
<a name="tutorial-bedrock-kb-clean-up"></a>

Um laufende Gebühren zu vermeiden, löschen Sie die Ressourcen, die Sie erstellt haben:
+ Amazon Bedrock Wissensdatenbank und Datenquelle
+ Amazon S3 S3-Vektorindex und Vektor-Bucket (oder OpenSearch Service Serverless Collection, wenn Sie die Alternative in Schritt 2 verwendet haben)
+ IAM-Rolle und Inline-Richtlinie
+ Auf den Access Point hochgeladene Objekte (falls sie nicht mehr benötigt werden)

```
$ aws bedrock-agent delete-data-source --knowledge-base-id {{knowledge-base-id}} --data-source-id {{data-source-id}}
aws bedrock-agent delete-knowledge-base --knowledge-base-id {{knowledge-base-id}}
aws s3vectors delete-index --vector-bucket-name fsxn-kb-vectors --index-name bedrock-kb-index
aws s3vectors delete-vector-bucket --vector-bucket-name fsxn-kb-vectors
aws iam delete-role-policy --role-name fsxn-kb-role --policy-name kb-access
aws iam delete-role --role-name fsxn-kb-role
```

### Alternative: Bereinigen Sie die serverlosen Ressourcen von OpenSearch Service
<a name="tutorial-bedrock-kb-clean-up-oss"></a>

Wenn Sie in Schritt 2 die OpenSearch Service Serverless-Alternative gewählt haben, ersetzen Sie die obigen `s3vectors` Befehle durch die folgenden. Bei OpenSearch Inanspruchnahme serverloser Dienste OCU-hour fallen Gebühren an. Löschen Sie sie daher umgehend, wenn Sie mit dem Tutorial fertig sind.

```
$ # Get the collection ID (required by delete-collection; the name is not accepted)
COLLECTION_ID=$(aws opensearchserverless batch-get-collection --names fsxn-kb \
    --query 'collectionDetails[0].id' --output text)

# Delete the collection, then the policies
aws opensearchserverless delete-collection --id "$COLLECTION_ID"
aws opensearchserverless delete-access-policy --name kb-data --type data
aws opensearchserverless delete-security-policy --name kb-net --type network
aws opensearchserverless delete-security-policy --name kb-enc --type encryption
```