Cohere Command R und Command R+ -Modelle von

Sie stellen Inferenzanfragen an Cohere Command R und Cohere Command R+ Modelle mit InvokeModel oder InvokeModelWithResponseStream (Streaming). 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.

Tipp

Für Konversationsanwendungen empfehlen wir die Verwendung der Converse-API. Die Converse-API bietet einen einheitlichen Satz von Parametern, die für alle Modelle funktionieren, die Nachrichten unterstützen. Weitere Informationen finden Sie unter Inferenz mit der Converse-API.

Anforderung und Antwort

Request

Die Cohere-Command-Modelle haben die folgenden Inferenzparameter.


{
    "message": string,
    "chat_history": [
        {
            "role":"USER or CHATBOT",
            "message": string
        }
  
    ],
    "documents": [
        {"title": string, "snippet": string},
    ],
    "search_queries_only" : boolean,
    "preamble" : string,
    "max_tokens": int,
    "temperature": float,
    "p": float,
    "k": float,
    "prompt_truncation" : string,
    "frequency_penalty" : float,
    "presence_penalty" : float,
    "seed" : int,
    "return_prompt" : boolean,
    "tools" : [
        {
            "name": string,
            "description": string,
            "parameter_definitions": {
                "parameter name": {
                    "description": string,
                    "type": string,
                    "required": boolean
                }
            }
        }
    ],
    "tool_results" : [
        {
            "call": {
                "name": string,
                "parameters": {
                "parameter name": string
                }
            },
        "outputs": [
                {
                "text": string
                }
            ]
        }
    ],
    "stop_sequences": [string],
    "raw_prompting" : boolean

}

Die folgenden Parameter sind erforderlich.

message – (erforderlich) Texteingabe, auf die das Modell antworten soll

Die folgenden Parameter sind optional.

chat_history – Eine Liste früherer Nachrichten zwischen dem Benutzer und dem Modell, die dem Modell einen Konversationskontext für die Beantwortung der Nachricht des Benutzers geben soll.

Die folgenden Felder sind erforderlich.
- role – Die Rolle für die Nachricht. Gültige Werte sind USER- oder CHATBOT-Token.
- message – Der Inhalt der Nachricht
Im Folgenden sehen Sie ein JSON-Beispiel für das Feld chat_history.
```
"chat_history": [
{"role": "USER", "message": "Who discovered gravity?"},
{"role": "CHATBOT", "message": "The man who is widely credited with discovering gravity is Sir Isaac Newton"}
]
```
documents – Eine Liste von Texten, die das Modell zitieren kann, um eine genauere Antwort zu generieren. Jedes Dokument ist ein Wörterbuch mit Zeichenfolgen. Die daraus resultierende Generierung umfasst Zitate, die auf einige dieser Dokumente verweisen. Wir empfehlen, die Gesamtzahl der Wörter der Zeichenfolgen im Wörterbuch auf weniger als 300 Wörter zu beschränken. Optional kann ein _excludes-Feld (ein Array von Zeichenfolgen) angegeben werden, um zu verhindern, dass einige Schlüssel-Wert-Paare dem Modell angezeigt werden. Weitere Informationen finden Sie unter Leitfaden für Dokumentenmodi in der Cohere-Dokumentation.

Im Folgenden sehen Sie ein JSON-Beispiel für das Feld documents.
```
"documents": [
{"title": "Tall penguins", "snippet": "Emperor penguins are the tallest."},
{"title": "Penguin habitats", "snippet": "Emperor penguins only live in Antarctica."}
]
```
search_queries_only – Die Standardeinstellung ist false. Wenn true gilt, enthält die Antwort nur eine Liste generierter Suchabfragen, es findet jedoch keine Suche statt und es wird keine Antwort des Modells auf die message des Benutzers generiert.
preamble – Setzt die Standardpräambel für die Generierung von Suchabfragen außer Kraft. Dies hat keinen Einfluss auf die Generationen der Tool-Nutzung.
max_tokens – Die maximale Anzahl von Token, die das Modell als Teil der Antwort generieren sollte. Beachten Sie, dass die Festlegung eines niedrigen Werts zu unvollständigen Generierungen führen kann. Die Einstellung max_tokens kann zu unvollständigen oder gar keinen Generierungen führen, wenn sie zusammen mit dem Feld tools oder documents verwendet wird.

Temperatur – Verwenden Sie einen niedrigeren Wert, um die Zufälligkeit der Antwort zu verringern. Die Zufälligkeit kann weiter maximiert werden, indem der Wert des p-Parameters erhöht wird.

Standard	Minimum	Maximum
0.3	0	1

p – Verwenden Sie einen niedrigeren Wert, um weniger wahrscheinliche Optionen zu ignorieren.

Standard	Minimum	Maximum
0.75	0.01	0.99

k – Geben Sie die Anzahl der Token-Optionen an, die das Modell zur Generierung des nächsten Tokens verwendet.

Standard	Minimum	Maximum
0	0	500

prompt_truncation – Die Standardeinstellung ist OFF. Legt fest, wie der Prompt aufgebaut ist. Bei Einstellung von prompt_truncation auf AUTO_PRESERVE_ORDER werden einige Elemente von chat_history und documents gelöscht, um einen Prompt zu erstellen, der innerhalb der Kontext-Längenbeschränkung des Modells liegt. Während dieses Vorgangs werden die Reihenfolge der Dokumente und der Chat-Verlauf beibehalten. Wenn prompt_truncation auf OFF festgelegt ist, werden keine Elemente gelöscht.

frequency_penalty – Wird verwendet, um die Wiederholbarkeit generierter Token zu reduzieren. Je höher der Wert ist, umso stärker ist die für zuvor bereits vorhandene Token angewendete Penalty, proportional dazu, wie oft sie bereits in dem Prompt oder der vorherigen Generierung aufgetreten sind.

Standard	Minimum	Maximum
0	0	1

presence_penalty – Wird verwendet, um die Wiederholbarkeit generierter Token zu reduzieren. Ähnlich wie frequency_penalty nur mit dem Unterschied, dass diese Strafe gleichmäßig auf alle Token angewendet wird, die bereits erschienen sind, unabhängig von ihrer genauen Häufigkeit.

Standard	Minimum	Maximum
0	0	1

seed – Falls angegeben, bemüht sich das Backend nach besten Kräften, Token deterministisch zu testen, sodass wiederholte Anfragen mit demselben Startwert und denselben Parametern dasselbe Ergebnis liefern sollten. Determinismus kann jedoch nicht vollständig garantiert werden.
return_prompt – Geben Sie true an, damit der vollständige Prompt zurückgegeben wird, der an das Modell gesendet wurde. Der Standardwert ist false. In der Antwort ist dies der Prompt im Feld prompt.
tools – Eine Liste verfügbarer Tools (Funktionen), deren Aufruf das Modell möglicherweise vorschlägt, bevor eine Textantwort generiert wird. Wenn tools (ohne tool_results) übergeben wird, lautet das Feld text in der Antwort "" und das Feld tool_calls in der Antwort wird mit einer Liste von Tool-Aufrufen gefüllt, die getätigt werden müssen. Wenn keine Aufrufe getätigt werden müssen, ist das tool_calls-Array leer.

Weitere Informationen finden Sie unter Tool-Nutzung in der Cohere-Dokumentation.

Tipp
Wir empfehlen Ihnen, die Responses API oder Messages API zu verwenden, um die Verwendung von Tools in Ihre Anwendung zu integrieren. Weitere Informationen finden Sie unter Verwenden eines Tools, um eine Amazon-Bedrock-Modellantwort zu vervollständigen.

Im Folgenden sehen Sie ein JSON-Beispiel für das Feld tools.
```
[
    {
        "name": "top_song",
        "description": "Get the most popular song played on a radio station.",
        "parameter_definitions": {
            "sign": {
                "description": "The call sign for the radio station for which you want the most popular song. Example calls signs are WZPZ and WKRP.",
                "type": "str",
                "required": true
            }
        }
    }
]
```
Weitere Informationen finden Sie in der Cohere Dokumentation unter Verwendung von Single-Step Tools (Funktionsaufruf).
tools_results – Eine Liste der Ergebnisse des Aufrufs von Tools, die vom Modell in der vorherigen Chatrunde empfohlen wurden. Die Ergebnisse werden verwendet, um eine Textantwort zu erstellen, und in Quellenangaben wird auf sie verwiesen. Bei der Verwendung von tool_results muss tools ebenfalls übergeben werden. Jedes tool_result enthält Informationen darüber, wie es aufgerufen wurde, sowie eine Liste von Ausgaben in Form von Wörterbüchern. Die einzigartige differenzierte Zitierlogik von Cohere erfordert, dass es sich bei der Ausgabe um eine Liste handelt. Falls es sich bei der Ausgabe beispielsweise nur um ein Element handelt, sollten Sie es trotzdem in eine Liste {"status": 200} einbinden.

Weitere Informationen finden Sie unter Tool-Nutzung in der Cohere-Dokumentation.

Im Folgenden sehen Sie ein JSON-Beispiel für das Feld tools_results.
```
[
    {
        "call": {
            "name": "top_song",
            "parameters": {
                "sign": "WZPZ"
            }
        },
        "outputs": [
            {
                "song": "Elemental Hotel"
            }
        ]
    }
]
```
stop_sequences – Eine Liste von Stoppsequenzen. Nachdem eine Stoppsequenz erkannt wird, stoppt das Modell die Generierung weiterer Token.
raw_prompting – Geben Sie true an, um die message des Benutzers ohne Vorverarbeitung an das Modell zu senden, andernfalls lautet der Wert falsch.

Response

Die Antwort enthält folgende mögliche Felder:


{
    "response_id": string,
    "text": string,
    "generation_id": string,
    "citations": [
        {
          "start": int,
          "end": int,
          "text": "string",
          "document_ids": [
              "string"
          ]
        }
      ],    
    "finish_reason": string,
    "tool_calls": [
        {
            "name": string,
            "parameters": {
                "parameter name": string
            }
        }
    ],
    {
    "meta": {
        "api_version": {
            "version": string
        },
        "billed_units": {
            "input_tokens": int,
            "output_tokens": int
        }
    }
}

response_id – Eindeutiger Bezeichner für die Chat-Vervollständigung
text – Die Antwort des Modells auf die Eingabe einer Chat-Nachricht
generation_id – Eindeutiger Bezeichner für die Chat-Vervollständigung, der zusammen mit dem Feedback-Endpunkt auf der Plattform von Cohere verwendet wird
citations – Ein Array von Inline-Zitaten und zugehörigen Metadaten für die generierte Antwort. Enthält die folgenden Felder:
- start – Der Index, an dem das Zitat beginnt, beginnend bei 0
- end – Der Index, nach dem das Zitat endet, beginnend bei 0
- text – Der Text, auf den sich das Zitat bezieht
- document_ids – Eine Reihe von Dokument-IDs, die Dokumenten entsprechen, die für den Text zitiert werden
prompt – Der vollständige Prompt, der an das Modell gesendet wurde. Geben Sie das Feld return_prompt an, um dieses Feld zurückzugeben.
finish_reason – Der Grund, warum das Modell keine Ausgabe mehr generiert hat Eine der folgenden Möglichkeiten kann möglich sein:
- complete – Die Fertigstellung hat das Ende des Generierungstoken erreicht. Stellen Sie sicher, dass dies der Grund für die Beendigung ist, um die beste Leistung zu erzielen.
- error_toxic – Die Generierung konnte aufgrund unserer Inhaltsfilter nicht abgeschlossen werden.
- error_limit – Die Generierung konnte nicht abgeschlossen werden, da das Kontextlimit des Modells erreicht wurde.
- error – Die Generierung konnte aufgrund eines Fehlers nicht abgeschlossen werden.
- user_cancel – Die Generierung konnte nicht abgeschlossen werden, da sie vom Benutzer gestoppt wurde.
- max_tokens – Die Generierung konnte nicht abgeschlossen werden, da der Benutzer in der Anfrage ein max_tokens-Limit angegeben hat und dieses Limit erreicht wurde. Führt möglicherweise nicht zur besten Leistung.
tool_calls – Eine Liste geeigneter Tools für Aufrufe. Wird nur zurückgegeben, wenn Sie das Eingabefeld tools angeben.

Weitere Informationen finden Sie unter Tool-Nutzung in der Cohere-Dokumentation.

Tipp
Wir empfehlen Ihnen, die Responses API oder Messages API zu verwenden, um die Verwendung von Tools in Ihre Anwendung zu integrieren. Weitere Informationen finden Sie unter Verwenden eines Tools, um eine Amazon-Bedrock-Modellantwort zu vervollständigen.

Im Folgenden sehen Sie ein JSON-Beispiel für das Feld tool_calls.
```
[
        {
            "name": "top_song",
            "parameters": {
                "sign": "WZPZ"
            }
        }
    ]
```
meta – API-Nutzungsdaten (existieren nur für Streaming)
- api_version – Die API-Version. Die Version ist im Feld version angegeben.
- billed_units – Die abgerechneten Einheiten Die möglichen Werte sind:
  - input_tokens – Die Anzahl der Eingabe-Token, die in Rechnung gestellt wurden
  - output_tokens – Die Anzahl der Ausgabe-Token, die in Rechnung gestellt wurden.

Codebeispiel

Dieses Beispiel zeigt, wie das Modell Cohere Command R aufgerufen wird.


# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
# SPDX-License-Identifier: Apache-2.0
"""
Shows how to use the  Cohere Command R model.
"""
import json
import logging
import boto3


from botocore.exceptions import ClientError

logger = logging.getLogger(__name__)
logging.basicConfig(level=logging.INFO)


def generate_text(model_id, body):
    """
    Generate text using a Cohere Command R model.
    Args:
        model_id (str): The model ID to use.
        body (str) : The reqest body to use.
    Returns:
        dict: The response from the model.
    """

    logger.info("Generating text with Cohere model %s", model_id)

    bedrock = boto3.client(service_name='bedrock-runtime')

    response = bedrock.invoke_model(
        body=body,
        modelId=model_id
    )

    logger.info(
        "Successfully generated text with Cohere Command R model %s", model_id)

    return response


def main():
    """
    Entrypoint for Cohere example.
    """

    logging.basicConfig(level=logging.INFO,
                        format="%(levelname)s: %(message)s")

    model_id = 'cohere.command-r-v1:0'
    chat_history = [
        {"role": "USER", "message": "What is an interesting new role in AI if I don't have an ML background?"},
        {"role": "CHATBOT", "message": "You could explore being a prompt engineer!"}
    ]
    message = "What are some skills I should have?"

    try:
        body = json.dumps({
            "message": message,
            "chat_history": chat_history,
            "max_tokens": 2000,
            "temperature": 0.6,
            "p": 0.5,
            "k": 250
        })
        response = generate_text(model_id=model_id,
                                 body=body)

        response_body = json.loads(response.get('body').read())
        response_chat_history = response_body.get('chat_history')
        print('Chat history\n------------')
        for response_message in response_chat_history:
            if 'message' in response_message:
                print(f"Role: {response_message['role']}")
                print(f"Message: {response_message['message']}\n")
        print("Generated text\n--------------")
        print(f"Stop reason: {response_body['finish_reason']}")
        print(f"Response text: \n{response_body['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 with Cohere model {model_id}.")


if __name__ == "__main__":
    main()

Warnung JavaScript ist in Ihrem Browser nicht verfügbar oder deaktiviert.

Zur Nutzung der AWS-Dokumentation muss JavaScript aktiviert sein. Weitere Informationen finden auf den Hilfe-Seiten Ihres Browsers.

Dokumentkonventionen

Cohere Embed v3

DeepSeek -Modelle von