Cohere Command R and Command R+ Modelle

Sie stellen Rückschlussanfragen an Cohere Command R and Cohere Command R+ Modelle mit InvokeModeloder 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 unterModell Amazon Bedrock IDs.

Tipp

Für Konversationsanwendungen empfehlen wir die Verwendung von ConverseAPI. Der Converse API bietet einen einheitlichen Satz von Parametern, die für alle Modelle funktionieren, die Nachrichten unterstützen. Weitere Informationen finden Sie unter Führen Sie ein Gespräch mit den Converse-Betrieben API.

Anforderung und Antwort

Request

Das Tool 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 Pflichtfelder.
- role— Die Rolle für die Nachricht. Gültige Werte sind USER oderCHATBOT. Tokens.
- message— Textinhalt der Nachricht.
Das Folgende ist ein Beispiel JSON für das chat_history Feld
```
"chat_history": [
{"role": "USER", "message": "Who discovered gravity?"},
{"role": "CHATBOT", "message": "The man who is widely credited with discovering gravity is Sir Isaac Newton"}
]
```
Dokumente — Eine Liste von Texten, die das Modell zitieren kann, um eine genauere Antwort zu erhalten. Jedes Dokument ist ein Wörterbuch mit Zeichenketten. Die daraus resultierende Generation umfasst Zitate, die auf einige dieser Dokumente verweisen. Wir empfehlen, die Gesamtzahl der Wörter der Zeichenketten im Wörterbuch auf weniger als 300 Wörter zu beschränken. Optional kann ein _excludes Feld (eine Reihe von Zeichenketten) angegeben werden, um zu verhindern, dass einige Schlüssel-Wert-Paare dem Modell angezeigt werden. Weitere Informationen finden Sie in der Anleitung zum Dokumentmodus im Cohere -Dokumentation.

Das Folgende ist ein Beispiel JSON für das documents Feld.
```
"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 Wanntrue, die Antwort enthält nur eine Liste generierter Suchanfragen, es findet jedoch keine Suche statt und es wird keine Antwort des Modells an die des Benutzers generiert. message
Präambel — Setzt die Standardpräambel für die Generierung von Suchanfragen außer Kraft. Hat keinen Einfluss auf die Generationen der Toolnutzung.
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 den documents Feldern tools oder verwendet wird.

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

Standard	Minimum	Maximum
0.3	0	1

p — Top P. Verwenden Sie einen niedrigeren Wert, um weniger wahrscheinliche Optionen zu ignorieren.

Standard	Minimum	Maximum
0.75	0.01	0.99

k — Top 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 die Eingabeaufforderung aufgebaut ist. Bei prompt_truncation Einstellung auf documents werden einige Elemente von chat_history und gelöschtAUTO_PRESERVE_ORDER, um eine Eingabeaufforderung zu erstellen, die 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 gesetzt OFF ist, werden keine Elemente gelöscht.

frequency_penalty — Wird verwendet, um die Wiederholbarkeit generierter Token zu reduzieren. Je höher der Wert, desto stärker wird eine Strafe auf bereits vorhandene Token angewendet, und zwar proportional dazu, wie oft sie bereits in der Eingabeaufforderung oder bei der vorherigen Generierung erschienen sind.

Standard	Minimum	Maximum
0	0	1

presence_penalty — Wird verwendet, um die Wiederholbarkeit generierter Token zu reduzieren. Ähnlich wiefrequency_penalty, mit dem Unterschied, dass diese Strafe gleichmäßig auf alle Tokens 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, Tokens 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, dass die vollständige Aufforderung zurückgegeben werden soll, die an das Modell gesendet wurde. Der Standardwert ist false. In der Antwort die Eingabeaufforderung im Feld. prompt
Tools — Eine Liste verfügbarer Tools (Funktionen), deren Aufruf das Modell möglicherweise vorschlägt, bevor eine Textantwort generiert wird. Wenn übergeben tools wird (ohnetool_results), wird das text Feld in der Antwort "" und das tool_calls Feld in der Antwort wird mit einer Liste von Toolaufrufen 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 Verwendung von Tools im Cohere -Dokumentation.

Tipp
Wir empfehlen Ihnen, Converse zu verwenden, API um die Verwendung von Tools in Ihre Anwendung zu integrieren. Weitere Informationen finden Sie unter Verwenden Sie ein Tool, um eine Antwort auf das Amazon Bedrock-Modell abzuschließen.

Das Folgende ist ein Beispiel JSON für das tools Feld.
```
[
    {
        "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 unter Verwendung eines Tools in einem Schritt (Funktionsaufruf) im Cohere -Dokumentation.
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 tool_results tools muss es 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, feinkörnige 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 einbinden. {"status": 200}

Weitere Informationen finden Sie unter Verwendung von Tools im Cohere -Dokumentation.

Das Folgende ist ein Beispiel JSON für das tools_results Feld.
```
[
    {
        "call": {
            "name": "top_song",
            "parameters": {
                "sign": "WZPZ"
            }
        },
        "outputs": [
            {
                "song": "Elemental Hotel"
            }
        ]
    }
]
```
stop_sequences — Eine Liste von Stoppsequenzen. Nachdem eine Stoppsequenz erkannt wurde, beendet das Modell die Generierung weiterer Token.
raw_prompting — Geben Sie antrue, dass die Daten des Benutzers ohne Vorverarbeitung message an das Modell gesendet werden sollen, andernfalls 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 den Abschluss des Chats
text — Die Antwort des Modells auf die Eingabe einer Chat-Nachricht.
generation_id — Eindeutiger Bezeichner für den Abschluss eines Chats, der zusammen mit dem Feedback-Endpunkt auf der Plattform von Cohere verwendet wird.
Zitate — Eine Reihe 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 DokumentenIDs, die Dokumenten entsprechen, die für den Text zitiert werden.
prompt — Die vollständige Aufforderung, die an das Modell gesendet wurde. Geben Sie das return_prompt Feld 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 letzte Grund für die beste Leistung ist.
- 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 tools Eingabefeld angeben.

Weitere Informationen finden Sie unter Verwendung von Tools im Cohere -Dokumentation.

Tipp
Wir empfehlen Ihnen, Converse zu verwenden, API um die Verwendung von Tools in Ihre Anwendung zu integrieren. Weitere Informationen finden Sie unter Verwenden Sie ein Tool, um eine Antwort auf das Amazon Bedrock-Modell abzuschließen.

Das Folgende ist ein Beispiel JSON für das tool_calls Feld.
```
[
        {
            "name": "top_song",
            "parameters": {
                "sign": "WZPZ"
            }
        }
    ]
```
Meta — API Nutzungsdaten (existieren nur für Streaming).
- api_version— Die API Version. Die Version ist im version Feld.
- 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 Ausgabetokens, die in Rechnung gestellt wurden.

Codebeispiel

Dieses Beispiel zeigt, wie man den aufruft Cohere Command RModell.


# 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 Modelle

AI21 Labs Modelle