

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.

# Arbeiten mit Vektorsuchsammlungen
<a name="serverless-vector-search"></a>

Mit dem Sammlungstyp *Vektorsuche* in OpenSearch Serverless können Sie skalierbare, leistungsstarke Ähnlichkeitssuchen durchführen. Sie können moderne, erweiterte Sucherlebnisse mit maschinellem Lernen (ML) und Anwendungen für generative künstliche Intelligenz (KI) entwickeln, ohne die zugrunde liegende Vektordatenbankinfrastruktur verwalten zu müssen. 

Zu den Anwendungsfällen für Vektorsuchsammlungen gehören Bildersuchen, Dokumentensuchen, Musikabruf, Produktempfehlungen, Videosuchen, standortbezogene Suchen, Betrugserkennung und Anomalieerkennung. 

Die Vektor-Engine für OpenSearch Serverless verwendet die Suchfunktion k-Nearest [Neighbor (k-NN](https://opensearch.org/docs/latest/search-plugins/knn/index/)) in. OpenSearch Sie erhalten dieselbe Funktionalität mit der Einfachheit einer serverlosen Umgebung. Die Engine unterstützt die [k-NN-Plugin-API](https://opensearch.org/docs/latest/search-plugins/knn/api/). Mit diesen Vorgängen können Sie Volltextsuche, erweiterte Filterung, Aggregationen, Geodatenabfragen und verschachtelte Abfragen verwenden, um Daten schneller abzurufen und bessere Suchergebnisse zu erzielen.

Die Vektor-Engine bietet Entfernungsmetriken wie euklidische Entfernung, Kosinusähnlichkeit und Punktproduktähnlichkeit und kann 16.000 Dimensionen aufnehmen. Sie können Felder mit verschiedenen Datentypen für Metadaten wie Zahlen, Boolesche Werte, Datumsangaben, Stichwörter und Geopunkte speichern. Sie können auch Felder mit Text für beschreibende Informationen speichern, um gespeicherten Vektoren mehr Kontext zu verleihen. Durch die gemeinsame Zuordnung der Datentypen wird die Komplexität reduziert, die Wartbarkeit erhöht und Datenduplizierungen, Probleme mit der Versionskompatibilität und Lizenzprobleme vermieden. 

## NextGen Sammlungen für die Vektorsuche
<a name="serverless-vector-nextgen-features"></a>

NextGen Die Vektorsuche wird je nach Arbeitslast je nach Bedarf skaliert, um das Gleichgewicht zwischen Kosten und Leistung zu optimieren. Nur die Datenblöcke, die für die Bearbeitung aktiver Suchanfragen erforderlich sind, werden in den Arbeitsspeicher geladen, und Worker skalieren dynamisch auf der Grundlage der benötigten Speicher- und CPU-Ressourcen. Wenn die Sammlung inaktiv ist und keine laufenden Anfragen vorliegen, werden sowohl Indexierung als auch Suche auf Null skaliert, was zusätzliche Kosteneinsparungen ermöglicht. NextGenEnthält standardmäßig integrierte Optimierungen, die den Abruf verbessern und gleichzeitig die Kosten und die Latenz reduzieren.
+ **Benutzerdefinierte Dokument-ID** — Benutzerdefinierte Dokument-IDs werden in NextGen Sammlungen unterstützt, sodass es für Kunden einfacher ist, Aktualisierungen vorzunehmen oder Dokumente mit vom Benutzer bereitgestellten IDs zu indexieren.
+ Indizes mit **32-facher Komprimierung — Alle Indizes** werden standardmäßig mit einer fortschrittlichen 32-fachen Komprimierungstechnik erstellt. Sie können die Standardkomprimierungsstufe überschreiben und eine beliebige unterstützte Komprimierungsstufe auswählen: 1x, 2x, 8x, 16x oder 32x (Standard).
+ **Beschleunigung der Indexerstellung** — Die GPU-Beschleunigung ist standardmäßig aktiviert, damit große Vektorindizes schneller und effizienter erstellt werden können. Sie reduziert den Zeitaufwand für die Indexierung von Daten in Vektorindizes und sorgt so für einen hohen Durchsatz bei der Indexierung und Kosteneinsparungen. GPU-Ressourcen werden nur bereitgestellt, wenn sie während der Indexerstellung benötigt werden. Mit der Einstellung `index.knn.remote_index_build.enabled` können Sie die GPU-Nutzung pro Index steuern. Weitere Informationen finden Sie unter [GPU-Beschleunigung für die Vektorindizierung](gpu-acceleration-vector-index.md).
+ **Vereinfachte API** — NextGen Vektorsuchsammlungen benötigen die `mode` Parameter `engine` und in Indexzuordnungen nicht. Das System bestimmt automatisch intern die optimale Konfiguration, wodurch die Komplexität der Indexerstellung reduziert wird.
+ **Optimierte Suchantwort** — Standardmäßig schließen Suchantworten in NextGen Vektorsammlungen den ursprünglichen Vektor aus den Ergebnissen aus. Dies reduziert die Latenz bei der Suche von Anfang bis Ende und die Größe der Antwort-Payload. Informationen zum Einbeziehen von Vektoren in die Suchantwort finden Sie unter[Ruft das vollständige Dokument mit Vektoren ab](#serverless-vector-index-full-source).
+ NextGen Vektorsammlungen haben eine Latenz von 10 Sekunden beim Lesen nach dem Schreiben (`refresh_interval`).

## Erste Schritte mit Vektor-Suchsammlungen
<a name="serverless-vector-tutorial"></a>

In diesem Tutorial führen Sie die folgenden Schritte aus, um Vektoreinbettungen in Echtzeit zu speichern, zu suchen und abzurufen:

1. [Konfigurieren von Berechtigungen](#serverless-vector-permissions)

1. [Erstellen einer Sammlung](#serverless-vector-create)

1. [Hochladen und Suchen von Daten](#serverless-vector-index)

1. [Löschen der Sammlung](#serverless-vector-delete)

### Schritt 1: Konfigurieren von Berechtigungen
<a name="serverless-vector-permissions"></a>

Um dieses Tutorial abzuschließen (und OpenSearch Serverless im Allgemeinen zu verwenden), benötigen Sie die richtigen AWS Identity and Access Management (IAM-) Berechtigungen. In diesem Tutorial erstellen Sie eine Sammlung, laden Daten hoch, suchen nach Daten und löschen dann die Sammlung.

Ihr Benutzer oder Ihre Rolle muss über eine angefügte [identitätsbasierte Richtlinie](security-iam-serverless.md#security-iam-serverless-id-based-policies) mit den folgenden Mindestberechtigungen verfügen:

------
#### [ JSON ]

****  

```
{
  "Version":"2012-10-17",		 	 	 
  "Statement": [
    {
      "Action": [
        "aoss:CreateCollection",
        "aoss:ListCollections",
        "aoss:BatchGetCollection",
        "aoss:DeleteCollection",
        "aoss:CreateAccessPolicy",
        "aoss:ListAccessPolicies",
        "aoss:UpdateAccessPolicy",
        "aoss:CreateSecurityPolicy",
        "iam:ListUsers",
        "iam:ListRoles"
      ],
      "Effect": "Allow",
      "Resource": "*"
    }
  ]
}
```

------

Weitere Informationen zu OpenSearch serverlosen IAM-Berechtigungen finden Sie unter. [Identity and Access Management für Amazon OpenSearch Serverless](security-iam-serverless.md)

### Schritt 2: Erstellen einer Sammlung
<a name="serverless-vector-create"></a>

Um eine neue Sammlung zu erstellen, folgen Sie dem einheitlichen Ablauf zur Erstellung von Sammlungen (NextGen Express Create), der automatisch Verschlüsselungs-, Netzwerk- und Datenzugriffsrichtlinien konfiguriert. Detaillierte Anweisungen finden Sie unter [Erstellen Sie eine NextGen Sammlung (Express Create)](serverless-create.md#serverless-create-nextgen-easy).

Für den Rest dieses Tutorials hat die Beispielsammlung einen Namen `housing` und es handelt sich um eine NextGen Vektorsuchsammlung.

**Anmerkung**  
Wenn Sie stattdessen eine klassische Vektorsammlung erstellen möchten, finden Sie [Arbeiten mit klassischen Vektorsammlungen](#serverless-vector-classic) die spezifischen Verfahren für klassische Sammlungen unter.

### Schritt 3: Daten hochladen und suchen
<a name="serverless-vector-index"></a>

Ein *Index* ist eine Sammlung von Dokumenten mit einem gemeinsamen Datenschema, mit dem Sie Ihre Vektoreinbettungen und andere Felder speichern, durchsuchen und abrufen können. [https://www.postman.com/downloads/](https://www.postman.com/downloads/) In diesem Tutorial werden Dev Tools verwendet. Informationen zum programmatischen Zugriff mit dem Python-SDK finden Sie unter[Daten in Amazon OpenSearch Serverless-Sammlungen aufnehmen](serverless-clients.md).

**So indexieren und suchen Sie nach Daten in der Wohnungssammlung**

1. Um einen Index für Ihre neue Sammlung zu erstellen, senden Sie die folgende Anfrage an die [Dev Tools-Konsole](https://opensearch.org/docs/latest/dashboards/dev-tools/index-dev/). Standardmäßig wird dadurch ein Index mit euklidischem Abstand und 32-facher Komprimierung erstellt.

   ```
   PUT housing-index
   {
     "settings": {
       "index.knn": true
     },
     "mappings": {
       "properties": {
         "housing-vector": {
           "type": "knn_vector",
           "dimension": 3,
           "space_type": "l2"
         },
         "title": {
           "type": "text"
         },
         "price": {
           "type": "long"
         },
         "location": {
           "type": "geo_point"
         }
       }
     }
   }
   ```

1. Um eine andere Komprimierungsstufe zu verwenden, legen Sie diese `compression_level` in der Feldzuordnung fest. Im folgenden Beispiel wird ein Index erstellt, der auf 1x `compression_level` gesetzt ist.

   ```
   PUT housing-index-1x
   {
     "settings": {
       "index.knn": true
     },
     "mappings": {
       "properties": {
         "housing-vector": {
           "type": "knn_vector",
           "dimension": 3,
           "compression_level": "1x",
           "space_type": "l2"
         },
         "title": {
           "type": "text"
         },
         "price": {
           "type": "long"
         },
         "location": {
           "type": "geo_point"
         }
       }
     }
   }
   ```

   Die unterstützten Komprimierungsstufen sind 1x, 2x, 8x, 16x und 32x.

1. Um Dokumente zu indizieren`housing-index`, können Sie eine vom System generierte ID (POST) oder eine vom Benutzer bereitgestellte ID (PUT) verwenden.

   ```
   # System-generated document ID
   POST housing-index/_doc
   {
     "housing-vector": [10, 20, 30],
     "title": "2 bedroom in downtown Seattle",
     "price": "2800",
     "location": "47.71, 122.00"
   }
   
   # User-provided document ID
   PUT housing-index/_doc/100
   {
     "housing-vector": [10, 20, 30],
     "title": "2 bedroom in downtown Seattle",
     "price": "2800",
     "location": "47.71, 122.00"
   }
   ```

1. Um nach Eigenschaften zu suchen, die denen in Ihrem Index ähneln, senden Sie die folgende Abfrage. Standardmäßig schließt die Suchantwort den ursprünglichen Vektor aus, `_source` um die Latenz und die Größe der Nutzlast zu reduzieren.

   ```
   GET housing-index/_search
   {
     "size": 5,
     "query": {
       "knn": {
         "housing-vector": {
           "vector": [10, 20, 30],
           "k": 2
         }
       }
     }
   }
   ```

   Die Antwort schließt das Feld aus: `housing-vector` `_source`

   ```
   {
     "took": 10,
     "timed_out": false,
     "_shards": {
       "total": 0,
       "successful": 0,
       "skipped": 0,
       "failed": 0
     },
     "hits": {
       "total": {
         "value": 1,
         "relation": "eq"
       },
       "max_score": 1,
       "hits": [
         {
           "_index": "housing-index",
           "_id": "100",
           "_score": 1,
           "_source": {
             "price": "2800",
             "location": "47.71, 122.00",
             "title": "2 bedroom in downtown Seattle"
           }
         }
       ]
     }
   }
   ```

#### Ruft das vollständige Dokument mit Vektoren ab
<a name="serverless-vector-index-full-source"></a>

Um das Standardverhalten zu überschreiben, legen Sie `_source` `true` in der Suchanfrage den Wert auf fest. Sie können auch die `excludes` Optionen`includes`/von verwenden`_source`, um bestimmte Felder abzurufen.

```
GET housing-index/_search
{
  "size": 5,
  "_source": true,
  "query": {
    "knn": {
      "housing-vector": {
        "vector": [10, 20, 30],
        "k": 2
      }
    }
  }
}
```

Die Antwort enthält jetzt das `housing-vector` Feld in`_source`:

```
{
  "took": 10,
  "timed_out": false,
  "_shards": {
    "total": 0,
    "successful": 0,
    "skipped": 0,
    "failed": 0
  },
  "hits": {
    "total": {
      "value": 1,
      "relation": "eq"
    },
    "max_score": 1,
    "hits": [
      {
        "_index": "housing-index",
        "_id": "100",
        "_score": 1,
        "_source": {
          "housing-vector": [10, 20, 30],
          "price": "2800",
          "location": "47.71, 122.00",
          "title": "2 bedroom in downtown Seattle"
        }
      }
    ]
  }
}
```

### Schritt 4: Sammlung löschen
<a name="serverless-vector-delete"></a>

Da die *Wohnungssammlung* zu Testzwecken dient, löschen Sie sie, wenn Sie mit dem Experimentieren fertig sind.

**Um eine OpenSearch serverlose Sammlung zu löschen**

1. Öffnen Sie die Amazon OpenSearch Service-Konsole.

1. Wählen Sie im linken Navigationsbereich **Sammlungen** und dann die **Wohnungssammlung** aus.

1. Wählen Sie **Löschen** und bestätigen Sie den Löschvorgang.

## Gefilterte Suche
<a name="serverless-vector-filter"></a>

Sie können Filter verwenden, um Ihre semantischen Suchergebnisse zu verfeinern. Um einen Index zu erstellen und eine gefilterte Suche in Ihren Dokumenten durchzuführen, ersetzen [Sie die folgenden Anweisungen anstelle von Daten hochladen und suchen](#serverless-vector-index) aus dem vorherigen Tutorial. Die anderen Schritte bleiben gleich. Weitere Informationen zu Filtern finden Sie unter [k-NN-Suche mit Filtern](https://opensearch.org/docs/latest/search-plugins/knn/filter-search-knn/).

**Um Daten in der Wohnsammlung zu indizieren und zu durchsuchen**

1. Um einen einzigen Index für Ihre Sammlung zu erstellen, senden Sie die folgende Anfrage an die [Dev Tools-Konsole](https://opensearch.org/docs/latest/dashboards/dev-tools/index-dev/):

   ```
   PUT housing-index-filtered
   {
     "settings": {
       "index.knn": true
     },
     "mappings": {
       "properties": {
         "housing-vector": {
           "type": "knn_vector",
           "dimension": 3,
           "space_type": "l2",
           "method": {
             "name": "hnsw"
           }
         },
         "title": {
           "type": "text"
         },
         "price": {
           "type": "long"
         },
         "location": {
           "type": "geo_point"
         }
       }
     }
   }
   ```

1. Senden Sie die folgende Anfrage, um ein einzelnes Dokument in *housing-index-filtered* zu indizieren:

   ```
   POST housing-index-filtered/_doc
   {
     "housing-vector": [
       10,
       20,
       30
     ],
     "title": "2 bedroom in downtown Seattle",
     "price": "2800",
     "location": "47.71, 122.00"
   }
   ```

1. Um nach Ihren Daten nach einer Wohnung in Seattle zu einem bestimmten Preis und in einer bestimmten Entfernung von einem geografischen Punkt zu suchen, senden Sie die folgende Anfrage:

   ```
   GET housing-index-filtered/_search
   {
     "size": 5,
     "query": {
       "knn": {
         "housing-vector": {
           "vector": [
             0.1,
             0.2,
             0.3
           ],
           "k": 5,
           "filter": {
             "bool": {
               "must": [
                 {
                   "query_string": {
                     "query": "Find me 2 bedroom apartment in Seattle under $3000 ",
                     "fields": [
                       "title"
                     ]
                   }
                 },
                 {
                   "range": {
                     "price": {
                       "lte": 3000
                     }
                   }
                 },
                 {
                   "geo_distance": {
                     "distance": "100miles",
                     "location": {
                       "lat": 48,
                       "lon": 121
                     }
                   }
                 }
               ]
             }
           }
         }
       }
     }
   }
   ```

## Einschränkungen
<a name="serverless-vector-limitations"></a>
+ Die radiale Suche wird bei NextGen Vektorindizes, die 32-fache Komprimierung verwenden, nicht unterstützt.

## Arbeiten mit klassischen Vektorsammlungen
<a name="serverless-vector-classic"></a>

Klassische Vektorsammlungen sind die ursprüngliche Generation der OpenSearch serverlosen Vektorsuche. Verwenden Sie die Verfahren in diesem Abschnitt, wenn Sie bereits über eine klassische Vektorsammlung verfügen. Für neue Sammlungen empfehlen wir NextGen — siehe [Erstellen von Sammlungen](serverless-create.md) So erstellen Sie eine NextGen Vektorsammlung.

**Anmerkung**  
Amazon OpenSearch Serverless Classic-Sammlungen unterstützen die skalare 16-Bit-Quantisierung von Faiss, die Konvertierungen zwischen 32-Bit-Floating- und 16-Bit-Vektoren durchführt. [Weitere Informationen finden Sie unter Skalarquantisierung mit 16 Bit von Faiss.](https://opensearch.org/docs/latest/search-plugins/knn/knn-vector-quantization/#faiss-16-bit-scalar-quantization) Sie können auch binäre Vektoren verwenden, um die Speicherkosten zu senken. Weitere Informationen finden Sie unter [Binäre Vektoren](https://opensearch.org/docs/latest/field-types/supported-field-types/knn-vector#binary-vectors).
Amazon OpenSearch Serverless Classic-Sammlungen unterstützen die festplattenbasierte Vektorsuche, wodurch die Betriebskosten für Vektor-Workloads in Umgebungen mit wenig Arbeitsspeicher erheblich gesenkt werden. [Weitere Informationen finden Sie unter Vektorsuche. Disk-based ](https://docs.opensearch.org/2.19/vector-search/optimizing-storage/disk-based-vector-search/)

### Daten hochladen und suchen (Classic)
<a name="serverless-vector-classic-index"></a>

Die folgenden Beispiele beziehen sich auf klassische Vektorsammlungen, die standardmäßig die `nmslib` Engine verwenden und den Originalvektor in den Suchantworten einbeziehen.

**Um Daten in einer Classic-Wohnungssammlung zu indizieren und zu durchsuchen**

1. Um einen Index für Ihre Classic-Sammlung zu erstellen, senden Sie die folgende Anfrage in der [Dev Tools-Konsole](https://opensearch.org/docs/latest/dashboards/dev-tools/index-dev/). Standardmäßig wird dadurch ein Index mit der `nmslib` Engine und der euklidischen Entfernung erstellt.

   ```
   PUT housing-index
   {
      "settings": {
         "index.knn": true
      },
      "mappings": {
         "properties": {
            "housing-vector": {
               "type": "knn_vector",
               "dimension": 3
            },
            "title": {
               "type": "text"
            },
            "price": {
               "type": "long"
            },
            "location": {
               "type": "geo_point"
            }
         }
      }
   }
   ```

1. Um ein einzelnes Dokument in den *Housing-Index* zu indexieren, senden Sie die folgende Anfrage:

   ```
   POST housing-index/_doc
   {
     "housing-vector": [
       10,
       20,
       30
     ],
     "title": "2 bedroom in downtown Seattle",
     "price": "2800",
     "location": "47.71, 122.00"
   }
   ```

1. Um nach Immobilien zu suchen, die denen in Ihrem Index ähneln, senden Sie die folgende Abfrage:

   ```
   GET housing-index/_search
   {
       "size": 5,
       "query": {
           "knn": {
               "housing-vector": {
                   "vector": [
                       10,
                       20,
                       30
                   ],
                   "k": 5
               }
           }
       }
   }
   ```

### Gefilterte Suche (klassisch)
<a name="serverless-vector-classic-filter"></a>

Verwenden Sie die folgenden Beispiele, um einen Index zu erstellen und eine gefilterte Suche durchzuführen. Weitere Informationen zu Filtern finden Sie unter [k-NN-Suche mit Filtern](https://opensearch.org/docs/latest/search-plugins/knn/filter-search-knn/).

**Um eine Classic-Wohnsammlung zu indizieren und eine gefilterte Suche durchzuführen**

1. Um einen einzigen Index für Ihre Sammlung zu erstellen, senden Sie die folgende Anfrage an die [Dev Tools-Konsole](https://opensearch.org/docs/latest/dashboards/dev-tools/index-dev/):

   ```
   PUT housing-index-filtered
   {
     "settings": {
       "index.knn": true
     },
     "mappings": {
       "properties": {
         "housing-vector": {
           "type": "knn_vector",
           "dimension": 3,
           "method": {
             "engine": "faiss",
             "name": "hnsw"
           }
         },
         "title": {
           "type": "text"
         },
         "price": {
           "type": "long"
         },
         "location": {
           "type": "geo_point"
         }
       }
     }
   }
   ```

1. Senden Sie die folgende Anfrage, um ein einzelnes Dokument in *housing-index-filtered* zu indizieren:

   ```
   POST housing-index-filtered/_doc
   {
     "housing-vector": [
       10,
       20,
       30
     ],
     "title": "2 bedroom in downtown Seattle",
     "price": "2800",
     "location": "47.71, 122.00"
   }
   ```

1. Um nach Ihren Daten nach einer Wohnung in Seattle zu einem bestimmten Preis und in einer bestimmten Entfernung von einem geografischen Punkt zu suchen, senden Sie die folgende Anfrage:

   ```
   GET housing-index-filtered/_search
   {
     "size": 5,
     "query": {
       "knn": {
         "housing-vector": {
           "vector": [
             0.1,
             0.2,
             0.3
           ],
           "k": 5,
           "filter": {
             "bool": {
               "must": [
                 {
                   "query_string": {
                     "query": "Find me 2 bedroom apartment in Seattle under $3000 ",
                     "fields": [
                       "title"
                     ]
                   }
                 },
                 {
                   "range": {
                     "price": {
                       "lte": 3000
                     }
                   }
                 },
                 {
                   "geo_distance": {
                     "distance": "100miles",
                     "location": {
                       "lat": 48,
                       "lon": 121
                     }
                   }
                 }
               ]
             }
           }
         }
       }
     }
   }
   ```

### Einschränkungen (klassisch)
<a name="serverless-vector-classic-limitations"></a>

Klassische Vektorsammlungen haben die folgenden Einschränkungen:
+ Vektor-Suchsammlungen unterstützen die Apache Lucene ANN-Engine nicht.
+ Sammlungen für die Vektorsuche unterstützen nur den HNSW-Algorithmus mit Faiss. Sie unterstützen weder IVF noch IVFQ.
+ Die Sammlungen der Vektorsuche unterstützen die API-Operationen „Aufwärmen“, „Statistiken“ und „Modelltraining“ nicht.
+ Sammlungen für die Vektorsuche unterstützen keine Inline- oder gespeicherten Skripts.
+ Informationen zur Indexanzahl sind in den Sammlungen AWS-Managementkonsole für die Vektorsuche nicht verfügbar. 
+ Das Aktualisierungsintervall für Indizes für Vektorsuchsammlungen beträgt 60 Sekunden.

### Billion-scale Arbeitslasten
<a name="serverless-vector-billion"></a>

Klassische Vektorsuchsammlungen unterstützen Workloads mit Milliarden von Vektoren. Sie müssen zu Skalierungszwecken keine Neuindizierung durchführen, da Auto Scaling dies für Sie erledigt. Wenn Sie über Millionen von Vektoren (oder mehr) mit einer hohen Anzahl von Dimensionen verfügen und mehr als 200 OCUs benötigen, wenden Sie sich an den [AWS Support](https://aws.amazon.com/premiumsupport/), um die maximale Anzahl an OpenSearch Recheneinheiten (OCU) für Ihr Konto zu erhöhen. 

## Nächste Schritte
<a name="serverless-vector-next"></a>

Da Sie nun wissen, wie Sie eine Vektorsuchsammlung erstellen und Daten indexieren, können Sie die folgenden Übungen ausprobieren:
+ Verwenden Sie den OpenSearch Python-Client, um mit Vektorsuchsammlungen zu arbeiten. Sehen Sie sich dieses Tutorial unter an [GitHub](https://github.com/opensearch-project/opensearch-py/blob/main/guides/plugins/knn.md). 
+ Verwenden Sie den OpenSearch Java-Client, um mit Vektorsuchsammlungen zu arbeiten. Sehen Sie sich dieses Tutorial unter an [GitHub](https://github.com/opensearch-project/opensearch-java/blob/main/guides/plugins/knn.md). 
+ Für LangChain die Verwendung OpenSearch als Vektorspeicher eingerichtet. LangChain ist ein Open-Source-Framework für die Entwicklung von Anwendungen, die auf Sprachmodellen basieren. Weitere Informationen finden Sie in der [LangChain -Dokumentation](https://python.langchain.com/docs/integrations/vectorstores/opensearch).