Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.

# CohereEmbeddan Cohere Embed v4 model
<a name="model-parameters-embed"></a>

Anda membuat permintaan inferensi ke Embed model dengan [InvokeModel](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModel.html)Anda memerlukan ID model untuk model yang ingin Anda gunakan. Untuk mendapatkan ID model, lihat[Model pondasi yang didukung di Amazon Bedrock](models-supported.md). 

**catatan**  
Amazon Bedrock tidak mendukung respons streaming dari Cohere Embed model.

**Topics**
+ [Cohere Sematkan v4](model-parameters-embed-v4.md)
+ [Cohere Sematkan v3](model-parameters-embed-v3.md)

# Cohere Sematkan v4
<a name="model-parameters-embed-v4"></a>

Cohere Embed v4adalah model penyematan multimodal yang mendukung input teks dan gambar. Ini dapat memproses teks dan konten gambar yang disisipkan, membuatnya ideal untuk pemahaman dokumen, pencarian visual, dan aplikasi pengambilan multimodal. Model ini mendukung berbagai jenis embedding termasuk format float, int8, uint8, biner, dan ubinary, dengan dimensi output yang dapat dikonfigurasi dari 256 hingga 1536.

ID model untuk Cohere Embed v4 adalah`cohere.embed-v4`.

**Catatan penggunaan tambahan**  

+ **Panjang konteks:** Hingga \$1 128k token didukung; untuk RAG, potongan yang lebih kecil sering meningkatkan pengambilan dan biaya.
+ **Ukuran gambar:** Gambar > 2.458.624 piksel diturunkan sampelnya ke ukuran itu; gambar <3.136 piksel di-upsample.
+ **Input interleaved:** Lebih suka inputs.content [] untuk konten multimodal seperti halaman sehingga konteks teks (misalnya, nama file, entitas) berjalan dengan gambar.

**Topics**
+ [Permintaan dan Tanggapan](#model-parameters-embed-v4-request-response)
+ [Permintaan dan tanggapan untuk input\$1types yang berbeda](#api-inference-examples-cohere-embed-v4)
+ [Contoh Kode](#code-examples-cohere-embed-v4)

## Permintaan dan Tanggapan
<a name="model-parameters-embed-v4-request-response"></a>

------
#### [ Request ]

Jenis konten: aplikasi/json

```
{
  "input_type": "search_document | search_query | classification | clustering",
  "texts": ["..."],                      // optional; text-only
  "images": ["data:<mime>;base64,..."],  // optional; image-only
  "inputs": [
    { "content": [
        { "type": "text",      "text": "..." },
        { "type": "image_url", "image_url": {"url": "data:<mime>;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"
}
```

**Parameter**  

+ **input\$1type** (wajib) - Menambahkan token khusus untuk membedakan kasus penggunaan. Diizinkan:`search_document`,`search_query`,`classification`,`clustering`. Untuk pencarian/RAG, sematkan korpus Anda dengan dan kueri dengan. `search_document` `search_query`
+ **teks** (opsional) - Array string untuk disematkan. Maks 96 per panggilan. Jika Anda menggunakan`texts`, jangan mengirim `images` panggilan yang sama.
+ **gambar** (opsional) - Array data-uri gambar base64 untuk menanamkan. Maks 96 per panggilan. Jangan mengirim `texts` dan `images` bersama-sama. (Gunakan `inputs` untuk disisipkan.)
+ **input** (opsional; mixed/fused modalitas) - Daftar di mana setiap item memiliki daftar konten bagian. Setiap bagian adalah `{ "type": "text", "text": ... }` atau`{ "type": "image_url", "image_url": {"url": "data:<mime>;base64,..."} }`. Kirim konten seperti halaman yang disisipkan di sini (misalnya, gambar halaman PDF\$1teks/metadata). Maks 96 item.
+ **embedding\$1types** (opsional) - Satu atau lebih dari:`float`,,,,. `int8` `uint8` `binary` `ubinary` Jika dihilangkan, kembalikan penyematan float.
+ **output\$1dimension** (opsional) - Pilih panjang vektor. Diizinkan:`256`,`512`,`1024`, `1536` (default `1536` jika tidak ditentukan).
+ **max\$1tokens** (opsional) - Anggaran pemotongan per objek masukan. Model ini mendukung hingga \$1 128.000 token; potongan lebih kecil untuk RAG yang sesuai.
+ **memotong** (opsional) — Cara menangani input yang terlalu panjang: `LEFT` menjatuhkan token dari awal; `RIGHT` turun dari akhir; `NONE` mengembalikan kesalahan jika input melebihi batas.

**Batas & ukuran**  

+ Item per permintaan: hingga 96 gambar. Jenis file gambar asli harus dalam format png, jpeg, webp, atau gif dan dapat berukuran hingga 5 MB.
+ Tutup ukuran permintaan: \$1 20 MB total muatan.
+ Token masukan maksimum: 128k token maks. File gambar diubah menjadi token, dan total token harus kurang dari 128k.
+ Gambar: maks 2.458.624 piksel sebelum downsampling; gambar yang lebih kecil dari 3.136 piksel di-upsample. Berikan gambar sebagai `data:<mime>;base64,....`
+ Penghitungan token (per `inputs` item): Token dari input gambar ≈ (piksel gambar ÷ 784) x 4 Token dari teks yang disisipkan dan input gambar = (piksel gambar ÷ 784) x 4 \$1 (token teks)

**Tip:** Untuk PDFs, ubah setiap halaman menjadi gambar dan kirim melalui `inputs` bersama dengan metadata halaman (misalnya, file\$1name, entitas) di bagian teks yang berdekatan.

------
#### [ Response ]

Jenis konten: aplikasi/json

Jika Anda meminta satu jenis penyematan (misalnya, hanya`float`):

```
{
"id": "string",
"embeddings": [[ /* length = output_dimension */ ]],
"response_type": "embeddings_floats",
"texts": ["..."], // present if text was provided
"inputs": [ { "content": [ ... ] } ] // present if 'inputs' was used
}
```

Jika Anda meminta beberapa jenis penyematan (misalnya,`["float","int8"]`):

```
{
  "id": "string",
  "embeddings": {
    "float": [[ ... ]],
    "int8":  [[ ... ]]
  },
  "response_type": "embeddings_by_type",
  "texts": ["..."],     // when text used
  "inputs": [ { "content": [ ... ] } ] // when 'inputs' used
}
```
+ Jumlah vektor yang dikembalikan cocok dengan panjang `texts` array Anda atau jumlah `inputs` item.
+ Panjang setiap vektor sama `output_dimension` (default`1536`).

------

## Permintaan dan tanggapan untuk input\$1types yang berbeda
<a name="api-inference-examples-cohere-embed-v4"></a>

**A) Halaman interleaved (gambar\$1keterangan) dengan vektor int8 kompak**

**Permintaan**  


```
{
  "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
}
```

**Respon (terpotong)**  


```
{
  "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) Pengindeksan korpus hanya teks (float default, 1536-redup)**

**Permintaan**  


```
{
  "input_type": "search_document",
  "texts": [
    "RAG system design patterns for insurance claims",
    "Actuarial loss triangles and reserving primer"
  ]
}
```

**Respon (sampel)**  


```
{
  "response_type": "embeddings_floats",
  "embeddings": [
    [0.0135, -0.0272, ...],   // length 1536
    [0.0047,  0.0189, ...]
  ]
}
```

## Contoh Kode
<a name="code-examples-cohere-embed-v4"></a>

------
#### [ 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 Sematkan v3
<a name="model-parameters-embed-v3"></a>

**Topics**
+ [Permintaan dan Tanggapan](#model-parameters-embed-v3-request-response)
+ [Contoh kode](#api-inference-examples-cohere-embed-v3)

## Permintaan dan Tanggapan
<a name="model-parameters-embed-v3-request-response"></a>

------
#### [ Request ]

CohereEmbedModel memiliki parameter inferensi berikut. 

```
{
    "input_type": "search_document|search_query|classification|clustering|image",
    "texts":[string],
    "images":[image_base64_image_uri]
    "truncate": "NONE|START|END",
    "embedding_types": embedding_types
}
```

Berikut ini adalah parameter yang diperlukan.
+ **text** — Sebuah array string untuk model untuk embed. Untuk kinerja optimal, kami sarankan untuk mengurangi panjang setiap teks menjadi kurang dari 512 token. 1 token adalah sekitar 4 karakter.

  Berikut ini adalah teks per panggilan dan batas karakter.

**Teks per panggilan**  
    
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/id_id/bedrock/latest/userguide/model-parameters-embed-v3.html)

**Karakter**  
    
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/id_id/bedrock/latest/userguide/model-parameters-embed-v3.html)
+ **input\$1type** — Menambahkan token khusus untuk membedakan setiap jenis satu sama lain. Anda tidak boleh mencampur jenis yang berbeda bersama-sama, kecuali saat mencampur jenis untuk pencarian dan pengambilan. Dalam hal ini, sematkan korpus Anda dengan `search_document` tipe dan kueri yang disematkan dengan tipe tipe. `search_query` 
  + `search_document`— Dalam kasus penggunaan pencarian, gunakan `search_document` saat Anda menyandikan dokumen untuk penyematan yang Anda simpan dalam database vektor.
  + `search_query`— Gunakan `search_query` saat menanyakan DB vektor Anda untuk menemukan dokumen yang relevan.
  + `classification`— Gunakan `classification` saat menggunakan embeddings sebagai masukan ke pengklasifikasi teks.
  + `clustering`— Gunakan `clustering` untuk mengelompokkan embeddings.
  + `images`- Ini adalah array gambar.
    + Array data gambar URIs untuk model yang akan disematkan. Jumlah maksimum gambar per panggilan adalah 1 (yaitu, model hanya mendukung satu input gambar).
    + Gambar harus berupa URI data yang valid. Gambar harus dalam salah satu image/jpeg atau image/png format dan memiliki ukuran maksimum 5MB.
    + Hanya satu dari “gambar” atau “teks” yang harus disediakan.

Berikut ini adalah parameter opsional:
+  **truncate** — Menentukan bagaimana API menangani input lebih lama dari panjang token maksimum. Gunakan salah satu langkah berikut:
  + `NONE`— (Default) Mengembalikan kesalahan ketika input melebihi panjang token masukan maksimum. 
  + `START`— Buang awal input. 
  + `END`— Buang akhir input.

  Jika Anda menentukan `START` atau`END`, model membuang input hingga input yang tersisa persis dengan panjang token input maksimum untuk model.
+  **embedding\$1types** - Menentukan jenis embeddings Anda ingin telah kembali. Opsional dan default adalah`None`, yang mengembalikan jenis `Embed Floats` respons. Bisa satu atau lebih dari jenis berikut:
  + `float`— Gunakan nilai ini untuk mengembalikan embeddings float default. 
  + `int8`— Gunakan nilai ini untuk mengembalikan penyematan int8 yang ditandatangani. 
  + `uint8`— Gunakan nilai ini untuk mengembalikan embeddings int8 yang tidak ditandatangani. 
  + `binary`— Gunakan nilai ini untuk mengembalikan penyematan biner yang ditandatangani. 
  + `ubinary`— Gunakan nilai ini untuk mengembalikan embeddings biner yang tidak ditandatangani. 

Untuk informasi selengkapnya, lihat [https://docs.cohere.com/reference/menyematkan](https://docs.cohere.com/reference/embed) dalam Cohere dokumentasi.

------
#### [ Response ]

`body`Tanggapan dari panggilan ke `InvokeModel` adalah sebagai berikut:

```
{
    "embeddings": [
        [ array of 1024 floats. ]
    ],
    "id": string,
    "response_type" : "embeddings_floats,
    "texts": [string],
    "images": [image_description]
}
```

`body`Tanggapan memiliki bidang-bidang berikut:
+ **id** — Pengenal untuk respons. 
+ **response\$1type — Jenis** respon. Nilai ini selalu `embeddings_floats`. 
+ **Embeddings** — Sebuah array embeddings, di mana setiap embedding adalah array float dengan 1024 elemen. Panjang `embeddings` array akan sama dengan panjang `texts` array asli. 
+ **text** — Sebuah array yang berisi entri teks yang embeddings dikembalikan. 
+ **gambar** — Sebuah array deskripsi untuk setiap input gambar.

  Sebuah `image_description` image\$1description adalah dari bentuk ini:

  ```
  {
      "width": long,
      "height": long,
      "format": string,
      "bit_depth": long
  }
  ```

  Jika gambar digunakan sebagai input, bidang `“texts”` respon akan menjadi array kosong. Sebaliknya tidak benar (yaitu, ketika teks digunakan, tidak `“images”` akan ada dalam tanggapan)

Untuk informasi selengkapnya, lihat [https://docs.cohere.com/reference/menyematkan.](https://docs.cohere.com/reference/embed)

------

## Contoh kode
<a name="api-inference-examples-cohere-embed-v3"></a>

Contoh ini menunjukkan cara memanggil *CohereEmbed English*model.

```
# 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()
```

**Input Gambar**

```
# 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()
```