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.
# Die Modelle Cohere Embed und Cohere Embed v4
Sie stellen mit [InvokeModel](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModel.html) Inferenzanforderungen an ein Embed-Modell. Sie benötigen die Modell-ID für das Modell, das Sie verwenden möchten. Informationen zum Abrufen der Modell-ID finden Sie unter [Unterstützte Basismodelle in Amazon Bedrock](models-supported.md).
**Anmerkung**
Amazon Bedrock unterstützt keine Streaming-Antworten von Cohere-Embed-Modellen.
**Topics**
+ [Cohere Embed v4](model-parameters-embed-v4.md)
+ [Cohere Embed v3](model-parameters-embed-v3.md)
# Cohere Embed v4
Cohere Embed v4 ist ein multimodales Einbettungsmodell, das sowohl Text- als auch Bildeingaben unterstützt. Es kann verschachtelte Text- und Bildinhalte verarbeiten und eignet sich daher ideal für Anwendungen zum Verstehen von Dokumenten, zur visuellen Suche und zum multimodalen Abrufen. Das Modell unterstützt verschiedene Einbettungstypen, darunter Float-, Int8-, Uint8-, Binär- und Ubinärformate, mit konfigurierbaren Ausgabedimensionen von 256 bis 1 536.
Die Modell-ID für Cohere Embed v4 lautet `cohere.embed-v4`.
**Zusätzliche Nutzungshinweise**
+ **Kontextlänge:** Bis zu \$1128 000 Token werden unterstützt. Bei RAG sind kleinere Blöcke häufig im Hinblick auf Abruf und Kosten vorteilhaft.
+ **Bildgröße:** bei Bildern > 2 458 624 Pixel erfolgt ein Downsampling; bei Bildern < 3 136 Pixel wird ein Upsampling vorgenommen.
+ **Interleaving-Eingaben:** Verwenden Sie am besten inputs.content[] für seitenähnlichen multimodalen Inhalt, sodass der Textkontext (z. B. Dateiname, Entitäten) zusammen mit dem Bild übertragen wird.
**Topics**
+ [Anforderung und Antwort](#model-parameters-embed-v4-request-response)
+ [Anforderung und Antwort für verschiedene input\$1types](#api-inference-examples-cohere-embed-v4)
+ [Codebeispiele](#code-examples-cohere-embed-v4)
## Anforderung und Antwort
------
#### [ Request ]
Inhaltstyp: application/json
```
{
"input_type": "search_document | search_query | classification | clustering",
"texts": ["..."], // optional; text-only
"images": ["data:;base64,..."], // optional; image-only
"inputs": [
{ "content": [
{ "type": "text", "text": "..." },
{ "type": "image_url", "image_url": {"url": "data:;base64,..."} }
]
}
], // optional; mixed (interleaved) text+image
"embedding_types": ["float" | "int8" | "uint8" | "binary" | "ubinary"],
"output_dimension": 256 | 512 | 1024 | 1536,
"max_tokens": 128000,
"truncate": "NONE | LEFT | RIGHT"
}
```
**Parameters**
+ **input\$1type** (erforderlich) – fügt spezielle Token hinzu, um Anwendungsfälle zu unterscheiden Zulässig: `search_document`, `search_query`, `classification`, `clustering`. Für search/RAG betten Sie Ihren Korpus mit `search_document` und Abfragen mit `search_query` ein.
+ **texts** (optional) – Array von Zeichenfolgen, die eingebettet werden sollen. Max. 96 pro Aufruf. Wenn Sie `texts` verwenden, senden Sie `images` nicht im selben Aufruf.
+ **images** (optional) – Array von einzubettenden base64-Bildern mit Daten-URI. Max. 96 pro Aufruf. Senden Sie `texts` und `images` nicht zusammen. (Verwenden Sie `inputs` für verschachtelt.)
+ **Eingaben** (optional; mixed/fused Modalität) — Eine Liste, in der jedes Element eine Inhaltsliste mit Teilen enthält. Jeder Teil ist `{ "type": "text", "text": ... }` oder `{ "type": "image_url", "image_url": {"url": "data:;base64,..."} }`. Senden Sie verschachtelte seitenähnliche Inhalte hier (z. B. PDF-Seitenbild \$1 Bildunterschrift/Metadaten). Max. 96 Elemente.
+ **embedding\$1types** (optional) – Ein oder mehrere der folgenden Typen: `float`, `int8`, `uint8`, `binary`, `ubinary`. Wenn nichts angegeben wurde, werden Float-Einbettungen zurückgegeben.
+ **output\$1dimension** (optional) – Wählen Sie die Vektorlänge aus. Zulässig: `256`, `512`, `1024`, `1536` (Standardwert `1536`, falls nicht angegeben).
+ **max\$1tokens** (optional) – Kürzungsbudget pro Eingabeobjekt. Das Modell unterstützt bis zu \$1128 000 Token; je nach Bedarf kleinere Blöcke für RAG.
+ **truncate** (optional) – So gehen Sie mit zu langen Eingaben um: `LEFT` löscht Token am Anfang; `RIGHT` entfernt sie am Ende; `NONE` gibt einen Fehler zurück, wenn die Eingabe das Limit überschreitet.
**Grenzwerte und Größenangaben**
+ Elemente pro Anforderung: bis zu 96 Bilder. Der ursprüngliche Bilddateityp muss im PNG-, JPEG-, WEBP- oder GIF-Format vorliegen und kann bis zu 5 MB umfassen sein.
+ Maximale Größe der Anforderung: \$120 MB Gesamtnutzdaten.
+ Maximale Eingabe-Token: max. 128 000 Token. Bilddateien werden in Token umgewandelt und die Gesamtzahl der Token sollte weniger als 128 KB betragen.
+ Bilder: maximal 2 458 624 Pixel vor dem Downsampling; bei Bildern, die kleiner als 3 136 Pixel sind, erfolgt ein Upsampling. Stellen Sie Bilder als `data:;base64,....` bereit.
+ Token-Abrechnung (pro `inputs`-Element): Token aus einer Bildeingabe ≈ (Bildpixel ÷ 784) x 4 Token aus einer verschachtelten Text- und Bildeingabe = (Bildpixel ÷ 784) x 4 \$1 (Text-Token)
**Tipp:** Konvertiere jede Seite in ein Bild und sende sie `inputs` zusammen mit Seitenmetadaten (z. B. Dateiname, Entitäten) in angrenzenden Textteilen. PDFs
------
#### [ Response ]
Inhaltstyp: application/json
Wenn Sie einen einzigen Einbettungstyp angefordert haben (z. B. nur `float`):
```
{
"id": "string",
"embeddings": [[ /* length = output_dimension */ ]],
"response_type": "embeddings_floats",
"texts": ["..."], // present if text was provided
"inputs": [ { "content": [ ... ] } ] // present if 'inputs' was used
}
```
Wenn Sie mehrere Einbettungstypen angefordert haben (z. B. `["float","int8"]`):
```
{
"id": "string",
"embeddings": {
"float": [[ ... ]],
"int8": [[ ... ]]
},
"response_type": "embeddings_by_type",
"texts": ["..."], // when text used
"inputs": [ { "content": [ ... ] } ] // when 'inputs' used
}
```
+ Die Anzahl der zurückgegebenen Vektoren entspricht der Länge Ihres `texts`-Arrays oder der Anzahl der `inputs`-Elemente.
+ Die Länge jedes Vektors ist gleich `output_dimension` (Standard `1536`).
------
## Anforderung und Antwort für verschiedene input\$1types
**A) Verschachtelte Seite (Bild \$1 Bildunterschrift) mit kompakten int8-Vektoren**
**Anforderung**
```
{
"input_type": "search_document",
"inputs": [
{
"content": [
{ "type": "text", "text": "Quarterly ARR growth chart; outlier in Q3." },
{ "type": "image_url", "image_url": {"url": "data:image/png;base64,{{BASE64_PAGE_IMG}}"} }
]
}
],
"embedding_types": ["int8"],
"output_dimension": 512,
"truncate": "RIGHT",
"max_tokens": 128000
}
```
**Antwort (gekürzt)**
```
{
"id": "836a33cc-61ec-4e65-afaf-c4628171a315",
"embeddings": { "int8": [[ 7, -3, ... ]] },
"response_type": "embeddings_by_type",
"inputs": [
{ "content": [
{ "type": "text", "text": "Quarterly ARR growth chart; outlier in Q3." },
{ "type": "image_url", "image_url": {"url": "data:image/png;base64,{{...}}"} }
] }
]
}
```
**B) Korpusindizierung nur aus Text (Standard: float, 1536-dim)**
**Anforderung**
```
{
"input_type": "search_document",
"texts": [
"RAG system design patterns for insurance claims",
"Actuarial loss triangles and reserving primer"
]
}
```
**Antwort (Beispiel)**
```
{
"response_type": "embeddings_floats",
"embeddings": [
[0.0135, -0.0272, ...], // length 1536
[0.0047, 0.0189, ...]
]
}
```
## Codebeispiele
------
#### [ Text input ]
```
# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
# SPDX-License-Identifier: Apache-2.0
"""
Shows how to generate embeddings using the Cohere Embed v4 model.
"""
import json
import logging
import boto3
from botocore.exceptions import ClientError
logger = logging.getLogger(__name__)
logging.basicConfig(level=logging.INFO)
def generate_text_embeddings(model_id, body, region_name):
"""
Generate text embedding by using the Cohere Embed model.
Args:
model_id (str): The model ID to use.
body (str) : The reqest body to use.
region_name (str): The AWS region to invoke the model on
Returns:
dict: The response from the model.
"""
logger.info("Generating text embeddings with the Cohere Embed model %s", model_id)
accept = '*/*'
content_type = 'application/json'
bedrock = boto3.client(service_name='bedrock-runtime', region_name=region_name)
response = bedrock.invoke_model(
body=body,
modelId=model_id,
accept=accept,
contentType=content_type
)
logger.info("Successfully generated embeddings with Cohere model %s", model_id)
return response
def main():
"""
Entrypoint for Cohere Embed example.
"""
logging.basicConfig(level=logging.INFO, format="%(levelname)s: %(message)s")
region_name = 'us-east-1'
model_id = 'cohere.embed-v4:0'
text1 = "hello world"
text2 = "this is a test"
input_type = "search_document"
embedding_types = ["float"]
try:
body = json.dumps({
"texts": [
text1,
text2],
"input_type": input_type,
"embedding_types": embedding_types
})
response = generate_text_embeddings(model_id=model_id, body=body, region_name=region_name)
response_body = json.loads(response.get('body').read())
print(f"ID: {response_body.get('id')}")
print(f"Response type: {response_body.get('response_type')}")
print("Embeddings")
embeddings = response_body.get('embeddings')
for i, embedding_type in enumerate(embeddings):
print(f"\t{embedding_type} Embeddings:")
print(f"\t{embeddings[embedding_type]}")
print("Texts")
for i, text in enumerate(response_body.get('texts')):
print(f"\tText {i}: {text}")
except ClientError as err:
message = err.response["Error"]["Message"]
logger.error("A client error occurred: %s", message)
print("A client error occured: " +
format(message))
else:
print(
f"Finished generating text embeddings with Cohere model {model_id}.")
if __name__ == "__main__":
main()
```
------
#### [ Mixed modalities ]
```
# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
# SPDX-License-Identifier: Apache-2.0
"""
Shows how to generate image embeddings using the Cohere Embed v4 model.
"""
import json
import logging
import boto3
import base64
from botocore.exceptions import ClientError
logger = logging.getLogger(__name__)
logging.basicConfig(level=logging.INFO)
def get_base64_image_uri(image_file_path: str, image_mime_type: str):
with open(image_file_path, "rb") as image_file:
image_bytes = image_file.read()
base64_image = base64.b64encode(image_bytes).decode("utf-8")
return f"data:{image_mime_type};base64,{base64_image}"
def generate_embeddings(model_id, body, region_name):
"""
Generate image embedding by using the Cohere Embed model.
Args:
model_id (str): The model ID to use.
body (str) : The reqest body to use.
region_name (str): The AWS region to invoke the model on
Returns:
dict: The response from the model.
"""
logger.info("Generating image embeddings with the Cohere Embed model %s", model_id)
accept = '*/*'
content_type = 'application/json'
bedrock = boto3.client(service_name='bedrock-runtime', region_name=region_name)
response = bedrock.invoke_model(
body=body,
modelId=model_id,
accept=accept,
contentType=content_type
)
logger.info("Successfully generated embeddings with Cohere model %s", model_id)
return response
def main():
"""
Entrypoint for Cohere Embed example.
"""
logging.basicConfig(level=logging.INFO, format="%(levelname)s: %(message)s")
region_name = 'us-east-1'
image_file_path = "image.jpg"
image_mime_type = "image/jpg"
text = "hello world"
model_id = 'cohere.embed-v4:0'
input_type = "search_document"
image_base64_uri = get_base64_image_uri(image_file_path, image_mime_type)
embedding_types = ["int8","float"]
try:
body = json.dumps({
"inputs": [
{
"content": [
{ "type": "text", "text": text },
{ "type": "image_url", "image_url": {"url": "data:image/png;base64,{{image_base64_uri}}"} }
]
}
],
"input_type": input_type,
"embedding_types": embedding_types
})
response = generate_embeddings(model_id=model_id, body=body, region_name=region_name)
response_body = json.loads(response.get('body').read())
print(f"ID: {response_body.get('id')}")
print(f"Response type: {response_body.get('response_type')}")
print("Embeddings")
embeddings = response_body.get('embeddings')
for i, embedding_type in enumerate(embeddings):
print(f"\t{embedding_type} Embeddings:")
print(f"\t{embeddings[embedding_type]}")
print("inputs")
for i, input in enumerate(response_body.get('inputs')):
print(f"\tinput {i}: {input}")
except ClientError as err:
message = err.response["Error"]["Message"]
logger.error("A client error occurred: %s", message)
print("A client error occured: " +
format(message))
else:
print(
f"Finished generating embeddings with Cohere model {model_id}.")
if __name__ == "__main__":
main()
```
------
# Cohere Embed v3
**Topics**
+ [Anforderung und Antwort](#model-parameters-embed-v3-request-response)
+ [Codebeispiel](#api-inference-examples-cohere-embed-v3)
## Anforderung und Antwort
------
#### [ Request ]
Die Cohere-Embed-Modelle haben die folgenden Inferenzparameter.
```
{
"input_type": "search_document|search_query|classification|clustering|image",
"texts":[string],
"images":[image_base64_image_uri]
"truncate": "NONE|START|END",
"embedding_types": embedding_types
}
```
Die folgenden Parameter sind erforderlich.
+ **texts** – Ein Array von Zeichenfolgen, die das Modell einbetten soll. Für eine optimale Leistung empfehlen wir, die Länge jedes Textes auf weniger als 512 Token zu reduzieren. Ein Token entspricht etwa 4 Zeichen.
Im Folgenden sind Text pro Aufruf und Zeichenbeschränkungen aufgeführt.
**Texte pro Aufruf**
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/bedrock/latest/userguide/model-parameters-embed-v3.html)
**Zeichen**
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/bedrock/latest/userguide/model-parameters-embed-v3.html)
+ **input\$1type** – Stellt spezielle Token voran, um die einzelnen Typen voneinander zu unterscheiden. Sie sollten verschiedene Typen nicht miteinander vermengen, außer wenn Sie Typen zum Suchen und Abrufen mischen. In diesem Fall betten Sie Ihren Korpus mit dem Typ `search_document` und eingebettete Abfragen mit dem Typ `search_query` ein.
+ `search_document` – Verwenden Sie `search_document` bei Suchen, wenn Sie Dokumente für Einbettungen kodieren, die Sie in einer Vektordatenbank speichern.
+ `search_query` – Verwenden Sie `search_query`, wenn Sie Ihre Vektordatenbank abfragen, um relevante Dokumente zu finden.
+ `classification` – Verwenden Sie `classification`, wenn Einbettungen als Eingabe für einen Textklassifizier verwendet werden.
+ `clustering` – Verwenden Sie `clustering`, um die Einbettungen in Cluster zu gruppieren.
+ `images` – Dies ist eine Reihe von Bildern.
+ Ein Array von Bilddaten-URIs, die das Modell einbetten soll. Die maximale Anzahl von Bildern pro Aufruf ist 1 (d. h., das Modell unterstützt nur eine Bildeingabe).
+ Das Bild muss eine gültige Daten-URI sein. Das Bild muss entweder im Bildformat JPEG oder PNG vorliegen und eine maximale Größe von 5 MB haben.
+ Es muss nur entweder „images“ oder „texts“ bereitgestellt werden.
Die folgenden Parameter sind optional:
+ **truncate** (kürzen) – Gibt an, wie die API Eingaben verarbeitet, die die maximale Token-Länge überschreiten. Nutzen Sie einen der Folgenden:
+ `NONE` – (Standard) gibt einen Fehler zurück, wenn die Eingabe die maximale Länge des Eingabe-Tokens überschreitet.
+ `START` – Verwirft den Anfang der Eingabe
+ `END` – Verwirft das Ende der Eingabe.
Wenn Sie `START` oder `END` angeben, verwirft das Modell die Eingabe, bis die verbleibende Eingabe genau der maximalen Länge des Eingabe-Tokens für das Modell entspricht.
+ **embedding\$1types** – Gibt die Arten von Einbettungen an, die zurückgegeben werden sollen. Dieser Parameter ist optional. Die Standardeinstellung ist `None`, was den Antworttyp `Embed Floats` zurückgibt. Beim Typ kann es sich um einen der folgenden Werte handeln:
+ `float` – Verwenden Sie diesen Wert, um die standardmäßigen Float-Einbettungen zurückzugeben.
+ `int8` – Verwenden Sie diesen Wert, um signierte int8-Einbettungen zurückzugeben.
+ `uint8` – Verwenden Sie diesen Wert, um unsignierte int8-Einbettungen zurückzugeben.
+ `binary` – Verwenden Sie diesen Wert, um signierte binäre Einbettungen zurückzugeben.
+ `ubinary` – Verwenden Sie diesen Wert, um unsignierte binäre Einbettungen zurückzugeben.
Weitere Informationen finden Sie unter [https://docs.cohere.com/reference/embed](https://docs.cohere.com/reference/embed) in der Cohere-Dokumentation.
------
#### [ Response ]
Die `body`-Antwort eines Aufrufs von `InvokeModel` lautet wie folgt:
```
{
"embeddings": [
[ array of 1024 floats. ]
],
"id": string,
"response_type" : "embeddings_floats,
"texts": [string],
"images": [image_description]
}
```
Die `body`-Antwort enthält folgende mögliche Felder:
+ **id** – Eine Kennung für die Antwort.
+ **response\$1type** – Der Antworttyp. Dieser Wert ist immer `embeddings_floats`.
+ **embeddings** – Ein Array von Einbettungen, wobei jede Einbettung ein Array von Gleitkommazahlen mit 1024 Elementen ist. Die Länge des `embeddings`-Arrays entspricht der Länge des ursprünglichen `texts`-Arrays.
+ **texts** – Ein Array, das die Texteinträge enthält, für die Einbettungen zurückgegeben wurden.
+ **images** – Ein Array mit einer Beschreibung für jede Bildeingabe.
Eine `image_description` hat folgende Form:
```
{
"width": long,
"height": long,
"format": string,
"bit_depth": long
}
```
Wenn ein Bild als Eingabe verwendet wurde, ist das `“texts”`-Antwortfeld ein leeres Array. Umgekehrt gilt dies nicht (d. h., wenn „texts“ verwendet wird, ist `“images”` nicht in der Antwort enthalten).
Weitere Informationen finden Sie unter [https://docs.cohere.com/reference/embed](https://docs.cohere.com/reference/embed).
------
## Codebeispiel
Dieses Beispiel zeigt, wie das Modell *Cohere Embed English* aufgerufen wird.
```
# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
# SPDX-License-Identifier: Apache-2.0
"""
Shows how to generate text embeddings using the Cohere Embed English model.
"""
import json
import logging
import boto3
from botocore.exceptions import ClientError
logger = logging.getLogger(__name__)
logging.basicConfig(level=logging.INFO)
def generate_text_embeddings(model_id, body, region_name):
"""
Generate text embedding by using the Cohere Embed model.
Args:
model_id (str): The model ID to use.
body (str) : The reqest body to use.
region_name (str): The AWS region to invoke the model on
Returns:
dict: The response from the model.
"""
logger.info("Generating text embeddings with the Cohere Embed model %s", model_id)
accept = '*/*'
content_type = 'application/json'
bedrock = boto3.client(service_name='bedrock-runtime', region_name=region_name)
response = bedrock.invoke_model(
body=body,
modelId=model_id,
accept=accept,
contentType=content_type
)
logger.info("Successfully generated embeddings with Cohere model %s", model_id)
return response
def main():
"""
Entrypoint for Cohere Embed example.
"""
logging.basicConfig(level=logging.INFO, format="%(levelname)s: %(message)s")
region_name = 'us-east-1'
model_id = 'cohere.embed-english-v3'
text1 = "hello world"
text2 = "this is a test"
input_type = "search_document"
embedding_types = ["int8", "float"]
try:
body = json.dumps({
"texts": [
text1,
text2],
"input_type": input_type,
"embedding_types": embedding_types
})
response = generate_text_embeddings(model_id=model_id, body=body, region_name=region_name)
response_body = json.loads(response.get('body').read())
print(f"ID: {response_body.get('id')}")
print(f"Response type: {response_body.get('response_type')}")
print("Embeddings")
embeddings = response_body.get('embeddings')
for i, embedding_type in enumerate(embeddings):
print(f"\t{embedding_type} Embeddings:")
print(f"\t{embeddings[embedding_type]}")
print("Texts")
for i, text in enumerate(response_body.get('texts')):
print(f"\tText {i}: {text}")
except ClientError as err:
message = err.response["Error"]["Message"]
logger.error("A client error occurred: %s", message)
print("A client error occured: " +
format(message))
else:
print(
f"Finished generating text embeddings with Cohere model {model_id}.")
if __name__ == "__main__":
main()
```
**Bildeingabe**
```
# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
# SPDX-License-Identifier: Apache-2.0
"""
Shows how to generate image embeddings using the Cohere Embed English model.
"""
import json
import logging
import boto3
import base64
from botocore.exceptions import ClientError
logger = logging.getLogger(__name__)
logging.basicConfig(level=logging.INFO)
def get_base64_image_uri(image_file_path: str, image_mime_type: str):
with open(image_file_path, "rb") as image_file:
image_bytes = image_file.read()
base64_image = base64.b64encode(image_bytes).decode("utf-8")
return f"data:{image_mime_type};base64,{base64_image}"
def generate_image_embeddings(model_id, body, region_name):
"""
Generate image embedding by using the Cohere Embed model.
Args:
model_id (str): The model ID to use.
body (str) : The reqest body to use.
region_name (str): The AWS region to invoke the model on
Returns:
dict: The response from the model.
"""
logger.info("Generating image embeddings with the Cohere Embed model %s", model_id)
accept = '*/*'
content_type = 'application/json'
bedrock = boto3.client(service_name='bedrock-runtime', region_name=region_name)
response = bedrock.invoke_model(
body=body,
modelId=model_id,
accept=accept,
contentType=content_type
)
logger.info("Successfully generated embeddings with Cohere model %s", model_id)
return response
def main():
"""
Entrypoint for Cohere Embed example.
"""
logging.basicConfig(level=logging.INFO, format="%(levelname)s: %(message)s")
region_name = 'us-east-1'
image_file_path = "image.jpg"
image_mime_type = "image/jpg"
model_id = 'cohere.embed-english-v3'
input_type = "image"
images = [get_base64_image_uri(image_file_path, image_mime_type)]
embedding_types = ["int8", "float"]
try:
body = json.dumps({
"images": images,
"input_type": input_type,
"embedding_types": embedding_types
})
response = generate_image_embeddings(model_id=model_id, body=body, region_name=region_name)
response_body = json.loads(response.get('body').read())
print(f"ID: {response_body.get('id')}")
print(f"Response type: {response_body.get('response_type')}")
print("Embeddings")
embeddings = response_body.get('embeddings')
for i, embedding_type in enumerate(embeddings):
print(f"\t{embedding_type} Embeddings:")
print(f"\t{embeddings[embedding_type]}")
print("Texts")
for i, text in enumerate(response_body.get('texts')):
print(f"\tText {i}: {text}")
except ClientError as err:
message = err.response["Error"]["Message"]
logger.error("A client error occurred: %s", message)
print("A client error occured: " +
format(message))
else:
print(
f"Finished generating text embeddings with Cohere model {model_id}.")
if __name__ == "__main__":
main()
```