\n\nAssistant:",
"temperature": float,
"top_p": float,
"top_k": int,
"max_tokens_to_sample": int,
"stop_sequences": [string]
}
```
Die folgenden Parameter sind erforderlich.
+ **prompt** – (erforderlich) Der Prompt, den Claude vervollständigen soll. Zur Gewährleistung einer korrekte Antwortgenerierung müssen Sie Ihren Prompt für Konversationsrunden abwechselnd mit `\n\nHuman:` und `\n\nAssistant:` formatieren. Zum Beispiel:
```
"\n\nHuman: {userQuestion}\n\nAssistant:"
```
Weitere Informationen finden Sie unter [Prompt-Validierung](https://docs.anthropic.com/claude/reference/prompt-validation) in der Dokumentation zu Anthropic Claude.
+ **max\$1tokens\$1to\$1sample** – (erforderlich) Die maximale Anzahl von Token, die vor dem Stoppen generiert werden sollen. Für eine optimale Leistung empfehlen wir ein Limit von 4 000 Token.
Beachten Sie, dass Anthropic-Claude-Modelle möglicherweise die Generierung von Token einstellen, bevor der Wert von `max_tokens_to_sample` erreicht ist. Verschiedene Anthropic-Claude-Modelle haben unterschiedliche Maximalwerte für diesen Parameter. Weitere Informationen finden Sie unter [Modellvergleich](https://docs.anthropic.com/claude/docs/models-overview#model-comparison) in der Dokumentation zu Anthropic Claude.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/bedrock/latest/userguide/model-parameters-anthropic-claude-text-completion.html)
Die folgenden Parameter sind optional.
+ **stop\$1sequences** – (optional) Sequenzen, die dazu führen, dass das Modell das Generieren beendet.
Anthropic-Claude-Modelle halten bei `"\n\nHuman:"` an und können künftig zusätzliche integrierte Stoppsequenzen enthalten. Verwenden Sie den `stop_sequences`-Inferenzparameter, um zusätzliche Zeichenfolgen einzubeziehen, die dem Modell signalisieren, die Textgenerierung einzustellen.
+ **temperature** – (optional) Die Menge an Zufälligkeit, die der Antwort hinzugefügt wurde. Verwenden Sie für analytische oder Multiple-Choice-Aufgaben einen Wert, der näher an 0 liegt, und für kreative und generative Aufgaben einen Wert, der näher an 1 liegt.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/bedrock/latest/userguide/model-parameters-anthropic-claude-text-completion.html)
+ **top\$1p** – (optional) Verwenden Sie Nukleus-Sampling.
Beim Nukleus-Sampling berechnet Anthropic Claude die kumulative Verteilung über alle Optionen für jedes nachfolgende Token in absteigender Wahrscheinlichkeitsreihenfolge und beendet den Vorgang, sobald eine bestimmte, durch `top_p` festgelegte Wahrscheinlichkeit erreicht ist. Sie sollten entweder `temperature` oder `top_p` ändern, aber nicht beide.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/bedrock/latest/userguide/model-parameters-anthropic-claude-text-completion.html)
+ **top\$1k** – (optional) Nehmen Sie für jedes nachfolgende Token nur Stichproben aus den Top-K-Optionen vor.
Verwenden Sie `top_k`, um Antworten mit langen Ausläufern und geringer Wahrscheinlichkeit zu entfernen.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/bedrock/latest/userguide/model-parameters-anthropic-claude-text-completion.html)
------
#### [ Response ]
Das Anthropic-Claude-Modell verfügt über die folgenden Felder für einen Inferenzaufruf zur Textvervollständigung.
```
{
"completion": string,
"stop_reason": string,
"stop": string
}
```
+ **completion** – Die daraus resultierende Vervollständigung bis zu und ohne die Stoppsequenzen.
+ **stop\$1reason** – Der Grund, warum das Modell keine Antwort mehr generiert hat.
+ **„stop\$1sequence“** – Das Modell hat eine Stoppsequenz erreicht, die entweder von Ihnen mit dem `stop_sequences`-Inferenzparameter bereitgestellt wurde, oder eine in das Modell integrierte Stoppsequenz ist.
+ **„max\$1tokens“** – Das Modell hat `max_tokens_to_sample` oder die maximale Token-Anzahl des Modells überschritten.
+ **stop** – Wenn Sie den `stop_sequences`-Inferenzparameter angeben, enthält `stop` die Stoppsequenz, die dem Modell signalisiert hat, die Textgenerierung zu beenden. Ein Beispiel dafür ist `holes` in der folgenden Antwort.
```
{
"completion": " Here is a simple explanation of black ",
"stop_reason": "stop_sequence",
"stop": "holes"
}
```
Wenn Sie `stop_sequences` nicht angeben, ist der Wert `stop` leer.
------
## Codebeispiel
Diese Beispiele zeigen, wie das Modell *Anthropic Claude V2* mit On-Demand-Durchsatz aufgerufen wird. Ändern Sie den Wert von `modelId` in `anthropic.claude-v2:1`, um Anthropic Claude Version 2.1 zu verwenden.
```
import boto3
import json
brt = boto3.client(service_name='bedrock-runtime')
body = json.dumps({
"prompt": "\n\nHuman: explain black holes to 8th graders\n\nAssistant:",
"max_tokens_to_sample": 300,
"temperature": 0.1,
"top_p": 0.9,
})
modelId = 'anthropic.claude-v2'
accept = 'application/json'
contentType = 'application/json'
response = brt.invoke_model(body=body, modelId=modelId, accept=accept, contentType=contentType)
response_body = json.loads(response.get('body').read())
# text
print(response_body.get('completion'))
```
Das folgende Beispiel zeigt, wie Streaming-Text mit Python mithilfe der Eingabeaufforderung *Einen Aufsatz zum Leben auf dem Mars in 1 000 Wörtern schreiben* und des Modells Anthropic Claude V2 generiert wird:
```
import boto3
import json
brt = boto3.client(service_name='bedrock-runtime')
body = json.dumps({
'prompt': '\n\nHuman: write an essay for living on mars in 1000 words\n\nAssistant:',
'max_tokens_to_sample': 4000
})
response = brt.invoke_model_with_response_stream(
modelId='anthropic.claude-v2',
body=body
)
stream = response.get('body')
if stream:
for event in stream:
chunk = event.get('chunk')
if chunk:
print(json.loads(chunk.get('bytes').decode()))
```
# Nachrichten-API von Anthropic Claude
Dieser Abschnitt enthält Inferenzparameter und ein Codebeispiel für die Verwendung der Nachrichten-API Anthropic Claude.
**Topics**
+ [Übersicht über die Nachrichten-API von Anthropic Claude](#model-parameters-anthropic-claude-messages-overview)
+ [Verwendung des Tools](model-parameters-anthropic-claude-messages-tool-use.md)
+ [Erweitertes Denken](claude-messages-extended-thinking.md)
+ [Adaptives Denken](claude-messages-adaptive-thinking.md)
+ [Verschlüsselung beim Denken](claude-messages-thinking-encryption.md)
+ [Unterschiede im Denken zwischen den Modellversionen](claude-messages-thinking-differences.md)
+ [Verdichtung](claude-messages-compaction.md)
+ [Holen Sie sich validierte JSON-Ergebnisse aus Modellen](claude-messages-structured-outputs.md)
+ [Anforderung und Antwort](model-parameters-anthropic-claude-messages-request-response.md)
+ [Codebeispiele](api-inference-examples-claude-messages-code-examples.md)
+ [Unterstützte Modelle](claude-messages-supported-models.md)
## Übersicht über die Nachrichten-API von Anthropic Claude
Sie können die Nachrichten-API verwenden, um Chat-Bots oder virtuelle Assistentenanwendungen zu erstellen. Die API verwaltet den Konversationsaustausch zwischen einem Benutzer und einem Anthropic-Claude-Modell (Assistent).
**Anmerkung**
In diesem Thema wird gezeigt, wie die Anthropic Claude Nachrichten-API mit den Basisinferenzoperationen ([InvokeModel](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModel.html)oder [InvokeModelWithResponseStream](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModelWithResponseStream.html)) verwendet wird. Wir empfehlen jedoch, die Converse-API zu verwenden, um Nachrichten in Ihrer Anwendung zu implementieren. Die 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 einer Konversation mit den Converse-API-Operationen](conversation-inference.md).
Einschränkungen gelten für die folgenden Operationen:`InvokeModel`, `InvokeModelWithResponseStream``Converse`, und`ConverseStream`. Einzelheiten finden Sie unter [API-Einschränkungen](inference-api-restrictions.md).
Anthropic trainiert Claude-Modelle so, dass sie abwechselnd als Benutzer und als Assistent kommunizieren. Wenn Sie eine neue Nachricht erstellen, geben Sie mit dem Nachrichtenparameter die vorherigen Gesprächsrunden an. Das Modell generiert dann die nächste Nachricht in der Konversation.
Jede Eingabenachricht muss ein Objekt mit einer Rolle und einem Inhalt sein. Sie können eine einzelne Benutzerrollennachricht angeben oder mehrere Benutzer- und Assistentennachrichten einbeziehen.
Wenn Sie die Technik verwenden, die Antwort von Claude vorab auszufüllen (indem Sie den Anfang von Claudes Antwort mithilfe einer endgültigen Nachricht der Assistentenrolle ausfüllen), antwortet Claude und macht dort weiter, wo Sie aufgehört haben. Bei dieser Technik gibt Claude nach wie vor eine Antwort mit der Assistentenrolle zurück.
Wenn für die endgültige Nachricht die Assistentenrolle verwendet wird, wird der Inhalt der Antwort sofort mit dem Inhalt dieser Nachricht fortgesetzt. Sie können dies verwenden, um einen Teil der Antwort des Modells einzuschränken.
Beispiel mit einer einzigen Benutzernachricht:
```
[{"role": "user", "content": "Hello, Claude"}]
```
Beispiel mit mehreren Konversationsrunden:
```
[
{"role": "user", "content": "Hello there."},
{"role": "assistant", "content": "Hi, I'm Claude. How can I help you?"},
{"role": "user", "content": "Can you explain LLMs in plain English?"},
]
```
Beispiel mit einer teilweise ausgefüllten Antwort von Claude:
```
[
{"role": "user", "content": "Please describe yourself using only JSON"},
{"role": "assistant", "content": "Here is my JSON description:\n{"},
]
```
Der Inhalt jeder Eingabenachricht kann entweder eine einzelne Zeichenfolge oder ein Array von Inhaltsblöcken sein, wobei jeder Block einen bestimmten Typ hat. Die Verwendung einer Zeichenfolge ist eine Abkürzung für ein Array aus einem Inhaltsblock vom Typ „text“. Die folgenden Eingabenachrichten sind gleichwertig:
```
{"role": "user", "content": "Hello, Claude"}
```
```
{"role": "user", "content": [{"type": "text", "text": "Hello, Claude"}]}
```
Informationen zum Erstellen von Prompts für Anthropic-Claude-Modelle finden Sie unter [Einführung in das Prompting](https://docs.anthropic.com/claude/docs/intro-to-prompting) in der Dokumentation zu Anthropic Claude. Wenn Sie bereits Prompts zur [Textvervollständigung](model-parameters-anthropic-claude-text-completion.md) haben, die Sie zur Nachrichten-API migrieren möchten, finden Sie weitere Informationen unter [Migration von Textvervollständigungen](https://docs.anthropic.com/claude/reference/migrating-from-text-completions-to-messages).
**Wichtig**
Der Timeout-Zeitraum für Inferenzaufrufe an Modelle von Anthropic Claude 3.7 Sonnet und Claude 4 beträgt 60 Minuten. Standardmäßig läuft das Timeout für AWS SDK-Clients nach 1 Minute ab. Wir empfehlen, dass Sie das Lese-Timeout Ihres AWS SDK-Clients auf mindestens 60 Minuten erhöhen. Ändern Sie beispielsweise im AWS Python Botocore SDK den Wert des Felds `read_timeout` in [botocore.config](https://botocore.amazonaws.com/v1/documentation/api/latest/reference/config.html#) auf mindestens 3 600.
### System-Prompts
Sie können der Anfrage auch einen System-Prompt hinzufügen. Mit einem System-Prompt können Sie Anthropic Claude Kontextinformationen und Anweisungen bereitstellen, wie etwa die Angabe eines bestimmten Ziels oder einer bestimmten Rolle. Geben Sie im `system`-Feld einen System-Prompt an, wie im folgenden Beispiel dargestellt.
```
"system": "You are Claude, an AI assistant created by Anthropic to be helpful,
harmless, and honest. Your goal is to provide informative and substantive responses
to queries while avoiding potential harms."
```
Weitere Informationen finden Sie unter [System-Prompts](https://docs.anthropic.com/en/docs/system-prompts) in der Anthropic-Dokumentation.
### Multimodale Prompts
Ein multimodaler Prompt kombiniert mehrere Modalitäten (Bilder und Text) in einem einzigen Prompt. Sie geben die Modalitäten im Eingabefeld `content` an. Das folgende Beispiel zeigt, wie Sie Anthropic Claude dazu auffordern können, den Inhalt eines bereitgestellten Bildes zu beschreiben. Einen Beispielcode finden Sie unter [Multimodale Code-Beispiele](api-inference-examples-claude-messages-code-examples.md#api-inference-examples-claude-multimodal-code-example).
```
{
"anthropic_version": "bedrock-2023-05-31",
"max_tokens": 1024,
"messages": [
{
"role": "user",
"content": [
{
"type": "image",
"source": {
"type": "base64",
"media_type": "image/jpeg",
"data": "iVBORw..."
}
},
{
"type": "text",
"text": "What's in these images?"
}
]
}
]
}
```
Jedes Bild, das Sie in eine Anfrage aufnehmen, wird auf Ihre Token-Nutzung angerechnet. Weitere Informationen finden Sie unter [Kosten für Bilder](https://docs.anthropic.com/claude/docs/vision#image-costs) in der Anthropic-Dokumentation.
# Verwendung des Tools
**Warnung**
Einige der folgenden Funktionen werden, wie angegeben, in der Betaversion angeboten. Diese Funktionen werden Ihnen als „Beta-Service“ gemäß der Definition in den AWS Servicebedingungen zur Verfügung gestellt. Es unterliegt Ihrer Vereinbarung mit AWS und den AWS Servicebedingungen sowie der geltenden Muster-EULA.
Bei Anthropic-Claude-Modellen können Sie ein Tool angeben, mit dem das Modell eine Nachricht beantworten kann. Sie könnten beispielsweise ein Tool angeben, das den beliebtesten Song eines Radiosenders ermittelt. Wenn der Benutzer die Nachricht weitergibt *Was ist der beliebteste Song bei WZPZ?*, stellt das Modell fest, dass das von Ihnen angegebene Tool bei der Beantwortung der Frage helfen kann. In seiner Antwort fordert das Modell Sie auf, das Tool in seinem Namen auszuführen. Anschließend führen Sie das Tool aus und übergeben das Tool-Ergebnis an das Modell, das dann eine Antwort für die ursprüngliche Nachricht generiert. Weitere Informationen finden Sie unter [Verwendung des Tools (Funktionsaufruf)](https://docs.anthropic.com/en/docs/tool-use) in der Anthropic-Claude-Dokumentation.
**Tipp**
Es wird empfohlen, die Converse-API zur Integration der Tool-Nutzung in Ihre Anwendung zu verwenden. Weitere Informationen finden Sie unter [Verwenden eines Tools, um eine Amazon-Bedrock-Modellantwort zu vervollständigen](tool-use.md).
**Wichtig**
Claude Sonnet 4.5 behält jetzt die absichtliche Formatierung der Zeichenfolgenparameter für Tool-Aufrufe bei. Bisher wurden nachfolgende Zeilenumbrüche in Zeichenfolgenparametern manchmal fälschlicherweise entfernt. Mit dieser Korrektur wird sichergestellt, dass Tools, die eine genaue Formatierung erfordern (wie Text-Editoren), Parameter genau wie vorgesehen erhalten. Dies ist eine behind-the-scenes Verbesserung, für die keine API-Änderungen erforderlich sind. Tools mit Zeichenfolgenparametern können jetzt jedoch Werte mit abschließenden Zeilenumbrüchen empfangen, die zuvor entfernt wurden.
**Anmerkung**
Claude Sonnet 4.5 beinhaltet automatische Optimierungen zur Verbesserung der Modellleistung. Durch diese Optimierungen können Anfragen kleine Mengen an Token hinzugefügt werden. Diese vom System hinzugefügten Token werden Ihnen jedoch nicht in Rechnung gestellt.
Sie geben die Tools, die Sie einem Modell zur Verfügung stellen möchten, im Feld `tools` an. Das folgende Beispiel bezieht sich auf ein Tool, das den beliebtesten Song eines Radiosenders ermittelt.
```
[
{
"name": "top_song",
"description": "Get the most popular song played on a radio station.",
"input_schema": {
"type": "object",
"properties": {
"sign": {
"type": "string",
"description": "The call sign for the radio station for which you want the most popular song. Example calls signs are WZPZ and WKRP."
}
},
"required": [
"sign"
]
}
}
]
```
Wenn das Modell ein Tool benötigt, um eine Antwort auf eine Nachricht zu generieren, gibt es Informationen über das angeforderte Tool und die Eingabe für das Tool im `content`-Nachrichtenfeld zurück. Außerdem wird der Grund für den Stopp der Antwort auf `tool_use` festgelegt.
```
{
"id": "msg_bdrk_01USsY5m3XRUF4FCppHP8KBx",
"type": "message",
"role": "assistant",
"model": "claude-3-sonnet-20240229",
"stop_sequence": null,
"usage": {
"input_tokens": 375,
"output_tokens": 36
},
"content": [
{
"type": "tool_use",
"id": "toolu_bdrk_01SnXQc6YVWD8Dom5jz7KhHy",
"name": "top_song",
"input": {
"sign": "WZPZ"
}
}
],
"stop_reason": "tool_use"
}
```
In Ihrem Code rufen Sie das Tool im Namen des Tools auf. Anschließend übergeben Sie das Tool-Ergebnis (`tool_result`) in einer Benutzernachricht an das Modell.
```
{
"role": "user",
"content": [
{
"type": "tool_result",
"tool_use_id": "toolu_bdrk_01SnXQc6YVWD8Dom5jz7KhHy",
"content": "Elemental Hotel"
}
]
}
```
In seiner Antwort verwendet das Modell das Tool-Ergebnis, um eine Antwort auf die ursprüngliche Nachricht zu generieren.
```
{
"id": "msg_bdrk_012AaqvTiKuUSc6WadhUkDLP",
"type": "message",
"role": "assistant",
"model": "claude-3-sonnet-20240229",
"content": [
{
"type": "text",
"text": "According to the tool, the most popular song played on radio station WZPZ is \"Elemental Hotel\"."
}
],
"stop_reason": "end_turn"
}
```
## Differenziertes Tool-Streaming
Differenziertes Tool-Streaming ist eine Anthropic-Claude-Modellfunktion, die mit Claude Sonnet 4.5, Claude Haiku 4.5, Claude Sonnet 4 und Claude Opus 4 verfügbar ist. Mit differenziertem Tool-Streaming können Claude-Entwickler Parameter für die Verwendung von Tools ohne Pufferung oder JSON-Validierung streamen, wodurch die Latenz beim Empfang großer Parameter reduziert wird.
**Anmerkung**
Wenn Sie differenziertes Tool-Streaming verwenden, erhalten Sie möglicherweise ungültige oder unvollständige JSON-Eingaben. Bitte achten Sie darauf, diese Grenzfälle in Ihrem Code zu berücksichtigen.
Wenn Sie dieses Feature nutzen möchten, fügen Sie einfach den Header `fine-grained-tool-streaming-2025-05-14` zu einer Anfrage zur Verwendung eines Tools hinzu.
Hier ist ein Beispiel dafür, wie der Header beim differenzierten Tool-Streaming angegeben werden kann:
```
{
"anthropic_version": "bedrock-2023-05-31",
"max_tokens": 1024,
"anthropic_beta": ["fine-grained-tool-streaming-2025-05-14"],
"messages": [
{
"role": "user",
"content": "Can you write a long poem and make a file called poem.txt?"
}
],
"tools": [
{
"name": "make_file",
"description": "Write text to a file",
"input_schema": {
"type": "object",
"properties": {
"filename": {
"type": "string",
"description": "The filename to write text to"
},
"lines_of_text": {
"type": "array",
"description": "An array of lines of text to write to the file"
}
},
"required": [
"filename",
"lines_of_text"
]
}
}
]
}
```
In diesem Beispiel ermöglicht es Claude durch differenziertes Tool-Streaming, die Zeilen eines langen Gedichts ohne Pufferung in den Tool-Aufruf `make_file` zu streamen, um zu überprüfen, ob es sich bei dem Parameter `lines_of_text` um einen gültigen JSON-Wert handelt. Das bedeutet, dass Sie den Parameter-Stream sehen können, sobald er eingeht, ohne darauf warten zu müssen, dass der gesamte Parameter gepuffert und validiert ist.
Bei differenziertem Tool-Streaming beginnen die Chunks, die das Tool verwenden, schneller zu streamen. Sie sind oft länger und enthalten weniger Wortumbrüche. Dies ist auf Unterschiede im Chunking-Verhalten zurückzuführen.
Ein Beispiel ohne differenziertes Streaming (Verzögerung von 15 Sekunden):
```
Chunk 1: '{"'
Chunk 2: 'query": "Ty'
Chunk 3: 'peScri'
Chunk 4: 'pt 5.0 5.1 '
Chunk 5: '5.2 5'
Chunk 6: '.3'
Chunk 8: ' new f'
Chunk 9: 'eatur'
...
```
Mit differenziertem Streaming (3 Sekunden Verzögerung):
```
Chunk 1: '{"query": "TypeScript 5.0 5.1 5.2 5.3'
Chunk 2: ' new features comparison'
```
**Anmerkung**
Da beim differenzierten Streaming Parameter ohne Pufferung oder JSON-Validierung gesendet werden, gibt es keine Garantie dafür, dass der resultierende Stream in einer gültigen JSON-Zeichenfolge abgeschlossen wird. Insbesondere wenn der Stopp-Grund `max_tokens` erreicht ist, kann es sein, dass der Stream nach der Hälfte eines Parameters endet und unvollständig ist. In der Regel müssen Sie spezielle Support-Programme schreiben, um zu regeln, was passiert, wenn der Wert erreicht `max_tokens` ist.
## Computer Use (Beta)
Computer Use ist eine Funktion des Anthropic-Claude-Modells (in der Betaversion), die mit Claude 3.5 Sonnet v2, Claude Sonnet 4.5, Claude Haiku 4.5, Claude 3.7 Sonnet, Claude Sonnet 4 und Claude Opus 4 verfügbar ist. Mithilfe von Computer Use kann Claude Aufgaben durch grundlegende GUI-Aktionen automatisieren.
**Warnung**
Die Funktion zur Computernutzung wird Ihnen als „Beta-Service“ gemäß der Definition in den AWS Servicebedingungen zur Verfügung gestellt. Sie unterliegt Ihrer Vereinbarung mit AWS und den AWS Servicebedingungen sowie der geltenden Muster-EULA. Bitte beachten Sie, dass die Computer-Use-API besondere Risiken birgt, die sich von Standard-API-Features oder Chat-Schnittstellen unterscheiden. Diese Risiken steigen, wenn die Computer-Use-API für die Interaktion mit dem Internet verwendet wird. Zur Minimierung der Risiken sollten Sie folgende Vorsichtsmaßnahmen in Betracht ziehen:
Betreiben Sie das Computer-Use-Feature in einer speziellen virtuellen Maschine oder in einem Container mit minimalen Rechten, um gezielte oder versehentliche Angriffe auf das System zu verhindern.
Zur Verhinderung von Informationsdiebstahl sollten Sie der Computer-Use-API keinen Zugriff auf sensible Konten oder Daten gewähren.
Beschränkung des APIs Internetzugangs zur Computernutzung auf die erforderlichen Domänen, um das Risiko bösartiger Inhalte zu verringern.
Um eine adäquate Aufsicht zu gewährleisten, sollte bei sensiblen Aufgaben (wie Entscheidungen, die erhebliche Auswirkungen auf die reale Welt haben könnten) sowie Aufgaben, die eine ausdrückliche Zustimmung erfordern (wie die Annahme von Cookies, die Ausführung von Finanztransaktionen oder die Zustimmung zu Nutzungsbedingungen), ein HITL einbezogen werden.
Alle Inhalte, für die Sie Claude Anzeige- oder Zugriffsberechtigungen erteilen, können möglicherweise Anweisungen außer Kraft setzen oder Claude zu Fehlern oder unbeabsichtigten Aktionen verleiten. Daher ist es wichtig, angemessene Vorsichtsmaßnahmen zu treffen und Claude z. B. von sensiblen Oberflächen fernzuhalten, auch zur Vermeidung von Risiken im Zusammenhang mit einer Promptinjektion. Bevor Sie die Computer-Use-Features in eigenen Produkten aktivieren oder die erforderlichen Genehmigungen anfordern, informieren Sie die Endbenutzer bitte über alle einschlägigen Risiken und holen Sie gegebenenfalls deren Zustimmung ein.
Die Computer-Use-API bietet mehrere vordefinierte Computer-Use-Tools, die Sie verwenden können. Sie können dann einen Prompt mit Ihrer Anfrage erstellen, z. B. „Sende Ben eine E-Mail mit den Notizen von meinem letzten Treffen“ und einen Screenshot (falls erforderlich). Die Antwort enthält eine Liste von `tool_use`-Aktionen im JSON-Format (z. B. scroll\$1down, left\$1button\$1press, screenshot). Ihr Code führt die Computeraktionen aus und stellt Claude einen Screenshot zur Verfügung, der die Ausgaben zeigt (falls angefordert).
Seit Veröffentlichung von Claude 3.5 v2 wurde der Parameter „tools“ aktualisiert und akzeptiert nun polymorphe Tooltypen. Zu ihrer Unterscheidung wurde eine neue `tool.type`-Eigenschaft hinzugefügt. Der Parameter `type` ist optional. Wenn er weggelassen wird, wird davon ausgegangen, dass es sich bei dem Tool um ein benutzerdefiniertes Tool handelt (bisher der einzige unterstützte Tooltyp). Für den Zugriff auf Computer-Use-Feature müssen Sie den `anthropic_beta`-Parameter mit einer entsprechenden Aufzählung verwenden, deren Wert von der verwendeten Modellversion abhängt. Weitere Informationen können Sie der folgenden Tabelle entnehmen.
Nur Anfragen, die mit diesem Parameter und enum gestellt wurden, können die Computer-Use-Tools verwenden. Er kann wie folgt angegeben werden: `"anthropic_beta": ["computer-use-2025-01-24"]`.
| Modell | Beta-Header |
| --- | --- |
| Claude Opus4.5 Claude Opus4.1 Claude Opus 4 Claude Sonnet 4.5 Claude Haiku 4.5 Claude Sonnet 4 Claude 3.7 Sonnet | computer-use-2025-01-24 |
| Claude 3.5 Sonnet v2 | computer-use-2024-10-22 |
Weitere Informationen finden Sie unter [Computer Use (Beta)](https://docs.anthropic.com/en/docs/build-with-claude/computer-use) in der Anthropic-Dokumentation.
Im Folgenden finden Sie ein Antwortbeispiel, bei dem davon ausgegangen wird, dass die Anfrage einen Screenshot Ihres Desktops mit einem Firefox-Symbol enthielt.
```
{
"id": "msg_123",
"type": "message",
"role": "assistant",
"model": "anthropic.claude-3-5-sonnet-20241022-v2:0",
"content": [
{
"type": "text",
"text": "I see the Firefox icon. Let me click on it and then navigate to a weather website."
},
{
"type": "tool_use",
"id": "toolu_123",
"name": "computer",
"input": {
"action": "mouse_move",
"coordinate": [
708,
736
]
}
},
{
"type": "tool_use",
"id": "toolu_234",
"name": "computer",
"input": {
"action": "left_click"
}
}
],
"stop_reason": "tool_use",
"stop_sequence": null,
"usage": {
"input_tokens": 3391,
"output_tokens": 132
}
}
```
## Anthropic-definierte Tools
Anthropic bietet eine Reihe von Tools, mit denen bestimmte Claude-Modelle Computer effektiv nutzen können. Bei der Angabe eines Anthropic-definierten Tools sind die Felder `description` und `tool_schema` nicht erforderlich oder zulässig. Anthropic-definierte Tools werden durch Anthropic definiert. Sie müssen die Ergebnisse des Tools jedoch explizit auswerten und `tool_results` an Claude zurückgeben. Wie bei jedem Tool führt das Modell das Tool nicht automatisch aus. Jedes Anthropic-definierte Tool hat Versionen, die für bestimmte Modelle Claude 3.5 Sonnet (neu) und Claude 3.7 Sonnet optimiert sind:
| Modell | Tool | Hinweise |
| --- | --- | --- |
| ClaudeClaude Opus4.1 ClaudeClaude Opus4 Claude Sonnet 4.5 Claude Haiku 4.5 Claude Sonnet 4 | {
"type": "text_editor_20250124",
"name": "str_replace_based_edit_tool"
} | Aktualisierung des bestehenden Tools `str_replace_editor` |
| Claude 3.7 Sonnet | {
"type": "computer_20250124",
"name": "computer"
} | Beinhaltet neue Aktionen für eine genauere Steuerung |
| Claude 3.7 Sonnet | {
"type": "text_editor_20250124",
"name": "str_replace_editor"
} | Gleiche Funktionen wie in der Version 20241022 |
| Claude 3.5 Sonnet v2 | {
"type": "bash_20250124",
"name": "bash"
} | Gleiche Funktionen wie in der Version 20241022 |
| Claude 3.5 Sonnet v2 | {
"type": "text_editor_20241022",
"name": "str_replace_editor"
} |
| Claude 3.5 Sonnet v2 | {
"type": "bash_20241022",
"name": "bash"
} |
| Claude 3.5 Sonnet v2 | {
"type": "computer_20241022",
"name": "computer"
} |
Das Feld `type` identifiziert das Tools und seine Parameter zu Validierungszwecken. Das Feld `name` ist der Tool-Name, der dem Modell zur Verfügung gestellt wird.
Wenn Sie das Modell auffordern möchten, eines dieser Tools zu verwenden, können Sie das Tool explizit anhand des Felds `name` referenzieren. Das Feld `name` muss innerhalb der Tool-Liste eindeutig sein. Sie können ein Tool nicht mit demselben `name` definieren wie ein Anthropic-definiertes Tool in demselben API-Aufruf.
## Automatisches Löschen von Tool-Aufrufen (Beta)
**Warnung**
Das automatische Löschen von Tool-Aufrufen wird als „Beta-Service“ gemäß der Definition in den AWS Servicebedingungen zur Verfügung gestellt.
**Anmerkung**
Diese Funktion wird derzeit von Claude Sonnet 4/4.5, Claude Haiku 4.5 und Claude Opus 4/4.1/4.5 unterstützt.
Das automatische Löschen von Werkzeugaufrufen ist eine Funktion des Modells Anthropic Claude (in der Beta-Phase). Mit dieser Funktion kann Claude alte Ergebnisse der Werkzeugnutzung automatisch löschen, wenn Sie sich den Token-Grenzwerten nähern, was ein effizienteres Kontextmanagement in Szenarien mit mehreren Werkzeugeinsätzen ermöglicht. Wenn Sie das Löschen von Tool-Aufrufen nutzen möchten, müssen Sie dem Anforderungsparameter anthropic\$1beta in der Liste der Beta-Header `context-management-2025-06-27` hinzufügen. Sie müssen außerdem die Verwendung von angeben `clear_tool_uses_20250919` und aus den folgenden Konfigurationsoptionen auswählen.
Dies sind die verfügbaren Steuerelemente für die Kontextmanagement-Strategie von `clear_tool_uses_20250919`. Alle sind optional oder haben Standardwerte:
| **Konfigurationsoption** | **Beschreibung** |
| --- | --- |
| `trigger` Standard: 100 000 Eingabe-Token | Definiert, wann die Strategie zur Kontextbearbeitung aktiviert wird. Sobald der Prompt diesen Schwellenwert überschreitet, beginnt der Löschvorgang. Sie können diesen Wert entweder in input\$1tokens oder tool\$1uses angeben. |
| `keep` Standard: 3 Tool-Anwendungen | Definiert, wie viele aktuelle use/result Werkzeugpaare nach dem Löschen beibehalten werden sollen. Die API entfernt zuerst die ältesten Tool-Interaktionen, wobei die neuesten beibehalten werden. Dies ist hilfreich, wenn das Modell Zugriff auf die letzten Tool-Interaktionen benötigt, um die Konversation effektiv fortzusetzen. |
| `clear_at_least` (optional) | Dadurch wird sichergestellt, dass bei jeder Aktivierung der Strategie eine Mindestanzahl an Token gelöscht wird. Wenn die API nicht mindestens die angegebene Menge löschen kann, wird die Strategie nicht angewendet. Dies ist nützlich, um festzustellen, ob es sich lohnt, den Prompt-Cache für das Löschen von Kontexten zu unterbrechen. |
| `exclude_tools` (optional) | Liste der Tool-Namen, deren Tool-Anwendungen und Ergebnisse niemals gelöscht werden sollten. Dies ist nützlich, um wichtigen Kontext zu bewahren. |
| `clear_tool_inputs`: (optional, Standard falsch) | Steuert, ob die Tool-Aufruf-Parameter zusammen mit den Tool-Ergebnissen gelöscht werden. Standardmäßig werden nur die Tool-Ergebnisse gelöscht, wobei die ursprünglichen Tool-Aufrufe von Claude sichtbar bleiben, sodass Claude auch nach dem Entfernen der Ergebnisse sehen kann, welche Operationen ausgeführt wurden. |
**Anmerkung**
Durch das Löschen von Tools wird Ihr Cache ungültig, wenn Ihre Präfixe Ihre Tools enthalten.
------
#### [ Request ]
```
response = client.beta.messages.create(
betas=["context-management-2025-06-27"],
model="claude-sonnet-4-20250514",
max_tokens=4096,
messages=[
{
"role": "user",
"content": "Create a simple command line calculator app using Python"
}
],
tools=[
{
"type": "text_editor_20250728",
"name": "str_replace_based_edit_tool",
"max_characters": 10000
},
{
"type": "web_search_20250305",
"name": "web_search",
"max_uses": 3
}
],
extra_body={
"context_management": {
"edits": [
{
"type": "clear_tool_uses_20250919",
# The below parameters are OPTIONAL:
# Trigger clearing when threshold is exceeded
"trigger": {
"type": "input_tokens",
"value": 30000
},
# Number of tool uses to keep after clearing
"keep": {
"type": "tool_uses",
"value": 3
},
# Optional: Clear at least this many tokens
"clear_at_least": {
"type": "input_tokens",
"value": 5000
},
# Exclude these tools uses from being cleared
"exclude_tools": ["web_search"]
}
]
}
}
)
```
------
#### [ Response ]
```
{
"id": "msg_123",
"type": "message",
"role": "assistant",
"content": [
{
"type": "tool_use",
"id": "toolu_456",
"name": "data_analyzer",
"input": {
"data": "sample data"
}
}
],
"context_management": {
"applied_edits": [
{
"type": "clear_tool_uses_20250919",
"cleared_tool_uses": 8, # Number of tool use/result pairs that were cleared
"cleared_input_tokens": 50000 # Total number of input tokens removed from the prompt
}
]
}
"stop_reason": "tool_use",
"usage": {
"input_tokens": 150,
"output_tokens": 50
}
}
```
------
#### [ Streaming Response ]
```
data: {"type": "message_start", "message": {"id": "msg_123", "type": "message", "role": "assistant"}}
data: {"type": "content_block_start", "index": 0, "content_block": {"type": "tool_use", "id": "toolu_456", "name": "data_analyzer", "input": {}}}
data: {"type": "content_block_delta", "index": 0, "delta": {"type": "input_json_delta", "partial_json": "{\"data\": \"sample"}}
data: {"type": "content_block_delta", "index": 0, "delta": {"type": "input_json_delta", "partial_json": " data\"}"}}
data: {"type": "content_block_stop", "index": 0}
data: {"type": "message_delta", "delta": {"stop_reason": "tool_use"}}
data: {"type": "message_stop"}
{
"type": "message_delta",
"delta": {
"stop_reason": "end_turn",
"stop_sequence": null,
},
"usage": {
"output_tokens": 1024
},
"context_management": {
"applied_edits": [...],
}
}
```
------
**Anmerkung**
Bedrock unterstützt derzeit kein `clear_tool_uses_20250919` Kontextmanagement auf der CountTokens API.
## Speicher-Tool (Beta)
**Warnung**
Memory Tool wird als „Beta-Service“ gemäß der Definition in den AWS Servicebedingungen zur Verfügung gestellt.
Claude Sonnet 4.5 umfasst ein neues Speicher-Tool, das Kunden die Möglichkeit bietet, den Speicher für alle Konversationen zu verwalten. Mit diesem Feature können Kunden Claude ermöglichen, Informationen außerhalb des Kontextfensters abzurufen, indem sie Zugriff auf ein lokales Verzeichnis gewähren. Dieses Feature wird als Beta-Feature verfügbar sein. Wenn Sie dieses Feature nutzen möchten, müssen Sie den Beta-Header `context-management-2025-06-27` verwenden.
Tool-Definition:
```
{
"type": "memory_20250818",
"name": "memory"
}
```
Beispielanforderung:
```
{
"max_tokens": 2048,
"anthropic_version": "bedrock-2023-05-31",
"anthropic_beta": ["context-management-2025-06-27"],
"tools": [{
"type": "memory_20250818",
"name": "memory"
}],
"messages": [
{
"role": "user",
"content": [{"type": "text", "text": "Remember that my favorite color is blue and I work at Amazon?"}]
}
]
}
```
Beispielantwort:
```
{
"id": "msg_vrtx_014mQ5ficCRB6PEa5k5sKqHd",
"type": "message",
"role": "assistant",
"model": "claude-sonnet-4-20250514",
"content": [
{
"type": "text",
"text": "I'll start by checking your memory directory and then record this important information about you."
},
{
"type": "tool_use",
"id": "toolu_vrtx_01EU1UrCDigyPMRntr3VYvUB",
"name": "memory",
"input": {
"command": "view",
"path": "/memories"
}
}
],
"stop_reason": "tool_use",
"stop_sequence": null,
"usage": {
"input_tokens": 1403,
"cache_creation_input_tokens": 0,
"cache_read_input_tokens": 0,
"output_tokens": 87
},
"context_management": {
"applied_edits": []
}
}
```
## Überlegungen zu den Kosten bei der Tool-Nutzung
Die Preise für Anfragen zur Nutzung von Tools basieren auf folgenden Faktoren:
1. Die Gesamtzahl der an das Modell gesendeten Eingabe-Token (einschließlich des Parameters tools)
1. Die Anzahl der generierten Ausgabe-Token
Tools haben denselben Preis wie alle anderen Claude-API-Anfragen, enthalten jedoch zusätzliche Token pro Anfrage. Die zusätzlichen Token, die sich aus der Nutzung des Tools ergeben, stammen aus den folgenden Quellen:
+ Parameter `tools` in den API-Anfragen. Zum Beispiel Tool-Namen, Beschreibungen und Schemas.
+ Alle `tool_use`-Inhaltsblöcke in API-Anfragen und -Antworten.
+ Alle `tool_result`-Inhaltsblöcke in API-Anfragen.
Wenn Sie Tools nutzen, enthalten die Anthropic-Modelle automatisch einen speziellen System-Prompt, der die Verwendung von Tools ermöglicht. Die Anzahl der für jedes Modell erforderlichen Tool-Nutzungstoken ist in der folgenden Tabelle aufgeführt. In dieser Tabelle sind die zuvor beschriebenen zusätzlichen Token nicht enthalten. Beachten Sie, dass in dieser Tabelle davon ausgegangen wird, dass mindestens ein Tool bereitgestellt wird. Wenn keine Tools bereitgestellt werden, werden bei der Toolauswahl „Keine“ 0 zusätzliche System-Prompt-Token verwendet.
| Modell | Auswahl des Tools | Anzahl der System-Prompt-Token für die Tool-Nutzung |
| --- | --- | --- |
| Claude Opus4.5 Claude Opus4.1 Claude Opus 4 Claude Sonnet 4.5 Claude Haiku 4.5 Claude Sonnet 4 Claude 3.7 Sonnet Claude 3.5 Sonnet v2 | auto oder none | 346 |
| Claude Opus4,5 Claude Opus4.1 Claude Opus 4 Claude Sonnet 4.5 Claude Haiku 4.5 Claude Sonnet 4 Claude 3.7 Sonnet Claude 3.5 Sonnet v2 | any oder tool | 313 |
| Claude 3.5 Sonnet | auto oder none | 294 |
| Claude 3.5 Sonnet | any oder tool | 261 |
| Claude 3 Opus | auto oder none | 530 |
| Claude 3 Opus | any oder tool | 281 |
| Claude 3 Sonnet | auto oder none | 159 |
| Claude 3 Sonnet | any oder tool | 235 |
| Claude 3 Haiku | auto oder none | 264 |
| Claude 3 Haiku | any oder tool | 340 |
## Tool zur Werkzeugsuche (Beta)
Das Tool Search Tool ermöglicht Claude die Arbeit mit Hunderten oder sogar Tausenden von Tools, ohne dass alle ihre Definitionen im Voraus in das Kontextfenster geladen werden müssen. Anstatt alle Tools sofort zu deklarieren, können Sie sie mit `defer_loading: true` markieren und über den Claude Werkzeugsuchmechanismus nur die Tools finden und laden, die Sie benötigen.
Um auf diese Funktion zugreifen zu können, müssen Sie den Beta-Header `tool-search-tool-2025-10-19` verwenden. Beachten Sie, dass diese Funktion derzeit nur über [InvokeModel](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModel.html)und verfügbar ist [InvokeModelWithResponseStream](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModelWithResponseStream.html) APIs.
Tool-Definition:
```
{
"type": "tool_search_tool_regex",
"name": "tool_search_tool_regex"
}
```
Anfragebeispiel:
```
{
"anthropic_version": "bedrock-2023-05-31",
"anthropic_beta": [
"tool-search-tool-2025-10-19"
],
"max_tokens": 4096,
"tools": [{
"type": "tool_search_tool_regex",
"name": "tool_search_tool_regex"
},
{
"name": "get_weather",
"description": "Get current weather for a location",
"input_schema": {
"type": "object",
"properties": {
"location": {
"type": "string"
},
"unit": {
"type": "string",
"enum": ["celsius", "fahrenheit"]
}
},
"required": ["location"]
},
"defer_loading": true
},
{
"name": "search_files",
"description": "Search through files in the workspace",
"input_schema": {
"type": "object",
"properties": {
"query": {
"type": "string"
},
"file_types": {
"type": "array",
"items": {
"type": "string"
}
}
},
"required": ["query"]
},
"defer_loading": true
}
],
"messages": [{
"role": "user",
"content": "What's the weather in Seattle?"
}]
}
```
Beispiel für eine Antwort
```
{
"role": "assistant",
"content": [{
"type": "text",
"text": "I'll search for the appropriate tools to help with this task."
},
{
"type": "server_tool_use",
"id": "srvtoolu_01ABC123",
"name": "tool_search_tool_regex",
"input": {
"pattern": "weather"
}
},
{
"type": "tool_search_tool_result",
"tool_use_id": "srvtoolu_01ABC123",
"content": {
"type": "tool_search_tool_search_result",
"tool_references": [{
"type": "tool_reference",
"tool_name": "get_weather"
}]
}
},
{
"type": "text",
"text": "Now I can check the weather."
},
{
"type": "tool_use",
"id": "toolu_01XYZ789",
"name": "get_weather",
"input": {
"location": "Seattle",
"unit": "fahrenheit"
}
}
],
"stop_reason": "tool_use"
}
```
Beispiel für ein Streaming
```
# Event 1: content_block_start(with complete server_tool_use block) {
"type": "content_block_start",
"index": 0,
"content_block": {
"type": "server_tool_use",
"id": "srvtoolu_01ABC123",
"name": "tool_search_tool_regex"
}
}
# Event 2: content_block_delta(input JSON streamed) {
"type": "content_block_delta",
"index": 0,
"delta": {
"type": "input_json_delta",
"partial_json": "{\"regex\": \".*weather.*\"}"
}
}
# Event 3: content_block_stop(tool_use complete) {
"type": "content_block_stop",
"index": 0
}
# Event 4: content_block_start(COMPLETE result in single chunk) {
"type": "content_block_start",
"index": 1,
"content_block": {
"type": "tool_search_tool_result",
"tool_use_id": "srvtoolu_01ABC123",
"content": {
"type": "tool_search_tool_search_result",
"tool_references": [{
"type": "tool_reference",
"tool_name": "get_weather"
}]
}
}
}
# Event 5: content_block_stop(result complete) {
"type": "content_block_stop",
"index": 1
}
```
**Suchwerkzeuge für benutzerdefinierte Tools**
Sie können benutzerdefinierte Tools für die Werkzeugsuche implementieren (z. B. mithilfe von Einbettungen), indem Sie ein Tool definieren, das Blöcke zurückgibt`tool_reference`. Das benutzerdefinierte Tool muss dies haben, `defer_loading: false` während andere Tools dies tun sollten. `defer_loading: true` Wenn Sie Ihr eigenes Tool für die Werkzeugsuche definieren, sollte es ein Werkzeugergebnis mit `tool_reference` Inhaltsblöcken zurückgeben, die auf die Tools verweisen, die Sie verwenden Claude möchten.
Das erwartete, vom Kunden definierte Antwortformat für das Ergebnis des Tool Search Tools:
```
{
"type": "tool_result",
"tool_use_id": "toolu_01ABC123",
"content": [{
"type": "tool_reference",
"tool_name": "get_weather"
},
{
"type": "tool_reference",
"tool_name": "weather_forecast"
}
]
}
```
Das `tool_name` muss mit einem in der Anfrage definierten Tool übereinstimmen. `defer_loading: true` Claude hat dann Zugriff auf die vollständigen Schemas dieser Tools.
**Benutzerdefinierte Suchwerkzeuge — Detailliertes Beispiel**
Sie können benutzerdefinierte Tools zur Werkzeugsuche implementieren (z. B. mithilfe von Einbettungen oder semantischer Suche), indem Sie ein Tool definieren, das Blöcke zurückgibt. `tool_reference` Dies ermöglicht ausgeklügelte Mechanismen zur Werkzeugerkennung, die über den Regex-Abgleich hinausgehen.
Beispiel mit benutzerdefiniertem TST anfordern:
```
{
"model": "claude-sonnet-4-5-20250929",
"anthropic_version": "bedrock-2023-05-31",
"anthropic_beta": ["tool-search-tool-2025-10-19"],
"max_tokens": 4096,
"tools": [{
"name": "semantic_tool_search",
"description": "Search for available tools using semantic similarity. Returns the most relevant tools for the given query.",
"input_schema": {
"type": "object",
"properties": {
"query": {
"type": "string",
"description": "Natural language description of what kind of tool is needed"
},
"top_k": {
"type": "integer",
"description": "Number of tools to return (default: 5)"
}
},
"required": ["query"]
},
"defer_loading": false
},
{
"name": "get_weather",
"description": "Get current weather for a location",
"input_schema": {
"type": "object",
"properties": {
"location": {
"type": "string"
},
"unit": {
"type": "string",
"enum": ["celsius", "fahrenheit"]
}
},
"required": ["location"]
},
"defer_loading": true
},
{
"name": "search_flights",
"description": "Search for available flights between locations",
"input_schema": {
"type": "object",
"properties": {
"origin": {
"type": "string"
},
"destination": {
"type": "string"
},
"date": {
"type": "string"
}
},
"required": ["origin", "destination", "date"]
},
"defer_loading": true
}
],
"messages": [{
"role": "user",
"content": "What's the weather forecast in Seattle for the next 3 days?"
}]
}
```
ClaudeAntwort (Aufruf von benutzerdefiniertem TST):
```
{
"role": "assistant",
"content": [{
"type": "text",
"text": "I'll search for the appropriate tools to help with weather information."
},
{
"type": "tool_use",
"id": "toolu_01ABC123",
"name": "semantic_tool_search",
"input": {
"query": "weather forecast multiple days",
"top_k": 3
}
}
],
"stop_reason": "tool_use"
}
```
**Vom Kunden bereitgestelltes Werkzeugergebnis**
Nach der Durchführung einer semantischen Suche in der Werkzeugbibliothek gibt der Kunde passende Werkzeugreferenzen zurück:
```
{
"role": "user",
"content": [{
"type": "tool_search_tool_result",
"tool_use_id": "toolu_01ABC123",
"content": {
"type": "tool_search_tool_search_result",
"tool_references": [{
"type": "tool_reference",
"tool_name": "get_weather"
}]
}
}]
}
```
ClaudeNachverfolgung (unter Verwendung des entdeckten Tools)
```
{
"role": "assistant",
"content": [{
"type": "text",
"text": "I found the forecast tool. Let me get the weather forecast for Seattle."
},
{
"type": "tool_use",
"id": "toolu_01DEF456",
"name": "get_weather",
"input": {
"location": "Seattle, WA"
}
}
],
"stop_reason": "tool_use"
}
```
**Fehlerbehandlung**
+ Die Einstellung `defer_loading: true` für alle Tools (einschließlich des Tool Search Tools) führt zu einem 400-Fehler.
+ Die Übergabe von a `tool_reference` ohne entsprechende Werkzeugdefinition führt zu einem 400-Fehler
## Beispiele für die Verwendung von Tools (Beta)
Claude Opus4.5 unterstützt vom Benutzer bereitgestellte Beispiele in Werkzeugdefinitionen, um die Leistung Claude der Werkzeugnutzung zu erhöhen. Sie können Beispiele als vollständige Funktionsaufrufe bereitstellen, die genau so formatiert sind, wie es bei echten LLM-Ausgaben der Fall wäre, ohne dass eine Übersetzung in ein anderes Format erforderlich ist. Um diese Funktion nutzen zu können, müssen Sie den Beta-Header übergeben. `tool-examples-2025-10-29`
Beispiel für eine Werkzeugdefinition:
```
{
"name": "get_weather",
"description": "Get the current weather in a given location",
"input_schema": {
"type": "object",
"properties": {
"location": {
"type": "string",
"description": "The city and state, e.g. San Francisco, CA"
},
"unit": {
"type": "string",
"enum": ["celsius", "fahrenheit"],
"description": "Temperature unit"
}
},
"required": ["location"]
},
"input_examples": [{
"location": "San Francisco, CA",
"unit": "fahrenheit"
},
{
"location": "Tokyo, Japan",
"unit": "celsius"
},
{
"location": "New York, NY"
}
]
}
```
**Regeln für die Validierung**
+ Schemakonformität: Jedes Beispiel in `input_examples` muss gemäß den Angaben des `input_schema` Tools gültig sein.
+ Erforderliche Felder müssen in mindestens einem Beispiel vorhanden sein.
+ Feldtypen müssen dem Schema entsprechen.
+ Aufzählungswerte müssen aus dem zulässigen Satz stammen.
+ Wenn die Überprüfung fehlschlägt, geben Sie einen 400-Fehler mit Details darüber zurück, in welchem Beispiel die Überprüfung fehlgeschlagen ist.
+ Array-Anforderungen: `input_examples` muss ein Array sein (kann leer sein).
+ Ein leeres Array `[]` ist gültig und entspricht dem Auslassen des Felds.
+ Ein einzelnes Beispiel muss immer noch in ein Array eingeschlossen werden: `[{...}]`
+ Längenbeschränkung: Beginnen Sie mit einem Limit von 20 Beispielen pro Werkzeugdefinition.
Beispiele für Fehler:
```
// Invalid: Example doesn't match schema (missing required field)
{
"type": "invalid_request_error",
"message": "Tool 'get_weather' input_examples[0] is invalid: Missing required property 'location'"
}
// Invalid: Example has wrong type for field
{
"type": "invalid_request_error",
"message": "Tool 'search_products' input_examples[1] is invalid: Property 'filters.price_range.min' must be a number, got string"
}
// Invalid: input_examples on server-side tool
{
"type": "invalid_request_error",
"message": "input_examples is not supported for server-side tool"
}
```
# Erweitertes Denken
Erweitertes Denken ermöglicht Claude bessere Argumentationsfähigkeiten für komplexe Aufgaben und sorgt gleichzeitig für ein unterschiedliches Maß an Transparenz in Bezug auf den step-by-step Denkprozess, bevor eine endgültige Antwort gefunden wird. Wenn Sie den Denkmodus von Claude aktivieren, müssen Sie ein Budget für die maximale Anzahl von Token festlegen, die für den internen Argumentationsprozess von Claude verwenden werden dürfen.
Es werde folgende Modelle unterstützt:
| Modell | Modell-ID |
| --- | --- |
| Claude Opus4.5 | `anthropic.claude-opus-4-5-20251101-v1:0` |
| Claude Opus 4 | `anthropic.claude-opus-4-20250514-v1:0` |
| Claude Sonnet 4 | `anthropic.claude-sonnet-4-20250514-v1:0` |
| Claude Sonnet 4.5 | `anthropic.claude-sonnet-4-5-20250929-v1:0` |
| Claude Haiku 4.5 | `anthropic.claude-haiku-4-5-20251001-v1:0` |
| Claude 3.7 Sonnet | `anthropic.claude-3-7-sonnet-20250219-v1:0` |
| Claude Sonnet 4.5 | `anthropic.claude-opus-4-5-20251101-v1:0` |
**Anmerkung**
Das API-Verhalten der Modelle Claude 3.7 und Claude 4 unterscheidet sich. Weitere Informationen finden Sie unter [Unterschiede im Denken zwischen den Modellversionen](claude-messages-thinking-differences.md).
**Topics**
+ [Best Practices und Überlegungen für erweitertes Denken](#claude-messages-extended-thinking-bps)
+ [So funktioniert erweitertes Denken](#claude-messages-how-extended-thinking-works)
+ [Verwenden von erweitertem Denken](#claude-messages-use-extended-thinking)
+ [Erweitertes Denken mit der Verwendung des Tools](#claude-messages-extended-thinking-tool-use)
+ [Denken Sie an Block-Clearing (Beta)](#claude-messages-thinking-block-clearing)
+ [Erweitertes Denken mit Prompt-Caching](#claude-messages-extended-thinking-prompt-caching)
+ [Grundlagen zum Caching-Verhalten von Denkblöcken](#claude-messages-extended-thinking-caching-behavior)
+ [Maximale Anzahl an Token und Größe des Kontextfensters bei erweitertem Denken](#claude-messages-extended-thinking-max-tokens)
+ [Überlegungen zu den Kosten des erweiterten Denkens](#claude-messages-extended-thinking-cost)
## Best Practices und Überlegungen für erweitertes Denken
Richtlinien für die Verwendung
+ **Aufgabenauswahl**: Verwenden Sie erweitertes Denken für besonders komplexe Aufgaben, bei denen logisches step-by-step Denken von Vorteil ist, wie Mathematik, Programmieren und Analysieren.
+ **Umgang mit Kontext**: Sie müssen alte Denkblöcke nicht selbst entfernen. Die Anthropic-API ignoriert Denkblöcke aus früheren Runden automatisch, sodass sie bei der Berechnung der Kontextnutzung nicht berücksichtigt werden.
+ **Prompt-Engineering**: Lesen Sie die [Prompting-Tipps für erweitertes Denken](https://docs.anthropic.com/en/docs/build-with-claude/prompt-engineering/extended-thinking-tips) von Anthropic, wenn Sie die Leistungsfähigkeit von Claude maximieren möchten.
Leistungsaspekte
+ **Reaktionszeiten**: Seien Sie auf potenziell längere Antwortzeiten vorbereitet, da der Argumentationsprozess eine zusätzliche Bearbeitung erfordert. Berücksichtigen Sie, dass das Generieren von Denkblöcken die Gesamtreaktionszeit verlängern kann.
+ **Streaming-Anfragen**: Streaming ist erforderlich, wenn der Wert für `max_tokens` über 21.333 liegt. Seien Sie beim Streamen auf eingehende Inhaltsblöcke vom Typ `thinking` und `text` vorbereitetet.
Feature-Kompatibilität
+ Erweitertes Denken ist nicht kompatibel mit Änderungen der Parameter `temperature`, `top_p` oder `top_k` bzw. der [erzwungenen Verwendung des Tools](https://docs.anthropic.com/en/docs/agents-and-tools/tool-use/implement-tool-use#forcing-tool-use).
+ Wenn erweitertes Denken aktiviert ist, können Antworten nicht vorab ausgefüllt werden.
+ Änderungen am Budget für erweitertes Denken führen dazu, dass zwischengespeicherte Präfixe für Prompts, die Nachrichten enthalten, ungültig werden. Zwischengespeicherte System-Prompts und Tooldefinitionen funktionieren jedoch weiterhin, wenn sich die Denkparameter ändern.
Arbeiten mit Budgets für erweitertes Denken
+ **Budgetoptimierungen**: Das Mindestbudget beträgt 1.024 Token. Anthropic schlägt vor, mit dem Minimum zu beginnen und das Denkbudget schrittweise zu erhöhen, um den optimalen Bereich für Ihren Anwendungsfall zu finden. Eine größere Anzahl von Token ermöglicht vielleicht eine umfassendere und nuanciertere Argumentation, je nach Aufgabe kann dies aber auch die Ergebnisse beeinträchtigen. Das Budget ist eher ein Ziel als ein striktes Limit. Die tatsächliche Tokennutzung kann je nach Aufgabe variieren.
+ **Minimale und optimale Einstellungen**: Das Mindestbudget beträgt 1.024 Token. Wir empfehlen, mit dem Minimum zu beginnen und das Denkbudget schrittweise zu erhöhen, um den optimalen Bereich zu finden, in dem Claude eine gute Leistung für Ihren Anwendungsfall erbringen kann. Eine höhere Anzahl von Token ermöglicht vielleicht eine umfassendere und nuanciertere Argumentation, je nach Aufgabe kann dies aber auch die Ergebnisse beeinträchtigen. Das Budget ist eher ein Ziel als ein striktes Limit. Die tatsächliche Tokennutzung kann je nach Aufgabe variieren.
+ **Experimentieren**: Das Modell kann bei unterschiedlichen Einstellungen für das maximale Denkbudget unterschiedlich abschneiden. Eine Erhöhung des maximalen Budgets für erweitertes Denken kann dazu führen, dass das Modell besser oder schärfer denkt, was allerdings mit einer erhöhten Latenz einhergeht. Bei kritischen Aufgaben sollten Sie erwägen, verschiedene Budgeteinstellungen zu testen, um das optimale Gleichgewicht zwischen Qualität und Leistung zu finden.
+ **Große Budgets**: Bei Budgets über 32 000 Token empfehlen wir die Stapelverarbeitung, um Netzwerkprobleme zu vermeiden. Anfragen, die das Modell dazu drängen, beim Denken die Schwelle von 32 000 Token zu überschreiten, führen zu lang andauernden Anfragen, die zu System-Timeouts und offenen Verbindungslimits führen können. Beachten Sie, dass die Grenzwerte für `max_tokens` je nach Claude-Modell variieren. Weitere Informationen finden Sie unter [Maximale Anzahl an Token und Größe des Kontextfensters bei erweitertem Denken](#claude-messages-extended-thinking-max-tokens).
+ **Nachverfolgung der Tokennutzung**: Überwachen Sie die Nutzung von Token für erweitertes Denken, um Kosten und Leistung zu optimieren.
## So funktioniert erweitertes Denken
Wenn erweitertes Denken aktiviert ist, erstellt Claude `thinking`-Inhaltsblöcke mit interner Argumentation. Claude bezieht Erkenntnisse aus dieser Argumentation mit ein, bevor eine endgültige Antwort verfasst wird. Die API-Antwort wird `thinking`-Inhaltsblöcke enthalten, an die sich `text`-Inhaltsblöcke anschließen.
Das Folgende ist ein Beispiel für das Standardantwortformat:
```
{
"content": [
{
"type": "thinking",
"thinking": "Let me analyze this step by step...",
"signature": "WaUjzkypQ2mUEVM36O2TxuC06KN8xyfbJwyem2dw3URve/op91XWHOEBLLqIOMfFG/UvLEczmEsUjavL...."
},
{
"type": "text",
"text": "Based on my analysis..."
}
]
}
```
Weitere Informationen zum Antwortformat des erweiterten Denkens finden Sie in der Messages API [Anforderung und Antwort](model-parameters-anthropic-claude-messages-request-response.md) von Anthropic.
## Verwenden von erweitertem Denken
Um erweitertes Denken zu aktivieren, fügen Sie ein `thinking`-Objekt hinzu und setzen Sie den Parameter `thinking` auf „aktiviert“ und den Parameter `budget_tokens` auf ein bestimmtes Tokenbudget für erweitertes Denken.
Der Parameter `budget_tokens` bestimmt die maximale Anzahl von Token, die in Claude für den internen Argumentationsprozess verwendet werden dürfen. In Claude-4-Modellen gilt dieser Grenzwert für Token für vollständiges Denken und nicht für die zusammengefasste Ausgabe. Durch höhere Budgets kann die Qualität der Antworten verbessert werden, da sie eine gründlichere Analyse komplexer Probleme ermöglichen, obwohl in Claude möglicherweise nicht das gesamte zugewiesene Budget aufgebraucht wird, insbesondere bei Bereichen über 32 000 Token.
Der Wert des Parameters `budget_tokens` muss kleiner als der Wert für `max_tokens` sein. Bei der Verwendung von [Verschachteltes Denken (Beta)](#claude-messages-extended-thinking-tool-use-interleaved) mit Tools können Sie dieses Limit jedoch überschreiten, da das Tokenlimit für das gesamte Kontextfenster gilt (200 000 Token).
### Zusammengefasstes Denken
Wenn erweitertes Denken aktiviert ist, gibt die Messages API für Claude-4-Modelle eine Zusammenfassung des vollständigen Denkprozesses von Claude zurück. Zusammengefasstes Denken bietet alle Vorteile des erweiterten Denkens und verhindert gleichzeitig Missbrauch.
Im Folgenden finden Sie einige wichtige Überlegungen für zusammengefasstes Denken:
+ Es werden die Token für vollständiges Denken berechnet, die durch die ursprüngliche Anfrage generiert wurden, nicht die Token für zusammengefasstes Denken.
+ Die Anzahl der in Rechnung gestellten Ausgabetoken entspricht nicht der Anzahl der Token, die Sie in der Antwort sehen.
+ Der für das Modell für zusammengefasstes Denken bereitgestellte Prompt kann geändert werden.
+ Die ersten Gedankenzeilen sind ausführlicher und bieten eine detaillierte Argumentation, die vor allem für Prompt-Engineering-Zwecke hilfreich ist.
**Anmerkung**
Claude 3.7 Sonnet gibt trotzdem die vollständige Denkausgabe zurück.
Wenden Sie sich an Ihr Account-Team, um in Claude-4-Modellen auf die Ausgabe für vollständiges Denken zuzugreifen.
### Streaming-Denken
Sie können mithilfe von servergesendeten Ereignissen Antworten aus erweitertem Denken streamen. Wenn Streaming für erweitertes Denken aktiviert ist, erhalten Sie Denkinhalte über `thinking_delta`-Ereignisse. Es kann nicht garantiert werden, dass gestreamte Ereignisse mit konstanter Geschwindigkeit zurückgegeben werden. Zwischen Streaming-Ereignissen kann es zu Verzögerungen kommen. Weitere Informationen zum Streamen über die Messages API finden Sie unter [Streamen von Nachrichten](https://docs.anthropic.com/en/docs/build-with-claude/streaming).
So gehst du mit Streaming und Denken um: **InvokeModelWithResponseStream**
```
{
"anthropic_version": "bedrock-2023-05-31",
"max_tokens": 10000,
"thinking": {
"type": "enabled",
"budget_tokens": 4000
},
"messages": [
{
"role": "user",
"content": "What is 27 * 453?"
}
]
}
```
Antwort:
```
event: message_start
data: {"type": "message_start", "message": {"id": "msg_01...", "type": "message", "role": "assistant", "content": [], "model": "claude-3-7-sonnet-20250219", "stop_reason": null, "stop_sequence": null}}
event: content_block_start
data: {"type": "content_block_start", "index": 0, "content_block": {"type": "thinking", "thinking": ""}}
event: content_block_delta
data: {"type": "content_block_delta", "index": 0, "delta": {"type": "thinking_delta", "thinking": "Let me solve this step by step:\n\n1. First break down 27 * 453"}}
event: content_block_delta
data: {"type": "content_block_delta", "index": 0, "delta": {"type": "thinking_delta", "thinking": "\n2. 453 = 400 + 50 + 3"}}
// Additional thinking deltas...
event: content_block_delta
data: {"type": "content_block_delta", "index": 0, "delta": {"type": "signature_delta", "signature": "EqQBCgIYAhIM1gbcDa9GJwZA2b3hGgxBdjrkzLoky3dl1pkiMOYds..."}}
event: content_block_stop
data: {"type": "content_block_stop", "index": 0}
event: content_block_start
data: {"type": "content_block_start", "index": 1, "content_block": {"type": "text", "text": ""}}
event: content_block_delta
data: {"type": "content_block_delta", "index": 1, "delta": {"type": "text_delta", "text": "27 * 453 = 12,231"}}
// Additional text deltas...
event: content_block_stop
data: {"type": "content_block_stop", "index": 1}
event: message_delta
data: {"type": "message_delta", "delta": {"stop_reason": "end_turn", "stop_sequence": null}}
event: message_stop
data: {"type": "message_stop"}
```
**Informationen über das Verhalten von Streaming-Denken**
Wenn Sie Streaming mit aktiviertem Denken verwenden, stellen Sie möglicherweise fest, dass Text manchmal in größeren Blöcken ankommt und sich mit kleineren Sendungen abwechselt. token-by-token Dies ist ein erwartetes Verhalten, insbesondere bei Denkinhalten. Das Streaming-System muss Inhalte stapelweise verarbeiten, um eine optimale Leistung zu erzielen. Dies kann zu diesem Übertragungsmuster führen.
## Erweitertes Denken mit der Verwendung des Tools
Erweitertes Denken kann zusammen mit [Verwendung des Tools](model-parameters-anthropic-claude-messages-tool-use.md) verwendet werden, sodass die Argumentation in Claude durch Toolauswahl und Ergebnisverarbeitung durchgeführt wird. Beachten Sie die folgenden Einschränkungen, wenn Sie erweitertes Denken mit der Verwendung des Tools verwenden:
+ **Einschränkung der Verwendung des Tools**: Bei der Verwendung des Tools in Verbindung mit Denken wird nur `tool_choice: any` unterstützt. Die Bereitstellung eines bestimmten Tools, von `auto` oder anderen Werten wird nicht unterstützt.
+ **Beibehalten von Denkblöcken**: Während der Verwendung des Tools müssen Sie Denkblöcke für die letzte Assistentennachricht an die API zurückgeben. Fügen Sie den gesamten unveränderten Block wieder in die API ein, um die Kontinuität der Argumentation aufrechtzuerhalten.
So funktioniert die Verwaltung von Kontextfenstern mit Tools:
```
{
"anthropic_version": "bedrock-2023-05-31",
"max_tokens": 10000,
"thinking": {
"type": "enabled",
"budget_tokens": 4000
},
"tools": [
{
"name": "get_weather",
"description": "Get current weather for a location",
"input_schema": {
"type": "object",
"properties": {
"location": {
"type": "string"
}
},
"required": [
"location"
]
}
}
],
"messages": [
{
"role": "user",
"content": "What's the weather in Paris?"
}
]
}
```
Die erste Antwort lautet wie folgt:
```
{
"content": [
{
"type": "thinking",
"thinking": "The user wants to know the current weather in Paris. I have access to a function `get_weather`...",
"signature": "BDaL4VrbR2Oj0hO4XpJxT28J5TILnCrrUXoKiiNBZW9P+nr8XSj1zuZzAl4egiCCpQNvfyUuFFJP5CncdYZEQPPmLxYsNrcs...."
},
{
"type": "text",
"text": "I can help you get the current weather information for Paris. Let me check that for you"
},
{
"type": "tool_use",
"id": "toolu_01CswdEQBMshySk6Y9DFKrfq",
"name": "get_weather",
"input": {
"location": "Paris"
}
}
]
}
```
Wenn Sie die Konversation unter Verwendung des Tools fortsetzen, wird eine weitere Antwort generiert. Beachten Sie, dass sowohl der Parameter `thinking_block` als auch der Parameter `tool_use_block` übergeben wird. Wenn er nicht übergeben wird, erhalten Sie eine Fehlermeldung.
```
{
"anthropic_version": "bedrock-2023-05-31",
"max_tokens": 10000,
"thinking": {
"type": "enabled",
"budget_tokens": 4000
},
"tools": [
{
"name": "get_weather",
"description": "Get current weather for a location",
"input_schema": {
"type": "object",
"properties": {
"location": {
"type": "string"
}
},
"required": [
"location"
]
}
}
],
"messages": [
{
"role": "user",
"content": "What's the weather in Paris?"
},
{
"role": "assistant",
"content": [
{
"type": "thinking",
"thinking": "The user wants to know the current weather in Paris. I have access to a function `get_weather`…",
"signature": "BDaL4VrbR2Oj0hO4XpJxT28J5TILnCrrUXoKiiNBZW9P+nr8XSj1zuZzAl4egiCCpQNvfyUuFFJP5CncdYZEQPPmLxY",
},
{
"type": "tool_use",
"id": "toolu_01CswdEQBMshySk6Y9DFKrfq",
"name": "get_weather",
"input": {
"location": "Paris"
}
}
]
},
{
"role": "user",
"content": [
{
"type": "tool_result",
"tool_use_id": "toolu_01CswdEQBMshySk6Y9DFKrfq",
"content": "Current temperature: 88°F"
}
]
}
]
}
```
Die API-Antwort enthält jetzt nur Text.
```
{
"content": [
{
"type": "text",
"text": "Currently in Paris, the temperature is 88°F (31°C)"
}
]
}
```
### Beibehalten von Denkblöcken
Während der Verwendung des Tools müssen Sie Denkblöcke an die API zurückgeben und den gesamten unveränderten Block wieder in die API aufnehmen. Dies ist entscheidend für die Aufrechterhaltung des Argumentationsflusses und der Konversationsintegrität des Modells.
**Tipp**
Sie können zwar `thinking`-Blöcke aus früheren Runden der `assistant`-Rolle weglassen, wir empfehlen jedoch, bei Konversationen mit mehreren Runden immer alle Denkblöcke an die API zurückzugeben. Die API führt die folgenden Schritte aus:
Filtert automatisch die bereitgestellten Denkblöcke
Verwendet die relevanten Denkblöcke, die erforderlich sind, um die Argumentation des Modells beizubehalten
Berechnet nur die Eingabetoken für die in Claude angezeigten Blöcke
Wenn Claude Tools aufruft, wird die Erstellung einer Antwort pausiert, während auf externe Informationen gewartet wird. Wenn die Ergebnisse des Tools zurückgegeben werden, wird die Erstellung der vorhandenen Antwort in Claude fortgesetzt. Dies erfordert die Beibehaltung von Denkblöcken bei der Verwendung des Tools, und zwar aus den folgenden Gründen:
+ **Kontinuität beim Denken**: Die Denkblöcke erfassen Claude die step-by-step Argumentation, die zu Anfragen nach Tools geführt hat. Wenn Sie die Ergebnisse des Tools veröffentlichen, wird durch Einbeziehung des ursprünglichen Denkvorgangs sichergestellt, dass Claude die Argumentation an der Stelle fortsetzen kann, an der sie angehalten wurde.
+ **Kontextwartung**: Die Ergebnisse der Tools werden in der API-Struktur zwar als Benutzernachrichten angezeigt, sind aber Teil eines kontinuierlichen Argumentationsflusses. Durch die Beibehaltung von Denkblöcken wird dieser konzeptionelle Fluss über mehrere API-Aufrufe hinweg aufrechterhalten.
**Wichtig**
Bei der Bereitstellung von Denkblöcken muss die gesamte Abfolge aufeinanderfolgender Denkblöcke mit den Ergebnissen übereinstimmen, die das Modell während der ursprünglichen Anfrage generiert hat. Sie können die Reihenfolge dieser Blöcke nicht neu anordnen oder ändern.
### Verschachteltes Denken (Beta)
**Warnung**
Interleaved Thinking wird Ihnen als „Beta-Service“ gemäß der Definition in den Servicebedingungen zur Verfügung gestellt. AWS Er unterliegt Ihrer Vereinbarung mit AWS und den AWS Servicebedingungen sowie der jeweils geltenden Muster-EULA.
Claude-4-Modelle unterstützen verschachteltes Denken; dieses Feature ermöglicht Claude einen Denkvorgang zwischen den einzelnen Toolaufrufen, sodass nach Erhalt der Ergebnisse differenziertere Schlussfolgerungen möglich sind. Dies ermöglicht komplexere Interaktionen der Kundendienstmitarbeiter, sodass in Claude Folgendes möglich wird:
+ Erläutern der Ergebnisse eines Toolaufrufs vor der Entscheidung, was als Nächstes zu tun ist
+ Verketten mehrerer Toolaufrufe mit dazwischen liegenden Argumentationsschritten
+ Differenziertere Entscheidungen auf der Grundlage von Zwischenergebnissen
Um verschachteltes Denken zu aktivieren, fügen Sie Ihrer API-Anfrage den Beta-Header `interleaved-thinking-2025-05-14` hinzu.
**Anmerkung**
Beim verschachtelten Denken kann der Parameter `budget_tokens` den Parameter `max_tokens` überschreiten, da er das Gesamtbudget aller Denkblöcke innerhalb einer Assistentenrunde darstellt.
## Denken Sie an Block-Clearing (Beta)
**Warnung**
Thinking Block Clearing wird als „Beta-Service“ gemäß der Definition in den AWS Servicebedingungen zur Verfügung gestellt.
**Anmerkung**
Diese Funktion wird derzeit von Claude Sonnet 4/4.5, Claude Haiku 4.5 und Claude Opus 4/4.1/4.5 unterstützt.
Das Löschen von Denkblöcken ist eine Funktion des Anthropic-Claude-Modells (in der Beta-Phase). Mit dieser Funktion kann Claude automatisch ältere Denkblöcke aus früheren Runden löschen. Um das Löschen von Denkblöcken zu verwenden, müssen Sie der Liste der Beta-Header den Anforderungsparameter anthropic\$1beta hinzufügen`context-management-2025-06-27`. Sie müssen außerdem die Verwendung von angeben `clear_thinking_20251015` und aus den folgenden Konfigurationsoptionen auswählen.
Dies sind die verfügbaren Steuerelemente für die Kontextmanagement-Strategie von `clear_thinking_20251015`. Alle sind optional oder haben Standardwerte:
| **Konfigurationsoption** | **Beschreibung** |
| --- | --- |
| `keep` Standard: 1 Denkrunde | Definiert, wie viele kürzliche Runden des Assistenten mit Denkblockaden beibehalten werden sollen. Geben Sie `{"type": "thinking_turns", "value": N}` an, wo N > 0 sein muss, um die letzten N Züge oder `{"type": "all"}` alle Denkblöcke beizubehalten. |
------
#### [ Request ]
```
{
"anthropic_version": "bedrock-2023-05-31",
"max_tokens": 10000,
"anthropic_beta": [
"context-management-2025-06-27"
],
"thinking": {
"type": "enabled",
"budget_tokens": 4000
},
"tools": [
{
"name": "get_weather",
"description": "Get current weather for a location",
"input_schema": {
"type": "object",
"properties": {
"location": {
"type": "string"
}
},
"required": [
"location"
]
}
}
],
"messages": [
{
"role": "user",
"content": "What's the weather in Paris?"
},
{
"role": "assistant",
"content": [
{
"type": "thinking",
"thinking": "The user is asking for the weather in Paris. I have access to a get_weather function that takes a location as a parameter. I have all the information I need to make this call - the location is \"Paris\".\n\nLet me call the get_weather function with \"Paris\" as the location.",
"signature": "ErgDCkgIChABGAIqQC/Ccv8GC+5VfcMEiq78XmpU2Ef2cT+96pHKMedKcRNuPz1x0kFlo5HBpW0r1NcQFVQUPuj6PDmP7jdHY7GsrUwSDKNBMogjaM7wYkwfPhoMswjlmfF09JLjZfFlIjB03NkghGOxLbr3VCQHIY0lMaV9UBvt7ZwTpJKzlz+mulBysfvAmDfcnvdJ/6CZre4qnQJsTZaiXdEgASwPIc5jOExBguerrtYSWVC/oPjSi7KZM8PfhP/SPXupyLi8hwYxeqomqkeG7AQhD+3487ecerZJcpJSOSsf0I1OaMpmQEE/b7ehnvTV/A4nLhxIjP4msyIBW+dVwHNFRFlpJLBHUJvN99b4run6YmqBSf4y9TyNMfOr+FtfxedGE0HfJMBd4FHXmUFyW5y91jAHMWqwNxDgacaKkFCAMaqce5rm0ShOxXn1uwDUAS3jeRP26Pynihq8fw5DQwlqOpo7vvXtqb5jjiCmqfOe6un5xeIdhhbzWddhEk1Vmtg7I817pM4MZjVaeQN02drPs8QgDxihnP6ZooGhd6FCBP2X3Ymdlj5zMlbVHxmSkA4wcNtg4IAYAQ=="
},
{
"type": "tool_use",
"id": "toolu_bdrk_01U7emCvL5v5z5GT7PDr2vzc",
"name": "get_weather",
"input": {
"location": "Paris"
}
}
]
},
{
"role": "user",
"content": [
{
"type": "tool_result",
"tool_use_id": "toolu_bdrk_01U7emCvL5v5z5GT7PDr2vzc",
"content": "Current temperature: 88°F"
}
]
}
],
"context_management": {
"edits": [
{
"type": "clear_thinking_20251015",
"keep": {
"type": "thinking_turns",
"value": 1
}
}
]
}
}
```
------
#### [ Response ]
```
{
"model": "claude-haiku-4-5-20251001",
"id": "msg_bdrk_01KyTbyFbdG2kzPwWMJY1kum",
"type": "message",
"role": "assistant",
"content": [
{
"type": "text",
"text": "The current weather in Paris is **88°F** (approximately 31°C). It's quite warm! If you need more detailed information like humidity, wind conditions, or a forecast, please let me know."
}
],
"stop_reason": "end_turn",
"stop_sequence": null,
"usage": {
"input_tokens": 736,
"cache_creation_input_tokens": 0,
"cache_read_input_tokens": 0,
"cache_creation": {
"ephemeral_5m_input_tokens": 0,
"ephemeral_1h_input_tokens": 0
},
"output_tokens": 47
},
"context_management": {
"applied_edits": [...]
}
}
```
------
## Erweitertes Denken mit Prompt-Caching
Beim erweiterten Denken mit [Prompt-Caching](https://docs.aws.amazon.com/bedrock/latest/userguide/prompt-caching.html) sind mehrere wichtige Aspekte zu berücksichtigen:
**Kontextentfernung aus Denkblöcken**
+ Denkblöcke aus früheren Runden werden aus dem Kontext entfernt, was sich auf Cache-Haltepunkte auswirken kann.
+ Wenn Konversationen unter Verwendung des Tools fortgesetzt werden, werden Denkblöcke zwischengespeichert und zählen als Eingabetoken, wenn sie aus dem Cache gelesen werden. Dies führt zu einem Kompromiss, bei dem Denkblöcke zwar visuell keinen Platz im Kontextfenster beanspruchen, aber beim Zwischenspeichern trotzdem auf die Nutzung Ihrer Eingabetoken angerechnet werden.
+ Wenn das Denken deaktiviert wird, schlagen Anfragen fehl, wenn Sie Denkinhalte in der aktuellen Runde mit der Verwendung des Tools übergeben. In anderen Kontexten werden Denkinhalte, die an die API übergeben werden, einfach ignoriert.
**Muster für Cache-Invalidierung**
+ Änderungen an Denkparametern (wie das Aktivieren, Deaktivieren oder Ändern der Budgetzuweisung) machen die Haltepunkte für den Nachrichten-Cache ungültig.
+ [Verschachteltes Denken (Beta)](#claude-messages-extended-thinking-tool-use-interleaved) verstärkt die Cache-Invalidierung, da zwischen mehreren Toolaufrufen Denkblöcke gebildet werden können.
+ System-Prompts und Tools bleiben im Cache, auch bei der Änderung von Denkparametern oder dem Entfernen von Blöcken.
**Anmerkung**
Während Denkblöcke für das Caching und für kontextbezogene Berechnungen beseitigt werden, müssen sie bei der Fortsetzung von Konversationen mit der Verwendung des Tools, insbesondere bei verschachteltem Denken, beibehalten werden.
## Grundlagen zum Caching-Verhalten von Denkblöcken
Bei Einsatz von erweitertem Denken unter Verwendung des Tools zeigen Denkblöcke ein spezifisches Caching-Verhalten, das sich auf das Zählen von Tokens auswirkt. Der folgenden Sequenz können Sie entnehmen, wie das funktioniert.
1. Das Caching erfolgt nur, wenn Sie eine nachfolgende Anfrage, die Ergebnisse des Tools enthält.
1. Wenn die nachfolgende Anfrage gestellt wird, kann der vorherige Konversationsverlauf (einschließlich Denkblöcken) zwischengespeichert werden.
1. Diese zwischengespeicherten Denkblöcke zählen als Eingabetoken in den Nutzungsmetriken, wenn sie aus dem Cache gelesen werden.
1. Wenn ein non-tool-result Benutzerblock enthalten ist, werden alle vorherigen Denkblöcke ignoriert und aus dem Kontext entfernt.
Im Folgenden ist ein detaillierter Beispielablauf:
Anfrage 1:
```
User: "What's the weather in Paris?"
```
Antwort 1:
```
[thinking_block 1] + [tool_use block 1]
```
Anfrage 2:
```
User: "What's the weather in Paris?",
Assistant: [thinking_block_1] + [tool_use block 1],
User: [tool_result_1, cache=True]
```
Antwort 2:
```
[thinking_block 2] + [text block 2]
```
Anfrage 2 schreibt einen Cache mit dem Inhalt der Anfrage (nicht der Antwort). Der Cache enthält die ursprüngliche Benutzernachricht, den ersten Denkblock, die Verwendung des Tool-Blocks und das Tool-Ergebnis.
Anfrage 3:
```
User: ["What's the weather in Paris?"],
Assistant: [thinking_block_1] + [tool_use block 1],
User: [tool_result_1, cache=True],
Assistant: [thinking_block_2] + [text block 2],
User: [Text response, cache=True]
```
Da ein non-tool-result Benutzerblock enthalten war, werden alle vorherigen Denkblöcke ignoriert. Diese Anfrage wird genauso bearbeitet wie die folgende Anfrage:
Alternative zu Anfrage 3:
```
User: ["What's the weather in Paris?"]
Assistant: [tool_use block 1]
User: [tool_result_1, cache=True]
Assistant: [text block 2]
User: [Text response, cache=True]
```
Dieses Verhalten ist unabhängig davon, ob normales oder verschachteltes Denken angewendet wird, konsistent.
## Maximale Anzahl an Token und Größe des Kontextfensters bei erweitertem Denken
Wenn in älteren Claude-Modellen (früher Claude 3.7 Sonnet) die Summe aus Prompt-Token und „max\$1tokens“ das Kontextfenster des Modells überschritt, passte das System den Wert für „max\$1tokens“ automatisch an, sodass dieser innerhalb des Kontextlimits lag. Das bedeutete, dass Sie einen großen Wert für „max\$1tokens“ festlegen konnten und das System diesen Wert automatisch nach Bedarf reduzierte. Bei den Modellen Claude 3.7 und 4 (worunter auch Ihr Denkbudget fällt, sofern die Denkfunktion aktiviert ist) wird `max_tokens` als strikter Grenzwert durchgesetzt. Das System gibt jetzt einen Validierungsfehler zurück, wenn die Summe aus Prompt-Token und „max\$1tokens“ die Größe des Kontextfensters überschreiten.
### Das Kontextfenster bei erweitertem Denken
Bei der Berechnung der Kontextfensternutzung sind bei aktiviertem Denken einige Aspekte zu beachten:
+ Denkblöcke aus früheren Runden werden entfernt und nicht auf das Kontextfenster angerechnet.
+ Das Denken in der aktuellen Runde wird auf das `max_tokens`-Limit für diese Runde angerechnet.
Das effektive Kontextfenster wird wie folgt berechnet: Kontextfenster = (aktuelle Eingabetoken – Vorherige Denktoken) \$1 (Denktoken \$1 verschlüsselte Denktoken \$1 Textausgabetoken).
### Verwalten von Token mit erweitertem Denken und Verwendung des Tools
Wenn erweitertes Denken zusammen mit der Verwendung des Tools verwendet wird, müssen Denkblöcke explizit beibehalten und zusammen mit den Ergebnissen des Tools zurückgegeben werden. Die effektive Berechnung des Kontextfensters für erweitertes Denken bei Verwendung von Tools sieht wie folgt aus:
`context window = (current input tokens + previous thinking tokens + tool use tokens) + (thinking tokens + encrypted thinking tokens + text output tokens)`
### Verwalten von Token mit erweitertem Denken
Angesichts des Kontextfensters und des Verhaltens von `max_tokens` mit den Claude-Modellen 3.7 und 4 für erweitertes Denken müssen Sie möglicherweise eine der folgenden Aktionen ausführen:
+ Überwachen und verwalten Sie Ihre Tokennutzung aktiver.
+ Passen Sie die Werte für `max_tokens` an, wenn sich die Länge des Prompts ändert.
+ Beachten Sie, dass sich frühere Denkblöcke nicht im Kontextfenster ansammeln. Diese Änderung wurde vorgenommen, um ein vorhersehbareres und transparenteres Verhalten zu ermöglichen, insbesondere da die maximale Grenze für Token erheblich erhöht wurde.
## Überlegungen zu den Kosten des erweiterten Denkens
Beim Denkprozess fallen folgende Gebühren an:
+ Für Token, die beim Denken verwendet werden (Ausgabetoken)
+ Für Denkblöcke aus der letzten Runde des Assistenten, die in nachfolgenden Anfragen enthalten sind (Eingabetoken)
+ Für Standard-Textausgabetoken
**Tipp**
Wenn erweitertes Denken aktiviert ist, wird zur Unterstützung des Features automatisch ein spezieller Prompt mit 28 oder 29 Token hinzugefügt.
Der Parameter `budget_tokens` bestimmt die maximale Anzahl von Token, die in Claude für den internen Argumentationsprozess verwendet werden dürfen. Durch höhere Budgets kann die Qualität der Antworten verbessert werden, da sie eine gründlichere Analyse komplexer Probleme ermöglichen, wobei in Claude möglicherweise nicht das gesamte zugewiesene Budget aufgebraucht wird, insbesondere bei Bereichen über 32 000.
Beim verschachtelten Denken kann der Parameter `budget_tokens` den Parameter `max_tokens` überschreiten, weil er das Gesamtbudget aller Denkblöcke innerhalb einer Assistentenrunde darstellt.
Berücksichtigen Sie bei der Verwendung von zusammengefasstem Denken Folgendes:
+ **Eingabetoken**: Token in der ursprünglichen Anfrage
+ **Ausgabetoken (in Rechnung gestellt)**: Die ursprünglichen Denktoken, die intern in Claude generiert wurden
+ **Ausgabetoken (sichtbar)**: Die zusammengefassten Denktoken, die Sie in der Antwort sehen
+ **Kostenlos**: Token, die zur Generierung der Zusammenfassung verwendet wurden
+ Im Feld `summary_status` wird möglicherweise angegeben, ob das Token die Zusammenfassung der betroffenen Daten einschränkt
+ Die Anzahl der in Rechnung gestellten Ausgabetoken entspricht nicht der Anzahl der Token, die Sie in der Antwort sehen. Ihnen wird der vollständige Denkprozess in Rechnung gestellt, nicht die Zusammenfassung, die Sie sehen.
# Adaptives Denken
Adaptives Denken ist die empfohlene Methode [Erweitertes Denken](claude-messages-extended-thinking.md) für Claude Opus 4.6. Anstatt manuell ein Budget für Denkmuster festzulegen, ermöglicht adaptives Denken anhand der Komplexität der einzelnen Anfragen Claude dynamisch zu entscheiden, wann und wie viel nachgedacht werden soll. Adaptives Denken führt zuverlässig zu einer besseren Leistung als erweitertes Denken mit einer festen Einstellung`budget_tokens`, und wir empfehlen, zu adaptivem Denken überzugehen, um die intelligentesten Antworten aus Claude Opus 4.6 zu erhalten. Es ist kein Beta-Header erforderlich.
Es werde folgende Modelle unterstützt:
| Modell | Modell-ID |
| --- | --- |
| Claude Opus4.6 | `anthropic.claude-opus-4-6-v1` |
| Claude Sonett 4,6 | `anthropic.claude-sonnet-4-6` |
**Anmerkung**
`thinking.type: "enabled"`und `budget_tokens` sind in Version Claude Opus 4.6 veraltet und werden in einer future Modellversion entfernt. Verwenden Sie es `thinking.type: "adaptive"` stattdessen mit dem Effort-Parameter.
Ältere Modelle (Claude Sonnet 4.5, Claude Opus 4.5 usw.) unterstützen adaptives Denken nicht und erfordern `thinking.type: "enabled"` mit`budget_tokens`.
## Wie funktioniert adaptives Denken
Im adaptiven Modus Claude wird die Komplexität jeder Anfrage bewertet und entschieden, ob und wie viel darüber nachgedacht werden soll. Auf der Standardaufwandsebene (`high`) denkt er fast immer nach. Claude Bei niedrigerem Aufwand überspringt er Claude möglicherweise das Denken für einfachere Probleme.
Adaptives Denken ermöglicht dies auch automatisch[Verschachteltes Denken (Beta)](claude-messages-extended-thinking.md#claude-messages-extended-thinking-tool-use-interleaved). Das bedeutet, dass es zwischen den einzelnen Toolaufrufen denken Claude kann, was es besonders effektiv für die Arbeitsabläufe von Agenturen macht.
Stellen Sie `"adaptive"` in `thinking.type` Ihrer API-Anfrage auf Folgendes ein:
------
#### [ CLI ]
```
aws bedrock-runtime invoke-model \
--model-id "us.anthropic.claude-opus-4-6-v1" \
--body '{
"anthropic_version": "bedrock-2023-05-31",
"max_tokens": 16000,
"thinking": {
"type": "adaptive"
},
"messages": [
{
"role": "user",
"content": "Three players A, B, C play a game. Each has a jar with 100 balls numbered 1-100. Simultaneously, each draws one ball. A beats B if As number > Bs number (mod 100, treating 100 as 0 for comparison). Similarly for B vs C and C vs A. The overall winner is determined by majority of pairwise wins (ties broken randomly). Is there a mixed strategy Nash equilibrium where each player draws uniformly? If not, characterize the equilibrium."
}
]
}' \
--cli-binary-format raw-in-base64-out \
output.json && cat output.json | jq '.content[] | {type, thinking: .thinking[0:200], text}'
```
------
#### [ Python ]
```
import boto3
import json
bedrock_runtime = boto3.client(
service_name='bedrock-runtime',
region_name='us-east-2'
)
response = bedrock_runtime.invoke_model(
modelId="us.anthropic.claude-opus-4-6-v1",
body=json.dumps({
"anthropic_version": "bedrock-2023-05-31",
"max_tokens": 16000,
"thinking": {
"type": "adaptive"
},
"messages": [{
"role": "user",
"content": "Explain why the sum of two even numbers is always even."
}]
})
)
response_body = json.loads(response["body"].read())
for block in response_body["content"]:
if block["type"] == "thinking":
print(f"\nThinking: {block['thinking']}")
elif block["type"] == "text":
print(f"\nResponse: {block['text']}")
```
------
#### [ TypeScript ]
```
import { BedrockRuntimeClient, InvokeModelCommand } from "@aws-sdk/client-bedrock-runtime";
async function main() {
const client = new BedrockRuntimeClient({});
const command = new InvokeModelCommand({
modelId: "us.anthropic.claude-opus-4-6-v1",
body: JSON.stringify({
anthropic_version: "bedrock-2023-05-31",
max_tokens: 16000,
thinking: {
type: "adaptive"
},
messages: [{
role: "user",
content: "Explain why the sum of two even numbers is always even."
}]
})
});
const response = await client.send(command);
const responseBody = JSON.parse(new TextDecoder().decode(response.body));
for (const block of responseBody.content) {
if (block.type === "thinking") {
console.log(`\nThinking: ${block.thinking}`);
} else if (block.type === "text") {
console.log(`\nResponse: ${block.text}`);
}
}
}
main().catch(console.error);
```
------
## Adaptives Denken mit dem Parameter Aufwand
Sie können adaptives Denken mit dem Leistungsparameter kombinieren, um zu bestimmen, wie viel Denken Claude bewirkt. Das Aufwandsniveau dient als Orientierungshilfe für die Verteilung Claude des Denkens:
| Aufwand-Ebene | Denkverhalten |
| --- | --- |
| max | Claudedenkt immer ohne Einschränkungen in Bezug auf die Denktiefe. Claude Opusnur 4.6 — Anfragen, die max auf anderen Modellen verwendet werden, geben einen Fehler zurück. |
| high (Standard) | Claudedenkt immer. Bietet fundierte Überlegungen zu komplexen Aufgaben. |
| medium | Claudeverwendet gemäßigtes Denken. Kann bei sehr einfachen Fragen das Nachdenken überspringen. |
| low | Claudeminimiert das Denken. Überspringt das Denken bei einfachen Aufgaben, bei denen Geschwindigkeit am wichtigsten ist. |
## Prompt-Caching
Aufeinanderfolgende Anfragen, bei denen `adaptive` Thinking verwendet wird, behalten die Zwischenspeicher-Haltepunkte bei. Beim Umschalten zwischen den `disabled` Denkmodi `adaptive` und`enabled`/werden jedoch die Cache-Breakpoints für Nachrichten unterbrochen. Systemaufforderungen und Werkzeugdefinitionen bleiben unabhängig von Modusänderungen zwischengespeichert.
## Optimierung des Denkverhaltens
Wenn Claude Sie mehr oder weniger häufig denken, als Sie möchten, können Sie Ihrer Systemaufforderung eine Anleitung hinzufügen:
```
Extended thinking adds latency and should only be used when it
will meaningfully improve answer quality — typically for problems
that require multi-step reasoning. When in doubt, respond directly.
```
**Warnung**
Wenn Sie weniger häufig nachdenken, kann dies Claude zu Qualitätseinbußen bei Aufgaben führen, für die Argumentation von Vorteil ist. Messen Sie die Auswirkungen auf Ihre spezifischen Workloads, bevor Sie das Prompt-basierte Tuning in der Produktion einsetzen. Erwägen Sie, zunächst mit geringerem Aufwand zu testen.
# Verschlüsselung beim Denken
Die vollständigen Denkinhalte werden verschlüsselt und im Signaturfeld zurückgegeben. Dieses Feld wird verwendet, um zu überprüfen, ob bei der Rückgabe an die API Denkblöcke in Claude generiert wurden. Beim Streamen von Antworten wird die Signatur über ein `signature_delta`-Ereignis innerhalb eines `content_block_delta`-Ereignisses direkt vor einem `content_block_stop`-Ereignis hinzugefügt.
**Anmerkung**
Denkblöcke müssen nur dann zurückgeschickt werden, wenn Tools mit erweitertem Denken verwendet werden. Andernfalls können Denkblöcke aus früheren Runden weggelassen oder bei der Rückgabe von der API entfernt werden.
Wenn Sie Denkblöcke zurücksenden, empfehlen wir zur Wahrung der Konsistenz und zur Vermeidung potenzieller Probleme, sie in dem Zustand zu belassen, in dem sie empfangen wurden.
## Überarbeiten von Denkprozessen in Claude 3.7 Sonnet
**Anmerkung**
Die folgenden Informationen gelten speziell für Claude 3.7 Sonnet. In Claude-4-Modellen werden Denkprozesse anders gehandhabt und es werden keine überarbeiteten Denkblöcke erzeugt.
In Claude 3.7 Sonnet gilt Folgendes:
+ Gelegentlich werden die internen Argumentationen von Claude durch unsere Sicherheitssysteme aufgedeckt. In diesem Fall verschlüsseln wir einen Teil oder den gesamten Denkblock und geben ihn als redacted\$1thinking-Block an zurück. redacted\$1thinking-Blöcke werden entschlüsselt, wenn sie an die API zurückgegeben werden, sodass die Antwort von Claude fortgesetzt werden kann, ohne dass dabei Kontext verloren geht.
+ `thinking`- und `redacted_thinking`-Blöcke werden vor den Textblöcken in der Antwort zurückgegeben.
Berücksichtigen Sie bei der Entwicklung kundenorientierter Anwendungen, die erweitertes Denken mit Claude 3.7 Sonnet nutzen, folgende Aspekte:
+ Beachten Sie, dass überarbeitete Denkblöcke verschlüsselte Inhalte enthalten, die für Menschen nicht lesbar sind.
+ Fügen Sie ggf. eine einfache Erklärung hinzu, z. B. „Ein Teil der internen Argumentation von Claude wurde aus Sicherheitsgründen automatisch verschlüsselt. Die Qualität der Antworten wird dadurch nicht beeinträchtigt.“
+ Wenn Sie Benutzern Denkblöcke anzeigen, können Sie überarbeitete Blöcke herausfiltern und dabei normale Denkblöcke beibehalten.
+ Machen Sie deutlich, dass die Verwendung von Features für erweitertes Denken gelegentlich dazu führen kann, dass einige Argumentationen verschlüsselt werden.
+ Implementieren Sie eine angemessene Fehlerbehandlung, um redigiertes Denken ordnungsgemäß und ohne Beeinträchtigung der Benutzeroberfläche zu verwalten.
Hier ist ein Beispiel, das sowohl normale als auch überarbeitete Denkblöcke zeigt:
```
{
"content": [
{
"type": "thinking",
"thinking": "Let me analyze this step by step...",
"signature":"WaUjzkypQ2mUEVM36O2TxuC06KN8xyfbJwyem2dw3URve/op91XWHOEBLLqIOMfFG/UvLEczmEsUjavL...." },
{
"type": "redacted_thinking",
"data":"EmwKAhgBEgy3va3pzix/LafPsn4aDFIT2Xlxh0L5L8rLVyIwxtE3rAFBa8cr3qpP..."
},
{
"type": "text",
"text": "Based on my analysis..."
}
]
}
```
**Tipp**
Es ist normal, dass die Ausgabe redigierte Denkblöcke enthält. Das Modell kann diese überarbeitete Argumentation dennoch als Grundlage für seine Antworten verwenden und gleichzeitig den Integritätsschutz wahren.
Wenn Sie den Umgang mit überarbeitetem Denken in Ihrer Anwendung testen möchten, können Sie als Prompt die folgende Testzeichenfolge verwenden: `ANTHROPIC_MAGIC_STRING_TRIGGER_REDACTED_THINKING_46C9A13E193C177646C7398A98432ECCCE4C1253D5E2D82641AC0E52CC2876CB`
Wenn Sie in einer Konversation mit mehreren Runden `thinking`- und `redacted_thinking`-Blöcke an die API zurückleiten, müssen Sie den kompletten, unveränderten Block für die letzte Runde des Assistenten wieder in die API aufnehmen. Dies ist entscheidend für die Aufrechterhaltung des Argumentationsflusses des Modells. Wir empfehlen, immer alle Denkblöcke an die API zurückzugeben. Weitere Informationen hierzu finden Sie unter [Erweitertes Denken mit der Verwendung des ToolsBeibehalten von Denkblöcken](claude-messages-extended-thinking.md#claude-messages-extended-thinking-tool-use-thinking-blocks).
Im folgenden Beispiel wird die **InvokeModelWithResponseStream**API verwendet, um die Anfrage- und Antwortstruktur zu demonstrieren, wenn Thinking Tokens mit Schwärzungen verwendet werden.
Wenn Streaming aktiviert ist, erhalten Sie Denkinhalte von thinking\$1delta-Ereignissen. Vorgehensweise beim Streaming-Denken:
**Anforderung**
```
{
"anthropic_version": "bedrock-2023-05-31",
"max_tokens": 24000,
"thinking": {
"type": "enabled",
"budget_tokens": 16000
},
"messages": [
{
"role": "user",
"content": "What is 27 * 453?"
}
]
}
```
**Antwort**
```
event: message_start
data: {"type": "message_start", "message": {"id": "msg_01...", "type": "message", "role": "assistant", "content": [], "model": "claude-3-7-sonnet-20250219", "stop_reason": null, "stop_sequence": null}}
event: content_block_start
data: {"type": "content_block_start", "index": 0, "content_block": {"type": "thinking", "thinking": ""}}
event: content_block_delta
data: {"type": "content_block_delta", "index": 0, "delta": {"type": "thinking_delta", "thinking": "Let me solve this step by step:\n\n1. First break down 27 * 453"}}
event: content_block_delta
data: {"type": "content_block_delta", "index": 0, "delta": {"type": "thinking_delta", "thinking": "\n2. 453 = 400 + 50 + 3"}}
// Additional thinking deltas...
event: content_block_delta
data: {"type": "content_block_delta", "index": 0, "delta": {"type": "signature_delta", "signature": "EqQBCgIYAhIM1gbcDa9GJwZA2b3hGgxBdjrkzLoky3dl1pkiMOYds..."}}
event: content_block_stop
data: {"type": "content_block_stop", "index": 0}
event: content_block_start
data: {"type": "content_block_start", "index": 1, "content_block": {"type": "text", "text": ""}}
event: content_block_delta
data: {"type": "content_block_delta", "index": 1, "delta": {"type": "text_delta", "text": "27 * 453 = 12,231"}}
// Additional text deltas...
event: content_block_stop
data: {"type": "content_block_stop", "index": 1}
event: message_delta
data: {"type": "message_delta", "delta": {"stop_reason": "end_turn", "stop_sequence": null}}
event: message_stop
data: {"type": "message_stop"}
```
# Unterschiede im Denken zwischen den Modellversionen
Die Nachrichten-API behandelt die Denkfunktion in Claude-4-Modellen anders als in Claude 3.7 Sonnet-Modellen, insbesondere in Bezug auf das Verhalten bei der Überarbeitung und Zusammenfassung. Diese Unterschiede werden in der folgenden Tabelle zusammengefasst.
| Feature | Claude 3.7 Sonnet | Claude-4-Modelle |
| --- | --- | --- |
| Denkausgabe | Gibt die vollständige Denkausgabe zurück | Gibt zusammengefasstes Denken zurück |
| Umgang mit Überarbeitungen | Verwendet `redacted_thinking`-Blöcke | Überarbeitet und verschlüsselt den vollständigen Denkprozess und gibt in einem `signature`-Feld aus |
| Verschachteltes Denken | Nicht unterstützt | Wird mit einem Beta-Header unterstützt |
# Verdichtung
**Tipp**
Die serverseitige Komprimierung wird für die Verwaltung des Kontextes in lang andauernden Konversationen und Agentenworkflows empfohlen, da sie das Kontextmanagement automatisch und mit minimalem Integrationsaufwand abwickelt.
**Anmerkung**
Die Komprimierung befindet sich derzeit in der Betaphase. Nehmen Sie den Beta-Header `compact-2026-01-12` in Ihre API-Anfragen auf, um diese Funktion zu nutzen. Die Komprimierung wird derzeit von der Converse API nicht unterstützt, sie wird jedoch von unterstützt. [InvokeModel](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModel.html)
Durch die Komprimierung wird die effektive Kontextlänge für Konversationen und Aufgaben mit langer Laufzeit verlängert, indem älterer Kontext automatisch zusammengefasst wird, wenn das Kontext-Fensterlimit erreicht wird. Das ist ideal für:
+ Chat-basierte Konversationen mit mehreren Runden, bei denen Sie möchten, dass Benutzer einen Chat über einen längeren Zeitraum verwenden
+ Aufgabenorientierte Eingabeaufforderungen, die viel Nacharbeit erfordern (häufig den Einsatz von Tools) und die das Kontextfenster von 200.000 überschreiten können
Die Komprimierung wird auf den folgenden Modellen unterstützt:
| Modell | Modell-ID |
| --- | --- |
| Claude Sonnet 4.6 | `anthropic.claude-sonnet-4-6` |
| Claude Opus 4.6 | `anthropic.claude-opus-4-6-v1` |
**Anmerkung**
Die Werte auf oberster Ebene `input_tokens` und `output_tokens` im `usage` Feld enthalten nicht die Verwendung von Verdichtungsiterationen und geben die Summe aller Iterationen ohne Komprimierung wieder. Um die Gesamtzahl der für eine Anfrage verbrauchten und in Rechnung gestellten Token zu berechnen, summieren Sie alle Einträge im Array. `usage.iterations`
Wenn Sie sich bisher `usage.output_tokens` bei der Kostenverfolgung oder -prüfung auf `usage.input_tokens` und verlassen haben, müssen Sie Ihre Nachverfolgungslogik aktualisieren, damit `usage.iterations` sie bei aktivierter Komprimierung aggregiert wird. Das `iterations` Array ist nur vorhanden, wenn während der Anforderung eine neue Komprimierung ausgelöst wird. Das erneute Anwenden eines vorherigen `compaction` Blocks verursacht keine zusätzlichen Verdichtungskosten, und die Verwendungsfelder der obersten Ebene bleiben in diesem Fall korrekt.
## Wie funktioniert die Verdichtung
Wenn die Komprimierung aktiviert ist, fasst Ihre Konversation Claude automatisch zusammen, wenn sie sich dem konfigurierten Token-Schwellenwert nähert. Die API:
1. Erkennt, wenn Eingabe-Tokens den angegebenen Triggerschwellenwert überschreiten.
1. Generiert eine Zusammenfassung der aktuellen Konversation.
1. Erzeugt einen `compaction` Block, der die Zusammenfassung enthält.
1. Setzt die Antwort mit dem komprimierten Kontext fort.
Bei nachfolgenden Anfragen fügen Sie die Antwort an Ihre Nachrichten an. Die API löscht automatisch alle Nachrichtenblöcke vor dem `compaction` Block und setzt die Konversation von der Zusammenfassung aus fort.
## Grundlegende Verwendung
Aktivieren Sie die Komprimierung, indem Sie die `compact_20260112` Strategie zu `context_management.edits` Ihrer Nachrichten-API-Anfrage hinzufügen.
------
#### [ CLI ]
```
aws bedrock-runtime invoke-model \
--model-id "us.anthropic.claude-opus-4-6-v1" \
--body '{
"anthropic_version": "bedrock-2023-05-31",
"anthropic_beta": ["compact-2026-01-12"],
"max_tokens": 4096,
"messages": [
{
"role": "user",
"content": "Help me build a website"
}
],
"context_management": {
"edits": [
{
"type": "compact_20260112"
}
]
}
}' \
--cli-binary-format raw-in-base64-out \
/tmp/response.json
echo "Response:"
cat /tmp/response.json | jq '.content[] | {type, text: .text[0:500]}'
```
------
#### [ Python ]
```
import boto3
import json
bedrock_runtime = boto3.client(service_name='bedrock-runtime')
messages = [{"role": "user", "content": "Help me build a website"}]
response = bedrock_runtime.invoke_model(
modelId="us.anthropic.claude-opus-4-6-v1",
body=json.dumps({
"anthropic_version": "bedrock-2023-05-31",
"anthropic_beta": ["compact-2026-01-12"],
"max_tokens": 4096,
"messages": messages,
"context_management": {
"edits": [
{
"type": "compact_20260112"
}
]
}
})
)
response_body = json.loads(response["body"].read())
# Append the response (including any compaction block) to continue the conversation
messages.append({"role": "assistant", "content": response_body["content"]})
for block in response_body["content"]:
if block.get("type") == "compaction":
print(f"[COMPACTION]: {block['content'][:200]}...")
elif block.get("type") == "text":
print(f"[RESPONSE]: {block['text']}")
```
------
#### [ TypeScript ]
```
import { BedrockRuntimeClient, InvokeModelCommand } from "@aws-sdk/client-bedrock-runtime";
async function main() {
const client = new BedrockRuntimeClient({});
const messages: Array<{role: string, content: string | object[]}> = [
{ role: "user", content: "Help me build a website" }
];
const command = new InvokeModelCommand({
modelId: "us.anthropic.claude-opus-4-6-v1",
body: JSON.stringify({
anthropic_version: "bedrock-2023-05-31",
anthropic_beta: ["compact-2026-01-12"],
max_tokens: 4096,
messages,
context_management: {
edits: [
{
type: "compact_20260112"
}
]
}
})
});
const response = await client.send(command);
const responseBody = JSON.parse(new TextDecoder().decode(response.body));
// Append response to continue conversation
messages.push({ role: "assistant", content: responseBody.content });
for (const block of responseBody.content) {
if (block.type === "compaction") {
console.log(`[COMPACTION]: ${block.content.substring(0, 200)}...`);
} else if (block.type === "text") {
console.log(`[RESPONSE]: ${block.text}`);
}
}
}
main().catch(console.error);
```
------
## Parameters
| Parameter | Typ | Standard | Description |
| --- | --- | --- | --- |
| type | Zeichenfolge | Erforderlich | Muss "compact\$120260112" sein. |
| trigger | object | 150.000 Token | Wann muss die Verdichtung ausgelöst werden? Es müssen mindestens 50.000 Tokens sein. |
| pause\$1after\$1compaction | boolesch | false | Ob nach dem Generieren der Zusammenfassung der Komprimierung eine Pause eingelegt werden soll |
| instructions | Zeichenfolge | null | Eingabeaufforderung zur benutzerdefinierten Zusammenfassung. Ersetzt die Standardaufforderung vollständig, sofern sie bereitgestellt wird. |
## Konfiguration des Triggers
Konfigurieren Sie mit dem folgenden `trigger` Parameter, wann die Komprimierung ausgelöst wird:
```
import boto3
import json
bedrock_runtime = boto3.client(service_name='bedrock-runtime')
response = bedrock_runtime.invoke_model(
modelId="us.anthropic.claude-opus-4-6-v1",
body=json.dumps({
"anthropic_version": "bedrock-2023-05-31",
"anthropic_beta": ["compact-2026-01-12"],
"max_tokens": 4096,
"messages": [{"role": "user", "content": "Help me build a website"}],
"context_management": {
"edits": [
{
"type": "compact_20260112",
"trigger": {
"type": "input_tokens",
"value": 100000
}
}
]
}
})
)
response_body = json.loads(response["body"].read())
print(response_body["content"][-1]["text"])
```
## Anweisungen zur benutzerdefinierten Zusammenfassung
Standardmäßig verwendet die Komprimierung die folgende Zusammenfassungsaufforderung:
```
You have written a partial transcript for the initial task above. Please write a summary of the transcript. The purpose of this summary is to provide continuity so you can continue to make progress towards solving the task in a future context, where the raw history above may not be accessible and will be replaced with this summary. Write down anything that would be helpful, including the state, next steps, learnings etc. You must wrap your summary in a block.
```
Sie können über den `instructions` Parameter benutzerdefinierte Anweisungen angeben, um diese Aufforderung vollständig zu ersetzen. Benutzerdefinierte Anweisungen ergänzen die Standardeinstellung nicht, sondern ersetzen sie vollständig:
```
import boto3
import json
bedrock_runtime = boto3.client(service_name='bedrock-runtime')
response = bedrock_runtime.invoke_model(
modelId="us.anthropic.claude-opus-4-6-v1",
body=json.dumps({
"anthropic_version": "bedrock-2023-05-31",
"anthropic_beta": ["compact-2026-01-12"],
"max_tokens": 4096,
"messages": [{"role": "user", "content": "Help me build a website"}],
"context_management": {
"edits": [
{
"type": "compact_20260112",
"instructions": "Focus on preserving code snippets, variable names, and technical decisions."
}
]
}
})
)
response_body = json.loads(response["body"].read())
print(response_body["content"][-1]["text"])
```
## Wird nach der Verdichtung angehalten
Wird verwendet`pause_after_compaction`, um die API nach dem Generieren der Zusammenfassung der Komprimierung anzuhalten. Auf diese Weise können Sie zusätzliche Inhaltsblöcke hinzufügen (z. B. die Beibehaltung aktueller Nachrichten oder bestimmter anweisungsorientierter Nachrichten), bevor die API mit der Antwort fortfährt.
Wenn diese Option aktiviert ist, gibt die API nach der Generierung des Verdichtungsblocks eine Nachricht mit dem Grund für den `compaction` Stopp zurück:
```
import boto3
import json
bedrock_runtime = boto3.client(service_name='bedrock-runtime')
messages = [{"role": "user", "content": "Help me build a website"}]
response = bedrock_runtime.invoke_model(
modelId="us.anthropic.claude-opus-4-6-v1",
body=json.dumps({
"anthropic_version": "bedrock-2023-05-31",
"anthropic_beta": ["compact-2026-01-12"],
"max_tokens": 4096,
"messages": messages,
"context_management": {
"edits": [
{
"type": "compact_20260112",
"pause_after_compaction": True
}
]
}
})
)
response_body = json.loads(response["body"].read())
# Check if compaction triggered a pause
if response_body.get("stop_reason") == "compaction":
# Response contains only the compaction block
messages.append({"role": "assistant", "content": response_body["content"]})
# Continue the request
response = bedrock_runtime.invoke_model(
modelId="us.anthropic.claude-opus-4-6-v1",
body=json.dumps({
"anthropic_version": "bedrock-2023-05-31",
"anthropic_beta": ["compact-2026-01-12"],
"max_tokens": 4096,
"messages": messages,
"context_management": {
"edits": [{"type": "compact_20260112"}]
}
})
)
response_body = json.loads(response["body"].read())
print(response_body["content"][-1]["text"])
```
## Mit Verdichtungsblöcken arbeiten
Wenn die Komprimierung ausgelöst wird, gibt die API zu Beginn der Assistentenantwort einen `compaction` Block zurück.
Eine lang andauernde Konversation kann zu mehreren Verdichtungen führen. Der letzte Komprimierungsblock spiegelt den endgültigen Status der Aufforderung wider und ersetzt den Inhalt davor durch die generierte Zusammenfassung.
```
{
"content": [
{
"type": "compaction",
"content": "Summary of the conversation: The user requested help building a web scraper..."
},
{
"type": "text",
"text": "Based on our conversation so far..."
}
]
}
```
## Streaming
Wenn Sie Antworten mit aktivierter Komprimierung streamen, erhalten Sie ein `content_block_start` Ereignis, wenn die Komprimierung beginnt. Der Verdichtungsblock streamt anders als Textblöcke. Sie erhalten eine `content_block_start` Veranstaltung, gefolgt von einer Single `content_block_delta` mit dem vollständigen Inhalt der Zusammenfassung (kein Zwischenstreaming) und dann ein `content_block_stop` Ereignis.
## Prompt-Caching
Sie können einen `cache_control` Haltepunkt für Komprimierungsblöcke hinzufügen, der die vollständige Systemaufforderung zusammen mit dem zusammengefassten Inhalt zwischenspeichert. Der komprimierte Originalinhalt wird ignoriert. Beachten Sie, dass, wenn die Komprimierung ausgelöst wird, dies dazu führen kann, dass bei der nachfolgenden Anforderung ein Cache-Fehler auftritt.
```
{
"role": "assistant",
"content": [
{
"type": "compaction",
"content": "[summary text]",
"cache_control": {"type": "ephemeral"}
},
{
"type": "text",
"text": "Based on our conversation..."
}
]
}
```
## Die Verwendung verstehen
Für die Verdichtung ist ein zusätzlicher Probenahmeschritt erforderlich, was zu Preisobergrenzen und Fakturierung beiträgt. Die API gibt in der Antwort detaillierte Nutzungsinformationen zurück:
```
{
"usage": {
"input_tokens": 45000,
"output_tokens": 1234,
"iterations": [
{
"type": "compaction",
"input_tokens": 180000,
"output_tokens": 3500
},
{
"type": "message",
"input_tokens": 23000,
"output_tokens": 1000
}
]
}
}
```
Das `iterations` Array zeigt die Nutzung für jede Sampling-Iteration. Wenn die Komprimierung stattfindet, sehen Sie eine `compaction` Iteration, auf die die Hauptiteration folgt. `message` Die Token-Anzahl der letzten Iteration spiegelt die effektive Kontextgröße nach der Komprimierung wider.
# Holen Sie sich validierte JSON-Ergebnisse aus Modellen
Sie können strukturierte Ausgaben mitClaude Sonnet 4.5, Claude Haiku 4.5Claude Opus 4.5, und Claude Opus 4.6 verwenden. Weitere Informationen hierzu finden Sie unter [Holen Sie sich validierte JSON-Ergebnisse aus Modellen](structured-output.md).
# Anforderung und Antwort
Der Anfragetext wird im `body` Feld einer Anfrage an [InvokeModel](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModel.html)oder übergeben [InvokeModelWithResponseStream](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModelWithResponseStream.html).
**Anmerkung**
Einschränkungen gelten für die folgenden Operationen: `InvokeModel``InvokeModelWithResponseStream`,`Converse`, und`ConverseStream`. Einzelheiten finden Sie unter [API-Einschränkungen](inference-api-restrictions.md).
**Warnung**
Claude Sonnet 4.5und Claude Haiku 4.5 unterstützt die Angabe entweder des `top_p` Parameters `temperature` oder, aber nicht beider. Dies gilt nicht für ältere Modelle.
------
#### [ Request ]
Anthropic Claude verfügt über die folgenden Inferenzparameter für Nachrichten-Inferenzaufrufe.
```
{
"anthropic_version": "bedrock-2023-05-31",
"anthropic_beta": ["computer-use-2024-10-22"]
"max_tokens": int,
"system": string,
"messages": [
{
"role": string,
"content": [
{ "type": "image", "source": { "type": "base64", "media_type": "image/jpeg", "data": "content image bytes" } },
{ "type": "text", "text": "content text" }
]
}
],
"temperature": float,
"top_p": float,
"top_k": int,
"tools": [
{
"type": "custom",
"name": string,
"description": string,
"input_schema": json
},
{
"type": "computer_20241022",
"name": "computer",
"display_height_px": int,
"display_width_px": int,
"display_number": 0 int
},
{
"type": "bash_20241022",
"name": "bash"
},
{
"type": "text_editor_20241022",
"name": "str_replace_editor"
}
],
"tool_choice": {
"type" : string,
"name" : string,
},
"stop_sequences": [string]
}
```
Die folgenden Parameter sind erforderlich.
+ **anthropic\$1version** – (erforderlich) Die anthropische Version Der Wert muss sein`bedrock-2023-05-31`.
+ **max\$1tokens** – (erforderlich) Die maximale Anzahl von Token, die vor dem Stoppen generiert werden sollen.
Beachten Sie, dass Anthropic-Claude-Modelle möglicherweise die Generierung von Token einstellen, bevor der Wert von `max_tokens` erreicht ist. Verschiedene Anthropic-Claude-Modelle haben unterschiedliche Maximalwerte für diesen Parameter. Weitere Informationen finden Sie unter [Modellvergleich](https://docs.anthropic.com/claude/docs/models-overview#model-comparison).
+ **messages** – (erforderlich) Die Eingabenachrichten
+ **role** – Die Rolle der Konversationsrunde Gültige Werte sind `user` und `assistant`.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/bedrock/latest/userguide/model-parameters-anthropic-claude-messages-request-response.html)
+ **content** – (erforderlich) Der Inhalt der Konversationsrunde als Array von Objekten. Jedes Objekt enthält ein **type**-Feld, in dem Sie einen der folgenden Werte angeben können:
+ `text` – Wenn Sie diesen Typ angeben, müssen Sie ein **text**-Feld einschließen und den Text-Prompt als Wert angeben. Wenn es sich bei einem anderen Objekt im Array um ein Bild handelt, gilt dieser Text-Prompt für die Bilder.
+ `image` – Wenn Sie diesen Typ angeben, müssen Sie ein **source**-Feld angeben, das einem Objekt mit den folgenden Feldern zugeordnet ist:
+ **type** – (erforderlich) Der Kodierungstyp für das Bild. Sie können `base64` angeben.
+ **media\$1type** – (erforderlich) Der Typ des Bildes. Sie können die folgenden Bildformate angeben.
+ `image/jpeg`
+ `image/png`
+ `image/webp`
+ `image/gif`
+ **data** – (erforderlich) Die base64-codierten Bildbytes für das Bild. Die maximale Größe ist 3,75 MB. Die maximale Höhe und Breite eines Bildes beträgt 8 000 Pixel.
Die folgenden Parameter sind optional.
+ **system** – (optional) Der System-Prompt für die Anfrage.
Ein System-Prompt bietet die Möglichkeit, Anthropic Claude mit Kontext und Anweisungen zu versorgen, beispielsweise durch die Angabe eines bestimmten Ziels oder einer bestimmten Rolle. Weitere Informationen finden Sie unter [System-Prompts](https://docs.anthropic.com/en/docs/system-prompts) in der Anthropic-Dokumentation.
**Anmerkung**
Sie können System-Prompts mit Anthropic Claude Version 2.1 oder höher verwenden.
+ **anthropic\$1beta** – (optional) Der anthropische Beta-Parameter ist eine Liste von Zeichenfolgen von Beta-Headern, die verwendet werden, um anzugeben, dass Sie sich für einen bestimmten Satz von Beta-Features entschieden haben.
**Anmerkung**
Die Variante mit einer Länge von 1 Million Token Claude Sonnet 4 steht Ihnen in ausgewählten AWS Regionen als „Beta-Service“ zur Verfügung, wie in den AWS Servicebedingungen definiert. Sie unterliegt Ihrer Vereinbarung mit AWS und den AWS Servicebedingungen sowie der geltenden Muster-EULA. Weitere Informationen zu den Preisen für längere Kontextanfragen finden Sie auf der Seite [Amazon Bedrock – Preise](https://aws.amazon.com/bedrock/pricing/). Es gelten separate Service Quotas (weitere Informationen finden Sie unter **Servicekontingenten** im AWS-Managementkonsole).
Verfügbare Beta-Header sind beispielsweise folgende:
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/bedrock/latest/userguide/model-parameters-anthropic-claude-messages-request-response.html)
+ **stop\$1sequences** – (optional) Benutzerdefinierte Textsequenzen, die dazu führen, dass das Modell nicht mehr generiert wird. Anthropic-Claude-Modelle stoppen normalerweise, wenn sie ihre Verarbeitung auf natürliche Weise beendet haben. In diesem Fall ist der Wert des `stop_reason`-Antwortfeldes `end_turn`. Wenn Sie möchten, dass das Modell nicht mehr generiert wird, wenn es auf benutzerdefinierte Textzeichenfolgen trifft, können Sie den `stop_sequences`-Parameter verwenden. Wenn das Modell auf eine der benutzerdefinierten Textzeichenfolgen trifft, lautet der Wert des `stop_reason`-Antwortfeldes `stop_sequence` und der Wert von `stop_sequence` enthält die übereinstimmende Stoppsequenz.
Die maximale Anzahl von Einträgen ist 8 191.
+ **temperature** – (optional) Die Menge an Zufälligkeit, die der Antwort hinzugefügt wurde.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/bedrock/latest/userguide/model-parameters-anthropic-claude-messages-request-response.html)
+ **top\$1p** – (optional) Verwenden Sie Nukleus-Sampling.
Beim Nukleus-Sampling berechnet Anthropic Claude die kumulative Verteilung über alle Optionen für jedes nachfolgende Token in absteigender Wahrscheinlichkeitsreihenfolge und beendet den Vorgang, sobald eine bestimmte, durch `top_p` festgelegte Wahrscheinlichkeit erreicht ist. Wenn Sie die Sampling-Parameter anpassen, ändern Sie entweder `temperature` oder `top_p`. Ändern Sie nicht beide gleichzeitig.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/bedrock/latest/userguide/model-parameters-anthropic-claude-messages-request-response.html)
+ **top\$1k** – (optional) Nehmen Sie für jedes nachfolgende Token nur Stichproben aus den Top-K-Optionen vor.
Verwenden Sie `top_k`, um Antworten mit langen Ausläufern und geringer Wahrscheinlichkeit zu entfernen.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/bedrock/latest/userguide/model-parameters-anthropic-claude-messages-request-response.html)
+ **tools** – (optional) Definitionen von Tools, die das Modell verwenden kann.
**Anmerkung**
Erfordert ein Modell von Anthropic Claude 3.
Wenn Sie `tools` in Ihrer Anforderung angeben, gibt das Modell möglicherweise `tool_use`-Inhaltsblöcke zurück, die die Verwendung dieser Tools durch das Modell darstellt. Sie können diese Tools dann mit der vom Modell generierten Tool-Eingabe ausführen und anschließend optional Ergebnisse mithilfe von `tool_result`-Inhaltsblöcken an das Modell zurückgeben.
Sie können die folgenden Tool-Typen übergeben:
**Benutzerdefiniert**
Definition für ein benutzerdefiniertes Tool.
+ (optional) **type** – Der Typ des Tools. Falls dieser definiert ist, verwenden Sie den Wert `custom`.
+ **name** – Der Name des Tools
+ **Beschreibung** – (optional, aber dringend empfohlen) die Beschreibung des Tools
+ **input\$1schema** – Das JSON-Schema für das Tool.
**Computer**
Definition für das Computer-Tool, das Sie mit der Computer-Use-API verwenden.
+ **type** – Der Wert muss `computer_20241022` sein.
+ **name** – Der Wert muss `computer` sein.
+ (Erforderlich) **display\$1height\$1px** – Die Höhe der Anzeige, die vom Modell gesteuert wird, in Pixeln.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/bedrock/latest/userguide/model-parameters-anthropic-claude-messages-request-response.html)
+ (Erforderlich) **display\$1width\$1px** – Die Breite der Anzeige, die vom Modell gesteuert wird, in Pixeln.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/bedrock/latest/userguide/model-parameters-anthropic-claude-messages-request-response.html)
+ (Optional) **display\$1number** – Die zu steuernde Anzeigenummer (nur relevant für X11-Umgebungen). Falls angegeben, erhält das Tool eine Anzeigenummer in der Tool-Definition.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/bedrock/latest/userguide/model-parameters-anthropic-claude-messages-request-response.html)
**bash**
Definition für das Bash-Tool, das Sie mit der Computer-Use-API verwenden.
+ (optional) **type** – Der Wert muss `bash_20241022` sein.
+ **name** – Der Wert muss `bash` sein und dem Tool entsprechen.
**Text-Editor**
Definition für das Text-Editor-Tool, das Sie mit der Computer-Use-API verwenden.
+ (optional) **type** – Der Wert muss `text_editor_20241022` sein.
+ **name** – Der Wert muss `str_replace_editor` sein und dem Tool entsprechen.
+ **tool\$1choice** – (optional) Gibt an, wie das Modell die bereitgestellten Tools verwenden soll. Das Modell kann ein bestimmtes Tool bzw. jedes verfügbare Tool verwenden oder selbst entscheiden.
**Anmerkung**
Erfordert ein Modell von Anthropic Claude 3.
+ **type** – Der Typ der Tool-Auswahl. Mögliche Werte sind `any` (jedes verfügbare Werkzeug verwenden), `auto` (das Modell entscheidet) und `tool` (das angegebene Tool verwenden).
+ **name** – (optional) Der Name des zu verwendenden Tools. Erforderlich, wenn Sie `tool` im Feld `type` angeben.
------
#### [ Response ]
Das Anthropic-Claude-Modell gibt die folgenden Felder für einen Inferenzaufruf für Nachrichten zurück.
```
{
"id": string,
"model": string,
"type" : "message",
"role" : "assistant",
"content": [
{
"type": string,
"text": string,
"image" :json,
"id": string,
"name":string,
"input": json
}
],
"stop_reason": string,
"stop_sequence": string,
"usage": {
"input_tokens": integer,
"output_tokens": integer
}
}
```
Beispielantworten mit neuen stop\$1reason-Werten:
```
// Example with refusal
{
"stop_reason": "refusal",
"content": [
{
"type": "text",
"text": "I can't help with that request."
}
]
}
// Example with tool_use
{
"stop_reason": "tool_use",
"content": [
{
"type": "tool_use",
"id": "toolu_123",
"name": "calculator",
"input": {"expression": "2+2"}
}
]
}
// Example with model_context_window_exceeded (Claude Sonnet 4.5)
{
"stop_reason": "model_context_window_exceeded",
"content": [
{
"type": "text",
"text": "The response was truncated due to context window limits..."
}
]
}
```
+ **ID** – Die eindeutige Kennung für die Antwort. Das Format und die Länge der ID können sich im Laufe der Zeit ändern.
+ **model** – Die ID für das Anthropic-Claude-Modell, das die Anfrage gestellt hat.
+ **stop\$1reason** – Der Grund, warum Anthropic Claude keine Antwort mehr generiert hat.
+ **end\$1turn** – Das Modell hat einen natürlichen Haltepunkt erreicht.
+ **max\$1tokens** – Der generierte Text hat den Wert des `max_tokens`-Eingabefeldes oder die maximale Anzahl von Token überschritten, die das Modell unterstützt.
+ **stop\$1sequence** – Das Modell hat eine der Stoppsequenzen generiert, die Sie im `stop_sequences`-Eingabefeld angegeben haben.
+ **Ablehnung** – Claude weigert sich aus Sicherheitsgründen, eine Antwort zu generieren.
+ **tool\$1use** – Claude ruft ein Tool auf und erwartet, dass Sie es ausführen.
+ **model\$1context\$1window\$1exceeded** – Das Modell hat die Generierung gestoppt, weil das Kontextfensterlimit erreicht wurde.
+ Neu mit Claude Sonnet 4.5
+ **stop\$1sequence** – Die Stoppsequenz, mit der die Generierung beendet wurde.
+ **type** – Die Art der Antwort Dieser Wert ist immer `message`.
+ **role** – Die Konversationsrolle der generierten Nachricht Dieser Wert ist immer `assistant`.
+ **Inhalt** – Der vom Modell generierte Inhalt. Als Array zurückgegeben. Es gibt drei Inhaltstypen: *text*, *tool\$1use* und *image*.
+ *text* – Eine Textantwort
+ **type** – Die Art des Inhalts Dieser Wert ist `text`.
+ **text** – Wenn der Wert des Felds `type` „text“ ist, enthält es den Text des Inhalts.
+ *tool use* – Eine Anfrage des Modells zur Verwendung eines Tools
+ **type** – Die Art des Inhalts Dieser Wert ist `tool_use`.
+ **id** – Die ID des Tools, dessen Verwendung das Modell anfordert
+ **name** – Enthält den Namen des angeforderten Tools
+ **input** – Die Eingabeparameter, die an das Tool übergeben werden sollen
+ *Image* – Eine Anfrage des Modells zur Verwendung eines Tools
+ **type** – Die Art des Inhalts Dieser Wert ist `image`.
+ **source** – Enthält das Bild Weitere Informationen finden Sie unter [Multimodale Prompts](model-parameters-anthropic-claude-messages.md#model-parameters-anthropic-claude-messages-multimodal-prompts).
+ **usage** – Container für die Anzahl der Token, die Sie in der Anfrage angegeben haben, und für die Anzahl der Token, die das Modell in der Antwort generiert hat
+ **input\$1tokens** – Die Anzahl der Eingabe-Token in der Anfrage
+ **output\$1tokens** – Die Anzahl der Token, die das Modell in der Antwort generiert hat
+ **stop\$1sequence** – Das Modell hat eine der Stoppsequenzen generiert, die Sie im `stop_sequences`-Eingabefeld angegeben haben.
------
## Aufwandsparameter (Beta)
Der `effort` Parameter ist eine Alternative zu denkenden Token-Budgets für Claude Opus 4.5. Dieser Parameter gibt an, Claude wie großzügig es Tokens ausgeben sollte, um das beste Ergebnis zu erzielen, und passt die Token-Nutzung je nach Denkweise, Toolaufrufen und Benutzerkommunikation an. Er kann mit oder ohne erweiterten Denkmodus verwendet werden.
Der Aufwandsparameter kann wie folgt eingestellt werden:
+ `high`(Standard) — Claude gibt so viele Token aus, wie für das beste Ergebnis erforderlich sind
+ `medium`— Ausgewogene Token-Nutzung
+ `low`— Konservative Token-Verwendung
Um diese Funktion nutzen zu können, müssen Sie den Beta-Header übergeben`effort-2025-11-24`.
Anfragebeispiel:
```
{
"anthropic_version": "bedrock-2023-05-31",
"anthropic_beta": [
"effort-2025-11-24"
],
"max_tokens": 4096,
"output_config": {
"effort": "medium"
},
"messages": [{
"role": "user",
"content": "Analyze this complex dataset and provide insights"
}]
}
```
# Codebeispiele
Die folgenden Codebeispiele zeigen, wie Sie die Nachrichten-API verwenden.
**Topics**
+ [Beispiel für Nachrichten-Code](#api-inference-examples-claude-messages-code-example)
+ [Multimodale Code-Beispiele](#api-inference-examples-claude-multimodal-code-example)
## Beispiel für Nachrichten-Code
Dieses Beispiel zeigt, wie eine Single-Turn-Benutzernachricht und ein Benutzer-Turn mit einer vorausgefüllten Assistentennachricht an ein Anthropic Claude 3 Sonnet-Modell gesendet werden.
```
# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
# SPDX-License-Identifier: Apache-2.0
"""
Shows how to generate a message with Anthropic Claude (on demand).
"""
import boto3
import json
import logging
from botocore.exceptions import ClientError
logger = logging.getLogger(__name__)
logging.basicConfig(level=logging.INFO)
def generate_message(bedrock_runtime, model_id, system_prompt, messages, max_tokens):
body=json.dumps(
{
"anthropic_version": "bedrock-2023-05-31",
"max_tokens": max_tokens,
"system": system_prompt,
"messages": messages
}
)
response = bedrock_runtime.invoke_model(body=body, modelId=model_id)
response_body = json.loads(response.get('body').read())
return response_body
def main():
"""
Entrypoint for Anthropic Claude message example.
"""
try:
bedrock_runtime = boto3.client(service_name='bedrock-runtime')
model_id = 'anthropic.claude-3-sonnet-20240229-v1:0'
system_prompt = "Please respond only with emoji."
max_tokens = 1000
# Prompt with user turn only.
user_message = {"role": "user", "content": "Hello World"}
messages = [user_message]
response = generate_message (bedrock_runtime, model_id, system_prompt, messages, max_tokens)
print("User turn only.")
print(json.dumps(response, indent=4))
# Prompt with both user turn and prefilled assistant response.
#Anthropic Claude continues by using the prefilled assistant text.
assistant_message = {"role": "assistant", "content": ""}
messages = [user_message, assistant_message]
response = generate_message(bedrock_runtime, model_id,system_prompt, messages, max_tokens)
print("User turn and prefilled assistant response.")
print(json.dumps(response, indent=4))
except ClientError as err:
message=err.response["Error"]["Message"]
logger.error("A client error occurred: %s", message)
print("A client error occurred: " +
format(message))
if __name__ == "__main__":
main()
```
## Multimodale Code-Beispiele
Die folgenden Beispiele zeigen, wie ein Bild und ein Prompt in einer multimodalen Nachricht an ein Anthropic Claude 3 Sonnet-Modell weitergegeben werden.
**Topics**
+ [Multimodale Aufforderung mit InvokeModel](#api-inference-examples-claude-multimodal-code-example-invoke-model)
+ [Multimodale Eingabeaufforderung streamen mit InvokeModelWithResponseStream](#api-inference-examples-claude-multimodal-code-example-streaming)
### Multimodale Aufforderung mit InvokeModel
Das folgende Beispiel zeigt, wie eine multimodale Aufforderung an with gesendet wird. Anthropic Claude 3 Sonnet [InvokeModel](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModel.html)
```
# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
# SPDX-License-Identifier: Apache-2.0
"""
Shows how to run a multimodal prompt with Anthropic Claude (on demand) and InvokeModel.
"""
import json
import logging
import base64
import boto3
from botocore.exceptions import ClientError
logger = logging.getLogger(__name__)
logging.basicConfig(level=logging.INFO)
def run_multi_modal_prompt(bedrock_runtime, model_id, messages, max_tokens):
"""
Invokes a model with a multimodal prompt.
Args:
bedrock_runtime: The Amazon Bedrock boto3 client.
model_id (str): The model ID to use.
messages (JSON) : The messages to send to the model.
max_tokens (int) : The maximum number of tokens to generate.
Returns:
None.
"""
body = json.dumps(
{
"anthropic_version": "bedrock-2023-05-31",
"max_tokens": max_tokens,
"messages": messages
}
)
response = bedrock_runtime.invoke_model(
body=body, modelId=model_id)
response_body = json.loads(response.get('body').read())
return response_body
def main():
"""
Entrypoint for Anthropic Claude multimodal prompt example.
"""
try:
bedrock_runtime = boto3.client(service_name='bedrock-runtime')
model_id = 'anthropic.claude-3-sonnet-20240229-v1:0'
max_tokens = 1000
input_text = "What's in this image?"
input_image = "/path/to/image" # Replace with actual path to image file
# Read reference image from file and encode as base64 strings.
image_ext = input_image.split(".")[-1]
with open(input_image, "rb") as image_file:
content_image = base64.b64encode(image_file.read()).decode('utf8')
message = {
"role": "user",
"content": [
{
"type": "image",
"source": {
"type": "base64",
"media_type": f"image/{image_ext}",
"data": content_image
}
},
{
"type": "text",
"text": input_text
}
]
}
messages = [message]
response = run_multi_modal_prompt(
bedrock_runtime, model_id, messages, max_tokens)
print(json.dumps(response, indent=4))
except ClientError as err:
message = err.response["Error"]["Message"]
logger.error("A client error occurred: %s", message)
print("A client error occurred: " +
format(message))
if __name__ == "__main__":
main()
```
### Multimodale Eingabeaufforderung streamen mit InvokeModelWithResponseStream
Das folgende Beispiel zeigt, wie die Antwort von einer multimodalen Aufforderung gestreamt wird, die an Anthropic Claude 3 Sonnet with gesendet wurde. [InvokeModelWithResponseStream](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModelWithResponseStream.html)
```
# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
# SPDX-License-Identifier: Apache-2.0
"""
Shows how to stream the response from Anthropic Claude Sonnet (on demand) for a
multimodal request.
"""
import json
import base64
import logging
import boto3
from botocore.exceptions import ClientError
logger = logging.getLogger(__name__)
logging.basicConfig(level=logging.INFO)
def stream_multi_modal_prompt(bedrock_runtime, model_id, input_text, image, max_tokens):
"""
Streams the response from a multimodal prompt.
Args:
bedrock_runtime: The Amazon Bedrock boto3 client.
model_id (str): The model ID to use.
input_text (str) : The prompt text
image (str) : The path to an image that you want in the prompt.
max_tokens (int) : The maximum number of tokens to generate.
Returns:
None.
"""
with open(image, "rb") as image_file:
encoded_string = base64.b64encode(image_file.read())
body = json.dumps({
"anthropic_version": "bedrock-2023-05-31",
"max_tokens": max_tokens,
"messages": [
{
"role": "user",
"content": [
{"type": "text", "text": input_text},
{"type": "image", "source": {"type": "base64",
"media_type": "image/jpeg", "data": encoded_string.decode('utf-8')}}
]
}
]
})
response = bedrock_runtime.invoke_model_with_response_stream(
body=body, modelId=model_id)
for event in response.get("body"):
chunk = json.loads(event["chunk"]["bytes"])
if chunk['type'] == 'message_delta':
print(f"\nStop reason: {chunk['delta']['stop_reason']}")
print(f"Stop sequence: {chunk['delta']['stop_sequence']}")
print(f"Output tokens: {chunk['usage']['output_tokens']}")
if chunk['type'] == 'content_block_delta':
if chunk['delta']['type'] == 'text_delta':
print(chunk['delta']['text'], end="")
def main():
"""
Entrypoint for Anthropic Claude Sonnet multimodal prompt example.
"""
model_id = "anthropic.claude-3-sonnet-20240229-v1:0"
input_text = "What can you tell me about this image?"
image = "/path/to/image"
max_tokens = 100
try:
bedrock_runtime = boto3.client('bedrock-runtime')
stream_multi_modal_prompt(
bedrock_runtime, model_id, input_text, image, max_tokens)
except ClientError as err:
message = err.response["Error"]["Message"]
logger.error("A client error occurred: %s", message)
print("A client error occured: " +
format(message))
if __name__ == "__main__":
main()
```
# Unterstützte Modelle
Sie können die Nachrichten-API mit den folgenden Anthropic-Claude-Modellen verwenden.
+ AnthropicClaude Opus4.5
+ AnthropicClaude Opus4.1
+ AnthropicClaude Opus4
+ Anthropic Claude Sonnet 4.5
+ Anthropic Claude Haiku 4.5
+ Anthropic Claude Sonnet 4
+ Anthropic Claude 3.7 Sonnet
+ Anthropic Claude 3.5 Sonnet v2
+ Anthropic Claude 3.5 Sonnet
+ Anthropic Claude 3 Opus
+ Anthropic Claude 3 Sonnet
+ Anthropic Claude 3 Haiku
+ Anthropic Claude 2 v2.1
+ Anthropic Claude 2 v2
+ Anthropic Claude Instant v1.2
# Modelle von AI21 Labs
In diesem Abschnitt werden die Anforderungsparameter und Antwortfelder für Modelle von AI21 Labs beschrieben. Verwenden Sie diese Informationen, um mit den (Streaming-) Operationen [InvokeModel](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModel.html) und [InvokeModelWithResponseStream](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModelWithResponseStream.html) Inferenzaufrufe an Modelle von AI21 Labs durchzuführen. Dieser Abschnitt enthält auch Python-Codebeispiele, die zeigen, wie Modelle von AI21 Labs aufgerufen werden. Sie benötigen die Modell-ID für das Modell, um ein Modell in einer Inferenzoperation verwenden zu können. Informationen zum Abrufen der Modell-ID finden Sie unter [Unterstützte Basismodelle in Amazon Bedrock](models-supported.md). Einige Modelle funktionieren auch mit der [Converse-API](conversation-inference.md). Informationen darüber, ob die Converse-API ein bestimmtes Modell von AI21 Labs unterstützt, finden Sie unter [Unterstützte Modelle und Modellfeatures](conversation-inference-supported-models-features.md). Weitere Codebeispiele finden Sie unter [Codebeispiele für Amazon Bedrock mit AWS SDKs](service_code_examples.md).
Basismodelle in Amazon Bedrock unterstützen Eingabe- und Ausgabemodalitäten, die von Modell zu Modell variieren. Informationen zu den Modalitäten, die von Modellen von AI21 Labs unterstützt werden, finden Sie unter [Unterstützte Basismodelle in Amazon Bedrock](models-supported.md). Informationen darüber, welche Amazon-Bedrock-Features die Modelle von AI21 Labs unterstützen, finden Sie unter [Unterstützte Basismodelle in Amazon Bedrock](models-supported.md). Informationen darüber, in welchen AWS-Regionen diese Modelle von AI21 Labs verfügbar sind, finden Sie unter [Unterstützte Basismodelle in Amazon Bedrock](models-supported.md).
Wenn Sie Inferenzaufrufe mit Modellen von AI21 Labs tätigen, schließen Sie einen Prompt für das Modell ein. Allgemeine Informationen zum Erstellen von Prompts für die Modelle, die von Amazon Bedrock unterstützt werden, finden Sie unter [Prompt-Engineering-Konzepte](prompt-engineering-guidelines.md). Für AI21 Labs spezifische Informationen zu Prompts finden Sie im [Handbuch zu Prompt-Engineering von AI21 Labs](https://docs.ai21.com/docs/prompt-engineering).
**Topics**
+ [Jurassic-2-Modelle von AI21 Labs](model-parameters-jurassic2.md)
+ [Jamba-Modelle von AI21 Labs](model-parameters-jamba.md)
# Jurassic-2-Modelle von AI21 Labs
Dieser Abschnitt enthält Inferenzparameter und ein Codebeispiel für die Verwendung von AI21 Labs Jurassic-2-Modellen von AI21 Labs.
**Topics**
+ [Inferenzparameter](#model-parameters-jurassic2-request-response)
+ [Codebeispiel](#api-inference-examples-a2i-jurassic)
## Inferenzparameter
Die Jurassic-2-Modelle von AI21 Labs unterstützen die folgenden Inferenzparameter.
**Topics**
+ [Zufälligkeit und Diversität](#model-parameters-jurassic2-random)
+ [Länge](#model-parameters-jurassic2-length)
+ [Wiederholungen](#model-parameters-jurassic2-reps)
+ [Textfeld für die Modellaufrufanforderung](#model-parameters-jurassic2-request-body)
+ [Textfeld für die Modellaufruf-Antwort](#model-parameters-jurassic2-response-body)
### Zufälligkeit und Diversität
Jurassic-2-Modelle von AI21 Labs unterstützen die folgenden Parameter, um die Zufälligkeit und Diversität der Antwort zu kontrollieren.
+ **Temperatur** (`temperature`) – Verwenden Sie einen niedrigeren Wert, um die Zufälligkeit der Antwort zu verringern.
+ **Top-P** (`topP`) – Verwenden Sie einen niedrigeren Wert, um weniger wahrscheinliche Optionen zu ignorieren.
### Länge
Jurassic-2-Modelle von AI21 Labs unterstützen die folgenden Parameter, um die Länge der generierten Antwort zu steuern.
+ **Maximale Vervollständigungslänge** (`maxTokens`) – Geben Sie die maximale Anzahl von Token an, die in der generierten Antwort verwendet werden soll.
+ **Stoppsequenzen** (`stopSequences`) – Konfigurieren Sie Stoppsequenzen, die das Modell erkennt und nach deren Auftreten es die Generierung weiterer Token beendet. Drücken Sie die Eingabetaste, um ein Zeilenumbruchzeichen in eine Stoppsequenz einzufügen. Verwenden Sie die Tabulatortaste, um das Einfügen einer Stoppsequenz abzuschließen.
### Wiederholungen
Jurassic-2-Modelle von AI21 Labs unterstützen die folgenden Parameter, um Wiederholungen in der generierten Antwort zu steuern.
+ **Präsenzstrafe** (`presencePenalty`) – Verwenden Sie einen höheren Wert, um die Wahrscheinlichkeit zu verringern, dass neue Token generiert werden, die bereits mindestens einmal in der Eingabeaufforderung oder in der Vervollständigung vorkommen.
+ **Zählerstrafe** (`countPenalty`) – Verwenden Sie einen höheren Wert, um die Wahrscheinlichkeit zu verringern, dass neue Token generiert werden, die bereits mindestens einmal in der Eingabeaufforderung oder in der Vervollständigung vorkommen. Proportional zur Anzahl der Vorkommen
+ **Häufigkeitsstrafe** (`frequencyPenalty`) – Verwenden Sie einen hohen Wert, um die Wahrscheinlichkeit zu verringern, dass neue Token generiert werden, die bereits mindestens einmal in der Eingabeaufforderung oder in der Vervollständigung vorkommen. Der Wert ist proportional zur Häufigkeit der Token-Vorkommen (normalisiert auf die Textlänge).
+ **Strafe für spezielle Token** – Verringern Sie die Wahrscheinlichkeit, dass sich Sonderzeichen wiederholen. Die Standard-Werte sind `true`.
+ **Leerzeichen** (`applyToWhitespaces`) – Mit dem Wert `true` wird die Strafe auf Leerzeichen und Zeilenumbrüche angewendet.
+ **Interpunktionen** (`applyToPunctuation`) – Mit dem Wert `true` wird die Strafe auf Satzzeichen angewendet.
+ **Zahlen** (`applyToNumbers`) – Mit dem Wert `true` wird die Strafe auf Zahlen angewendet.
+ **Stoppwörter** (`applyToStopwords`) – Mit dem Wert `true` wird die Strafe auf Stoppwörter angewendet.
+ **Emojis** (`applyToEmojis`) – Mit dem Wert `true` werden Emojis von der Strafe ausgeschlossen.
### Textfeld für die Modellaufrufanforderung
Wenn Sie mit einem Modell von AI21 Labs einen [InvokeModel](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModel.html)- oder [InvokeModelWithResponseStream](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModelWithResponseStream.html)-Aufruf ausführen, füllen Sie das `body`-Feld mit einem JSON-Objekt aus, das dem unten stehenden entspricht. Geben Sie die Eingabeaufforderung in das Feld `prompt` ein.
```
{
"prompt": string,
"temperature": float,
"topP": float,
"maxTokens": int,
"stopSequences": [string],
"countPenalty": {
"scale": float
},
"presencePenalty": {
"scale": float
},
"frequencyPenalty": {
"scale": float
}
}
```
Wenn Sie spezielle Token bestrafen möchten, fügen Sie diese Felder einem beliebigen Strafobjekt hinzu. Sie können das Feld `countPenalty` beispielsweise wie folgt ändern.
```
"countPenalty": {
"scale": float,
"applyToWhitespaces": boolean,
"applyToPunctuations": boolean,
"applyToNumbers": boolean,
"applyToStopwords": boolean,
"applyToEmojis": boolean
}
```
Die folgende Tabelle zeigt die minimalen, maximalen und standardmäßigen Werte für die numerischen Parameter.
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/bedrock/latest/userguide/model-parameters-jurassic2.html)
### Textfeld für die Modellaufruf-Antwort
Informationen zum Format des Felds `body` in der Antwort finden Sie unter [https://docs.ai21.com/reference/j2-complete-api-ref](https://docs.ai21.com/reference/j2-complete-api-ref).
**Anmerkung**
Amazon Bedrock gibt die Antwort-ID (`id`) als Ganzzahl zurück.
## Codebeispiel
Dieses Beispiel zeigt, wie das Modell *A2I Jurassic-2 Mid von AI21 Labs* aufgerufen wird.
```
import boto3
import json
brt = boto3.client(service_name='bedrock-runtime')
body = json.dumps({
"prompt": "Translate to spanish: 'Amazon Bedrock is the easiest way to build and scale generative AI applications with base models (FMs)'.",
"maxTokens": 200,
"temperature": 0.5,
"topP": 0.5
})
modelId = 'ai21.j2-mid-v1'
accept = 'application/json'
contentType = 'application/json'
response = brt.invoke_model(
body=body,
modelId=modelId,
accept=accept,
contentType=contentType
)
response_body = json.loads(response.get('body').read())
# text
print(response_body.get('completions')[0].get('data').get('text'))
```
# Jamba-Modelle von AI21 Labs
Dieser Abschnitt enthält Inferenzparameter und ein Codebeispiel für die Verwendung von Jamba-Modellen von AI21 Labs.
**Topics**
+ [Pflichtfelder](#model-parameters-jamba-required-fields)
+ [Inferenzparameter](#model-parameters-jamba-request-response)
+ [Textfeld für die Modellaufrufanforderung](#model-parameters-jamba-request-body)
+ [Textfeld für die Modellaufruf-Antwort](#model-parameters-jamba-response-body)
+ [Codebeispiel](#api-inference-examples-a2i-jamba)
+ [Codebeispiel für Jamba 1.5 Large](#api-inference-examples-a2i-jamba15-large)
## Pflichtfelder
Die Jamba-Modelle von AI21 Labs unterstützen die folgenden Pflichtfelder:
+ **Nachrichten** (`messages`) – Die vorherigen Nachrichten in diesem Chat, von der ältesten (Index 0) bis zur neuesten. Die Liste muss mindestens eine Benutzer- oder Assistentennachricht enthalten. Schließen Sie sowohl Benutzereingaben als auch Systemantworten ein. Die maximale Gesamtgröße für die Liste beträgt etwa 256 000 Token. Jede Nachricht umfasst die folgenden Mitglieder:
+ **Rolle** (`role`) – Die Rolle des Nachrichtenautors. Einer der folgenden Werte:
+ **Benutzer** (`user`) – Vom Benutzer bereitgestellte Eingabe. Alle hier angegebenen Anweisungen, die im Widerspruch zu den Anweisungen im `system`-Prompt stehen, haben Vorrang vor den Anweisungen im `system`-Prompt.
+ **Assistent** (`assistant`) – Vom Modell generierte Antwort
+ **System** (`system`) – Erste Anweisungen an das System mit allgemeinen Hinweisen zu Tonfall und Stimme der generierten Nachricht. Eine erste Systemnachricht ist optional, wird jedoch empfohlen, um Hinweise zum Tonfall des Chats zu geben. Zum Beispiel: „Sie sind ein hilfreicher Chatbot mit einem Hintergrund in Geowissenschaften und einem charmanten französischen Akzent.“
+ **Inhalt** (`content`) – Der Inhalt der Nachricht
## Inferenzparameter
Jamba-Modelle von AI21 Labs unterstützen die folgenden Inferenzparameter.
**Topics**
+ [Zufälligkeit und Diversität](#model-parameters-jamba-random)
+ [Länge](#model-parameters-jamba-length)
+ [Wiederholungen](#model-parameters-jamba-reps)
### Zufälligkeit und Diversität
Jamba-Modelle von AI21 Labs unterstützen in der Regel die folgenden Parameter, um die Zufälligkeit und Diversität der Antwort zu kontrollieren.
+ **Temperatur** (`temperature`) – Wie viel Variation bei jeder Antwort angegeben werden soll. Wenn Sie diesen Wert auf 0 einstellen, wird garantiert, dass jedes Mal dieselbe Antwort auf dieselbe Frage gegeben wird. Ein höherer Wert führt zu mehr Variation. Ändert die Distribution, aus der Token erfasst werden. Standard: 1,0, Wertebereich: 0,0–2,0
+ **Top P** (`top_p`) – Beschränkt den Pool der nächsten Token in jedem Schritt auf das oberste N-Perzentil der möglichen Token, wobei 1,0 den Pool aller möglichen Token und 0,01 den Pool nur der wahrscheinlichsten nächsten Token bedeutet.
### Länge
Jamba-Modelle von AI21 Labs unterstützen die folgenden Parameter, um die Länge der generierten Antwort zu steuern.
+ **Max. Dauer des Abschlusses** (`max_tokens`) – Die maximale Anzahl von Token, die für jede generierte Antwortnachricht zulässig sind. In der Regel ist es am besten, die Länge der Ausgabe zu begrenzen, indem Sie im System-Prompt eine Längenbeschränkung angeben (z. B. „Beschränken Sie die Antworten auf drei Sätze“). Standard: 4 096, Wertebereich: 0–4 096
+ **Sequenzen beenden** (`stop`) – Beendet die Nachricht, wenn das Modell eine dieser Zeichenfolgen generiert. Die Stoppsequenz ist nicht in der generierten Nachricht enthalten. Jede Sequenz kann bis zu 64 KB lang sein und Zeilenumbrüche als\$1n Zeichen enthalten.
Beispiele:
+ Einfache Stoppzeichenfolge mit einem Wort und einem Punkt: „Affen.“
+ Mehrere Stoppzeichenfolgen und eine neue Zeile: [„Katze“, „Hund“, „ .“, „\$1\$1\$1\$1“, "\$1n„]
+ **Anzahl der Antworten** (`n`) – Wie viele Chat-Antworten generiert werden sollen. Hinweise n muss 1 sein, damit Antworten gestreamt werden können. Wenn n auf einen Wert größer als 1 festgelegt wird, schlägt die Einstellung `temperature=0` immer fehl, da es sich bei allen Antworten garantiert um Duplikate handelt. Standard: 1, Wertebereich: 1–16
### Wiederholungen
Jamba-Modelle von AI21 Labs unterstützen die folgenden Parameter, um Wiederholungen in der generierten Antwort zu steuern.
+ **Häufigkeitsstrafe** (`frequency_penalty`) – Reduzieren Sie die Häufigkeit wiederholter Wörter in einer einzelnen Antwortnachricht, indem Sie diese Zahl erhöhen. Diese Strafe nimmt allmählich zu, je öfter ein Wort während der Antwortgenerierung vorkommt. Bei der Einstellung 2,0 wird eine Zeichenfolge mit wenigen, wenn überhaupt, sich wiederholenden Wörtern erzeugt.
+ **Präsenzstrafe** (`presence_penalty`) – Reduzieren Sie die Häufigkeit wiederholter Wörter in einer einzelnen Nachricht, indem Sie diese Zahl erhöhen. Im Gegensatz zur Häufigkeitsstrafe ist die Präsenzstrafe immer gleich, egal wie oft ein Wort vorkommt.
## Textfeld für die Modellaufrufanforderung
Wenn Sie mit einem Modell von AI21 Labs einen [InvokeModel](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModel.html)- oder [InvokeModelWithResponseStream](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModelWithResponseStream.html)-Aufruf ausführen, füllen Sie das `body`-Feld mit einem JSON-Objekt aus, das dem unten stehenden entspricht. Geben Sie die Eingabeaufforderung in das Feld `prompt` ein.
```
{
"messages": [
{
"role":"system", // Non-printing contextual information for the model
"content":"You are a helpful history teacher. You are kind and you respond with helpful content in a professional manner. Limit your answers to three sentences. Your listener is a high school student."
},
{
"role":"user", // The question we want answered.
"content":"Who was the first emperor of rome?"
}
],
"n":1 // Limit response to one answer
}
```
## Textfeld für die Modellaufruf-Antwort
Informationen zum Format des Felds `body` in der Antwort finden Sie unter [https://docs.ai21.com/reference/jamba-instruct-api\$1response-details](https://docs.ai21.com/reference/jamba-instruct-api#response-details).
## Codebeispiel
Dieses Beispiel zeigt, wie das *Jamba-Instruct-Modell von AI21 Labs* aufgerufen wird.
**`invoke_model`**
```
import boto3
import json
bedrock = session.client('bedrock-runtime', 'us-east-1')
response = bedrock.invoke_model(
modelId='ai21.jamba-instruct-v1:0',
body=json.dumps({
'messages': [
{
'role': 'user',
'content': 'which llm are you?'
}
],
})
)
print(json.dumps(json.loads(response['body']), indent=4))
```
**Converse**
```
import boto3
import json
bedrock = session.client('bedrock-runtime', 'us-east-1')
response = bedrock.converse(
modelId='ai21.jamba-instruct-v1:0',
messages=[
{
'role': 'user',
'content': [
{
'text': 'which llm are you?'
}
]
}
]
)
print(json.dumps(json.loads(response['body']), indent=4))
```
## Codebeispiel für Jamba 1.5 Large
Dieses Beispiel zeigt, wie das *Modell Jamba 1.5 Large von AI21 Labs* aufgerufen wird.
**`invoke_model`**
```
POST https://bedrock-runtime.us-east-1.amazonaws.com/model/ai21.jamba-1-5-mini-v1:0/invoke-model HTTP/1.1
{
"messages": [
{
"role": "system",
"content": "You are a helpful chatbot with a background in earth sciences and a charming French accent."
},
{
"role": "user",
"content": "What are the main causes of earthquakes?"
}
],
"max_tokens": 512,
"temperature": 0.7,
"top_p": 0.9,
"stop": ["###"],
"n": 1
}
```
# Modelle von Cohere
In diesem Abschnitt werden die Anforderungsparameter und Antwortfelder für Modelle von Cohere beschrieben. Verwenden Sie diese Informationen, um mit den (Streaming-) Operationen [InvokeModel](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModel.html) und [InvokeModelWithResponseStream](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModelWithResponseStream.html) Inferenzaufrufe an Modelle von Cohere durchzuführen. Dieser Abschnitt enthält auch Python-Codebeispiele, die zeigen, wie Modelle von Cohere aufgerufen werden. Sie benötigen die Modell-ID für das Modell, um ein Modell in einer Inferenzoperation verwenden zu können. Informationen zum Abrufen der Modell-ID finden Sie unter [Unterstützte Basismodelle in Amazon Bedrock](models-supported.md). Einige Modelle funktionieren auch mit der [Converse-API](conversation-inference.md). Informationen darüber, ob die Converse-API ein bestimmtes Modell von Cohere unterstützt, finden Sie unter [Unterstützte Modelle und Modellfeatures](conversation-inference-supported-models-features.md). Weitere Codebeispiele finden Sie unter [Codebeispiele für Amazon Bedrock mit AWS SDKs](service_code_examples.md).
Basismodelle in Amazon Bedrock unterstützen Eingabe- und Ausgabemodalitäten, die von Modell zu Modell variieren. Informationen zu den Modalitäten, die von Modellen von Cohere unterstützt werden, finden Sie unter [Unterstützte Basismodelle in Amazon Bedrock](models-supported.md). Informationen darüber, welche Amazon-Bedrock-Features die Modelle von Cohere unterstützen, finden Sie unter [Unterstützte Basismodelle in Amazon Bedrock](models-supported.md). Informationen darüber, in welchen AWS-Regionen diese Modelle von Cohere verfügbar sind, finden Sie unter [Unterstützte Basismodelle in Amazon Bedrock](models-supported.md).
Wenn Sie Inferenzaufrufe mit Modellen von Cohere tätigen, schließen Sie einen Prompt für das Modell ein. Allgemeine Informationen zum Erstellen von Prompts für die Modelle, die von Amazon Bedrock unterstützt werden, finden Sie unter [Prompt-Engineering-Konzepte](prompt-engineering-guidelines.md). Für Cohere spezifische Informationen zu Prompts finden Sie im [Handbuch zu Prompt-Engineering von Cohere](https://txt.cohere.com/how-to-train-your-pet-llm-prompt-engineering).
**Topics**
+ [Command-Modelle von Cohere](model-parameters-cohere-command.md)
+ [Die Modelle Cohere Embed und Cohere Embed v4](model-parameters-embed.md)
+ [Die Modelle Cohere Command R und Command R\$1](model-parameters-cohere-command-r-plus.md)
# Command-Modelle von Cohere
Mit [InvokeModel](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModel.html) oder [InvokeModelWithResponseStream](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModelWithResponseStream.html) (Streaming) nehmen Sie Inferenzanforderungen an Command-Modelle von Cohere vor. 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).
**Topics**
+ [Anforderung und Antwort](#model-parameters-cohere-command-request-response)
+ [Codebeispiel](#api-inference-examples-cohere-command)
## Anforderung und Antwort
------
#### [ Request ]
Die Cohere-Command-Modelle haben die folgenden Inferenzparameter.
```
{
"prompt": string,
"temperature": float,
"p": float,
"k": float,
"max_tokens": int,
"stop_sequences": [string],
"return_likelihoods": "GENERATION|ALL|NONE",
"stream": boolean,
"num_generations": int,
"logit_bias": {token_id: bias},
"truncate": "NONE|START|END"
}
```
Die folgenden Parameter sind erforderlich.
+ **prompt** – (erforderlich) Der Eingabetext, der als Ausgangspunkt für die Generierung der Antwort dient.
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-cohere-command.html)
**Zeichen**
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/bedrock/latest/userguide/model-parameters-cohere-command.html)
Die folgenden Parameter sind optional.
+ return\$1likelihoods – Geben Sie an, wie und ob die Token-Wahrscheinlichkeiten zusammen mit der Antwort zurückgegeben werden. Sie können die folgenden Optionen angeben:
+ `GENERATION` – Gibt nur Wahrscheinlichkeiten für generierte Token zurück.
+ `ALL` – Gibt Wahrscheinlichkeiten für alle Token zurück.
+ `NONE` – (Standard) gibt keine Wahrscheinlichkeiten zurück.
+ **stream** – (erforderlich, um Streaming zu unterstützen) Mit `true` wird die Antwort Stück für Stück in Echtzeit und mit `false` vollständig nach Abschluss des Vorgangs zurückgegeben.
+ **logit\$1bias** – Dieser Wert verhindert, dass das Modell unerwünschte Token generiert, oder bietet Anreize für das Modell, die gewünschten Token einzubeziehen. Das Format lautet `{token_id: bias}`, wobei „bias“ eine Gleitkommazahl zwischen -10 und 10 ist. Token können mithilfe eines beliebigen Tokenisierungsdienstes, z. B. mit dem Tokenize-Endpunkt von Cohere, aus Text abgerufen werden. Weitere Informationen finden Sie in der [Cohere-Dokumentation](https://docs.cohere.com/docs).
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/bedrock/latest/userguide/model-parameters-cohere-command.html)
+ **num\$1generations** – Die maximale Anzahl der Generierungen, die das Modell zurückgeben soll
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/bedrock/latest/userguide/model-parameters-cohere-command.html)
+ **truncate** (kürzen) – Gibt an, wie die API Eingaben verarbeitet, die die maximale Token-Länge überschreiten. Nutzen Sie einen der Folgenden:
+ `NONE` – Gibt einen Fehler zurück, wenn die Eingabe die maximale Länge des Eingabe-Tokens überschreitet.
+ `START` – Verwirft den Anfang der Eingabe.
+ `END` – (Standard) 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.
+ **Temperatur** – Verwenden Sie einen niedrigeren Wert, um die Zufälligkeit der Antwort zu verringern.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/bedrock/latest/userguide/model-parameters-cohere-command.html)
+ **p** – Verwenden Sie einen niedrigeren Wert, um weniger wahrscheinliche Optionen zu ignorieren. Legen Sie den Wert auf 0 oder 1,0 fest, um den Parameter zu deaktivieren. Wenn `p` sowohl als auch `k` aktiviert sind, wird `p` nach `k` aktiv.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/bedrock/latest/userguide/model-parameters-cohere-command.html)
+ **k** – Geben Sie die Anzahl der Token-Optionen an, die das Modell zur Generierung des nächsten Tokens verwendet. Wenn `p` sowohl als auch `k` aktiviert sind, wird `p` nach `k` aktiv.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/bedrock/latest/userguide/model-parameters-cohere-command.html)
+ **max\$1tokens** – Geben Sie die maximale Anzahl von Token an, die in der generierten Antwort verwendet werden soll.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/bedrock/latest/userguide/model-parameters-cohere-command.html)
+ **stop\$1sequences** – Konfigurieren Sie bis zu vier Sequenzen, die das Modell erkennt. Nach einer Stoppsequenz stoppt das Modell die Generierung weiterer Token. Der zurückgegebene Text enthält keine Stoppsequenz.
------
#### [ Response ]
Die Antwort enthält folgende mögliche Felder:
```
{
"generations": [
{
"finish_reason": "COMPLETE | MAX_TOKENS | ERROR | ERROR_TOXIC",
"id": string,
"text": string,
"likelihood" : float,
"token_likelihoods" : [{"token" : string, "likelihood": float}],
"is_finished" : true | false,
"index" : integer
}
],
"id": string,
"prompt": string
}
```
+ `generations` – Eine Liste der generierten Ergebnisse zusammen mit den Wahrscheinlichkeiten für die angeforderten Token. (Immer zurückgegeben) Jedes Generierungsobjekt in der Liste umfasst die folgenden Felder.
+ `id` – Eine Kennung für die Generation. (Immer zurückgegeben)
+ `likelihood` – Die Wahrscheinlichkeit der Ausgabe. Der Wert ist der Durchschnitt der Token-Wahrscheinlichkeiten in `token_likelihoods`. Wird zurückgegeben, wenn Sie den Eingabeparameter `return_likelihoods` angeben.
+ `token_likelihoods` – Ein Array von Wahrscheinlichkeiten pro Token. Wird zurückgegeben, wenn Sie den Eingabeparameter `return_likelihoods` angeben.
+ `finish_reason` – Hiermit wird der Grund angegeben, warum das Modell die Token-Generierung abgeschlossen hat. `COMPLETE` – Das Modell hat eine fertige Antwort zurückgesendet. `MAX_TOKENS` – Die Antwort wurde gekürzt, weil das Modell die maximale Anzahl von Token für seine Kontextlänge erreicht hatte. `ERROR ` – Bei der Generierung der Antwort ist ein Fehler aufgetreten. `ERROR_TOXIC` – Das Modell generierte eine Antwort, die als toxisch eingestuft wurde. `finish_reason` wird nur zurückgegeben, wenn `is_finished` = `true` ist. (Nicht immer zurückgegeben)
+ `is_finished` – Ein boolesches Feld, das nur verwendet wird, wenn `stream` gleich `true` ist. Es gibt an, ob zusätzliche Token im Rahmen der Streaming-Antwort generiert werden oder nicht. (Nicht immer zurückgegeben)
+ `text` – Der generierte Text.
+ `index` – Wird in einer Streaming-Antwort verwendet, um festzustellen, zu welcher Generation ein bestimmtes Token gehört. Wenn nur eine Antwort gestreamt wird, gehören alle Token derselben Generation an und der Index wird nicht zurückgegeben. `index` wird daher nur in einer Streaming-Anfrage zurückgegeben, deren Wert für `num_generations` größer als eins ist.
+ `prompt` – Der Prompt aus der Eingabeanforderung (wird immer zurückgegeben).
+ `id` – Eine Kennung für die Anforderung (immer zurückgegeben).
Weitere Informationen finden Sie unter [Generieren](https://docs.cohere.com/reference/generate-1) in der Cohere-Dokumentation.
------
## Codebeispiel
Dieses Beispiel zeigt, wie das Modell *Cohere Command* aufgerufen wird.
```
# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
# SPDX-License-Identifier: Apache-2.0
"""
Shows how to generate text using a Cohere 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 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)
accept = 'application/json'
content_type = 'application/json'
bedrock = boto3.client(service_name='bedrock-runtime')
response = bedrock.invoke_model(
body=body,
modelId=model_id,
accept=accept,
contentType=content_type
)
logger.info("Successfully generated text with Cohere 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-text-v14'
prompt = """Summarize this dialogue:
"Customer: Please connect me with a support agent.
AI: Hi there, how can I assist you today?
Customer: I forgot my password and lost access to the email affiliated to my account. Can you please help me?
AI: Yes of course. First I'll need to confirm your identity and then I can connect you with one of our support agents.
"""
try:
body = json.dumps({
"prompt": prompt,
"max_tokens": 200,
"temperature": 0.6,
"p": 1,
"k": 0,
"num_generations": 2,
"return_likelihoods": "GENERATION"
})
response = generate_text(model_id=model_id,
body=body)
response_body = json.loads(response.get('body').read())
generations = response_body.get('generations')
for index, generation in enumerate(generations):
print(f"Generation {index + 1}\n------------")
print(f"Text:\n {generation['text']}\n")
if 'likelihood' in generation:
print(f"Likelihood:\n {generation['likelihood']}\n")
print(f"Reason: {generation['finish_reason']}\n\n")
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()
```
# 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()
```
# Die Modelle Cohere Command R und Command R\$1
Mit [InvokeModel](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModel.html) oder [InvokeModelWithResponseStream](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModelWithResponseStream.html) (Streaming) nehmen Sie Inferenzanforderungen an Modelle Cohere Command R und Cohere und Command R\$1 vor. 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).
**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 [Führen einer Konversation mit den Converse-API-Operationen](conversation-inference.md).
**Topics**
+ [Anforderung und Antwort](#model-parameters-cohere-command-request-response)
+ [Codebeispiel](#api-inference-examples-cohere-command-r)
## 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\$1history** – 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](https://docs.cohere.com/docs/retrieval-augmented-generation-rag#document-mode) 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\$1queries\$1only** – 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\$1tokens** – 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.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/bedrock/latest/userguide/model-parameters-cohere-command-r-plus.html)
+ **p** – Verwenden Sie einen niedrigeren Wert, um weniger wahrscheinliche Optionen zu ignorieren.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/bedrock/latest/userguide/model-parameters-cohere-command-r-plus.html)
+ **k** – Geben Sie die Anzahl der Token-Optionen an, die das Modell zur Generierung des nächsten Tokens verwendet.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/bedrock/latest/userguide/model-parameters-cohere-command-r-plus.html)
+ **prompt\$1truncation** – 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\$1penalty** – 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.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/bedrock/latest/userguide/model-parameters-cohere-command-r-plus.html)
+ **presence\$1penalty** – 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.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/bedrock/latest/userguide/model-parameters-cohere-command-r-plus.html)
+ **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\$1prompt** – 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](https://docs.cohere.com/docs/tool-use) in der Cohere-Dokumentation.
**Tipp**
Es wird empfohlen, die Converse-API zur Integration der Tool-Nutzung in Ihre Anwendung zu verwenden. Weitere Informationen finden Sie unter [Verwenden eines Tools, um eine Amazon-Bedrock-Modellantwort zu vervollständigen](tool-use.md).
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 unter [Nutzung von Tools in einem Schritt (Funktionsaufruf)](https://docs.cohere.com/docs/tool-use) in der Cohere-Dokumentation.
+ **tools\$1results** – 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](https://docs.cohere.com/docs/tool-use) 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\$1sequences** – Eine Liste von Stoppsequenzen. Nachdem eine Stoppsequenz erkannt wird, stoppt das Modell die Generierung weiterer Token.
+ **raw\$1prompting** – 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\$1id** – Eindeutiger Bezeichner für die Chat-Vervollständigung
+ **text** – Die Antwort des Modells auf die Eingabe einer Chat-Nachricht
+ **generation\$1id** – 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\$1ids** – 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\$1reason** – 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\$1toxic** – Die Generierung konnte aufgrund unserer Inhaltsfilter nicht abgeschlossen werden.
+ **error\$1limit** – Die Generierung konnte nicht abgeschlossen werden, da das Kontextlimit des Modells erreicht wurde.
+ **error** – Die Generierung konnte aufgrund eines Fehlers nicht abgeschlossen werden.
+ **user\$1cancel** – Die Generierung konnte nicht abgeschlossen werden, da sie vom Benutzer gestoppt wurde.
+ **max\$1tokens** – 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\$1calls** – Eine Liste geeigneter Tools für Aufrufe. Wird nur zurückgegeben, wenn Sie das Eingabefeld `tools` angeben.
Weitere Informationen finden Sie unter [Tool-Nutzung](https://docs.cohere.com/docs/tool-use) in der Cohere-Dokumentation.
**Tipp**
Es wird empfohlen, die Converse-API zur Integration der Tool-Nutzung in Ihre Anwendung zu verwenden. Weitere Informationen finden Sie unter [Verwenden eines Tools, um eine Amazon-Bedrock-Modellantwort zu vervollständigen](tool-use.md).
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()
```
# Modelle von DeepSeek
DeepSeek[Bei den Modellen R1 und V3.1 handelt es sich um text-to-text Modelle, die für die Invoke API ([InvokeModel](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModel.html), [InvokeModelWithResponseStream](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModelWithResponseStream.html)) und die Converse API (Converse und) für Inferenzen zur Verfügung stehen. [ConverseStream](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_ConverseStream.html)](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_Converse.html)
Wenn Sie Inferenzaufrufe mit Modellen von DeepSeek tätigen, müssen Sie einen Prompt für das Modell einschließen. Allgemeine Informationen zum Erstellen von Prompts für die DeepSeek-Modelle, die von Amazon Bedrock unterstützt werden, finden Sie unter [DeepSeek-Prompt-Anleitung](https://api-docs.deepseek.com/guides/reasoning_model.html).
**Anmerkung**
Sie können den Anforderungszugriff nicht von den Modellen Amazon Titan, Amazon Nova, DeepSeek -R1, Mistral AI, Meta Llama 3 Instruct und Meta Llama 4 entfernen. Sie können verhindern, dass Benutzer Inferenzaufrufe an diese Modelle tätigen, indem Sie eine IAM-Richtlinie verwenden und die Modell-ID angeben. Weitere Informationen finden Sie unter [Verweigern des Zugriffs für Inferenzen von Basismodellen](https://docs.aws.amazon.com/bedrock/latest/userguide/security_iam_id-based-policy-examples.html#security_iam_id-based-policy-examples-deny-inference .html).
Um eine optimale Antwortqualität mit zu erzielenDeepSeek-R1, beschränken Sie den Parameter auf 8.192 Token oder weniger`max_tokens`. Die API akzeptiert zwar bis zu 32.768 Token, bei einem Wert von 8.192 Tokens verschlechtert sich die Antwortqualität jedoch erheblich. [Dies entspricht den Argumentationsfähigkeiten des Modells, wie sie im Leitfaden zum Argumentieren mit Inferenzen beschrieben sind.](https://docs.aws.amazon.com/bedrock/latest/userguide/inference-reasoning.html)
In diesem Abschnitt werden die Anforderungsparameter und Antwortfelder für Modelle von DeepSeek beschrieben. Verwenden Sie diese Informationen, um im Rahmen der Operation Rückschlüsse auf Modelle zu DeepSeek ziehen. [InvokeModel](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModel.html) Dieser Abschnitt enthält auch Python-Codebeispiele, die zeigen, wie Modelle von DeepSeek aufgerufen werden.
Sie benötigen die Modell-ID für das Modell, um ein Modell in einer Inferenzoperation verwenden zu können. Da dieses Modell durch regionsübergreifende Inferenz aufgerufen wird, müssen Sie die [Inferenzprofil-ID](https://docs.aws.amazon.com/bedrock/latest/userguide/inference-profiles-support.html) als Modell-ID verwenden. Verwenden Sie zum Beispiel für die Region USA `us.deepseek.r1-v1:0`.
+ Modellname: DeepSeek-R1
+ Textmodell
Weitere Informationen zur Verwendung von DeepSeek Modellen mit finden Sie APIs unter [DeepSeekModelle.](https://deepseek.com/)
**Anforderung und Antwort von DeepSeek**
**Anforderungstext**
DeepSeek verfügt über die folgenden Inferenzparameter für Inferenzaufrufe zur Textvervollständigung.
```
{
"prompt": string,
"temperature": float,
"top_p": float,
"max_tokens": int,
"stop": string array
}
```
**Felder:**
+ **prompt** – (Zeichenfolge) erforderliche Texteingabe für den Prompt
+ **temperature** – (Gleitkommazahl) numerischer Wert kleiner oder gleich 1
+ **top\$1p** – (Gleitkommazahl) numerischer Wert kleiner oder gleich 1
+ **max\$1tokens** — (int) Verwendete Token, mindestens 1 bis maximal 8.192 Token für optimale Qualität. Die API akzeptiert zwar bis zu 32.768 Tokens, aber bei mehr als 8.192 Tokens verschlechtert sich die Antwortqualität erheblich.
+ **stop** – (Zeichenfolgen-Array) maximal 10 Elemente.
**Hauptteil der Antwort**
DeepSeek verfügt über die folgenden Antwortparameter für Inferenzaufrufe zur Textvervollständigung Bei diesem Beispiel handelt es sich um eine Textvervollständigung von DeepSeek, das keinen inhaltlichen Argumentationsblock zurückgibt.
```
{
"choices": [
{
"text": string,
"stop_reason": string
}
]
}
```
**Felder:**
+ **stop\$1reason** – (Zeichenfolge) der Grund, warum die Antwort keinen Text mehr generiert hat. Ein Wert von `stop` oder `length`.
+ **stop** – (Zeichenfolge) Das Modell hat die Textgenerierung für den Prompt abgeschlossen.
+ **length** – Die Länge der Token für den generierten Text überschreitet den Wert von `max_tokens` im Aufruf von `InvokeModel` (oder `InvokeModelWithResponseStream`, wenn Sie die Ausgabe streamen). Die Antwort wird auf `max_tokens` gekürzt. Erhöhen Sie den Wert von `max_tokens` und versuchen Sie Ihre Anfrage erneut.
**Beispiel-Code**
Das folgende Beispiel zeigt, wie das Modell DeepSeek-R1 aufgerufen wird.
```
# Use the API to send a text message to DeepSeek-R1.
import boto3
import json
from botocore.exceptions import ClientError
# Create a Bedrock Runtime client in the AWS-Region of your choice.
client = boto3.client("bedrock-runtime", region_name="us-west-2")
# Set the cross Region inference profile ID for DeepSeek-R1
model_id = "us.deepseek.r1-v1:0"
# Define the prompt for the model.
prompt = "Describe the purpose of a 'hello world' program in one line."
# Embed the prompt in DeepSeek-R1's instruction format.
formatted_prompt = f"""
<｜begin▁of▁sentence｜><｜User｜>{prompt}<｜Assistant｜>\n
"""
body = json.dumps({
"prompt": formatted_prompt,
"max_tokens": 512,
"temperature": 0.5,
"top_p": 0.9,
})
try:
# Invoke the model with the request.
response = client.invoke_model(modelId=model_id, body=body)
# Read the response body.
model_response = json.loads(response["body"].read())
# Extract choices.
choices = model_response["choices"]
# Print choices.
for index, choice in enumerate(choices):
print(f"Choice {index + 1}\n----------")
print(f"Text:\n{choice['text']}\n")
print(f"Stop reason: {choice['stop_reason']}\n")
except (ClientError, Exception) as e:
print(f"ERROR: Can't invoke '{model_id}'. Reason: {e}")
exit(1)
```
**Converse**
Anforderungstext – Verwenden Sie dieses Beispiel für den Anforderungstext, um die Converse-API aufzurufen.
```
{
"modelId": string, # us.deepseek.r1-v1:0
"system": [
{
"text": string
}
],
"messages": [
{
"role": string,
"content": [
{
"text": string
}
]
}
],
"inferenceConfig": {
"temperature": float,
"topP": float,
"maxTokens": int,
"stopSequences": string array
},
"guardrailConfig": {
"guardrailIdentifier":"string",
"guardrailVersion": "string",
"trace": "string"
}
}
```
**Felder:**
+ **system** – (optional) Der System-Prompt für die Anfrage.
+ **messages** – (erforderlich) Die Eingabenachrichten
+ **role** – Die Rolle der Konversationsrunde Gültige Werte sind `user` und `assistant`.
+ **content** – (erforderlich) Der Inhalt der Konversationsrunde als Array von Objekten. Jedes Objekt enthält ein type-Feld, in dem Sie einen der folgenden Werte angeben können:
+ **text** – (erforderlich) Wenn Sie diesen Typ angeben, müssen Sie ein text-Feld einschließen und den Text-Prompt als Wert angeben.
+ **inferenceConfig**
+ **temperature** – (optional) Werte: Minimum = 0. Maximum = 1.
+ **topP** – (optional) Werte: Minimum = 0. Maximum = 1.
+ **maxTokens** – (Optional) die maximale Anzahl von Token, die vor dem Beenden generiert werden sollen. Werte: Minimum = 0. Maximum = 32 768.
+ **stopSequences** – (optional) Benutzerdefinierte Textsequenzen, die dazu führen, dass das Modell das Generieren beendet. Maximum = 10 Elemente.
Antworttext – Verwenden Sie dieses Beispiel für den Anforderungstext, um die Converse-API aufzurufen.
```
{
"message": {
"role" : "assistant",
"content": [
{
"text": string
},
{
"reasoningContent": {
"reasoningText": string
}
}
],
},
"stopReason": string,
"usage": {
"inputTokens": int,
"outputTokens": int,
"totalTokens": int
}
"metrics": {
"latencyMs": int
}
}
```
**Felder:**
+ **message** – Die Rückantwort des Modells
+ **role** – Die Konversationsrolle der generierten Nachricht Dieser Wert ist immer `assistant`.
+ **content** – Der vom Modell generierte Inhalt, der als Array zurückgegeben wird. Es gibt zwei Arten von Inhalt:
+ **text** – Der Textinhalt der Antwort
+ **reasoningContent** – (optional) Der Inhalt der Argumentation aus der Modellantwort
+ **reasoningText** – Der Begründungstext aus der Modellantwort
+ **stopReason** – Der Grund, warum das Modell keine Antwort mehr generiert hat
+ **end\$1turn** – Das Modell hat bei dieser Runde einen Haltepunkt erreicht.
+ **max\$1tokens** – Der generierte Text hat den Wert des `maxTokens`-Eingabefeldes oder die maximale Anzahl von Token überschritten, die das Modell unterstützt.
Beispielcode — Hier ist ein Beispiel für die DeepSeek Erstellung eines Aufrufs der ConverseAPI.
```
# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
# SPDX-License-Identifier: Apache-2.0
"""
Shows how to use the Converse API with DeepSeek-R1 (on demand).
"""
import logging
import boto3
from botocore.client import Config
from botocore.exceptions import ClientError
logger = logging.getLogger(__name__)
logging.basicConfig(level=logging.INFO)
def generate_conversation(bedrock_client,
model_id,
system_prompts,
messages):
"""
Sends messages to a model.
Args:
bedrock_client: The Boto3 Bedrock runtime client.
model_id (str): The model ID to use.
system_prompts (JSON) : The system prompts for the model to use.
messages (JSON) : The messages to send to the model.
Returns:
response (JSON): The conversation that the model generated.
"""
logger.info("Generating message with model %s", model_id)
# Inference parameters to use.
temperature = 0.5
max_tokens = 4096
# Base inference parameters to use.
inference_config = {
"temperature": temperature,
"maxTokens": max_tokens,
}
# Send the message.
response = bedrock_client.converse(
modelId=model_id,
messages=messages,
system=system_prompts,
inferenceConfig=inference_config,
)
# Log token usage.
token_usage = response['usage']
logger.info("Input tokens: %s", token_usage['inputTokens'])
logger.info("Output tokens: %s", token_usage['outputTokens'])
logger.info("Total tokens: %s", token_usage['totalTokens'])
logger.info("Stop reason: %s", response['stopReason'])
return response
def main():
"""
Entrypoint for DeepSeek-R1 example.
"""
logging.basicConfig(level=logging.INFO,
format="%(levelname)s: %(message)s")
model_id = "us.deepseek.r1-v1:0"
# Setup the system prompts and messages to send to the model.
system_prompts = [{"text": "You are an app that creates playlists for a radio station that plays rock and pop music. Only return song names and the artist."}]
message_1 = {
"role": "user",
"content": [{"text": "Create a list of 3 pop songs."}]
}
message_2 = {
"role": "user",
"content": [{"text": "Make sure the songs are by artists from the United Kingdom."}]
}
messages = []
try:
# Configure timeout for long responses if needed
custom_config = Config(connect_timeout=840, read_timeout=840)
bedrock_client = boto3.client(service_name='bedrock-runtime', config=custom_config)
# Start the conversation with the 1st message.
messages.append(message_1)
response = generate_conversation(
bedrock_client, model_id, system_prompts, messages)
# Add the response message to the conversation.
output_message = response['output']['message']
# Remove reasoning content from the response
output_contents = []
for content in output_message["content"]:
if content.get("reasoningContent"):
continue
else:
output_contents.append(content)
output_message["content"] = output_contents
messages.append(output_message)
# Continue the conversation with the 2nd message.
messages.append(message_2)
response = generate_conversation(
bedrock_client, model_id, system_prompts, messages)
output_message = response['output']['message']
messages.append(output_message)
# Show the complete conversation.
for message in messages:
print(f"Role: {message['role']}")
for content in message['content']:
if content.get("text"):
print(f"Text: {content['text']}")
if content.get("reasoningContent"):
reasoning_content = content['reasoningContent']
reasoning_text = reasoning_content.get('reasoningText', {})
print()
print(f"Reasoning Text: {reasoning_text.get('text')}")
print()
except ClientError as err:
message = err.response['Error']['Message']
logger.error("A client error occurred: %s", message)
print(f"A client error occured: {message}")
else:
print(
f"Finished generating text with model {model_id}.")
if __name__ == "__main__":
main()
```
# Modelle von Luma AI
In diesem Abschnitt werden die Anforderungsparameter sowie die Antworfelder der Luma-AI-Modelle beschrieben. Verwenden Sie diese Informationen, um im Rahmen der Operation Inferenzrufe an Luma-AI-Modelle zu senden. [StartAsyncInvoke](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_StartAsyncInvoke.html) Dieser Abschnitt enthält auch Python-Codebeispiele, die zeigen, wie Luma-AI-Modelle aufgerufen werden. Sie benötigen die Modell-ID für das Modell, um ein Modell in einer Inferenzoperation verwenden zu können.
+ Modell-ID: luma.ray-v2:0
+ Modellname: Luma Ray 2
+ Text-zu-Video-Modell
Luma AI modelliert Prozessmodell-Eingabeaufforderungen asynchron mithilfe von Async APIs , einschließlich, und. [StartAsyncInvoke[GetAsyncInvoke[ListAsyncInvokes](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_ListAsyncInvokes.html)](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_GetAsyncInvoke.html)](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_StartAsyncInvoke.html)
Das Luma-AI-Modell verarbeitet Prompts mithilfe der folgenden Schritte.
+ Der Benutzer fordert das Modell mithilfe von. [StartAsyncInvoke](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_StartAsyncInvoke.html)
+ Warten Sie, bis der fertig InvokeJob ist. Sie können `GetAsyncInvoke` oder `ListAsyncInvokes` verwenden, um den Abschlussstatus des Auftrags zu überprüfen.
+ Die Modellausgabe wird in den angegebenen Ausgabe-Bucket von Amazon S3 platziert.
Weitere Informationen zur Verwendung der Luma-AI-Modelle mit dem APIs finden Sie unter [Videogenerierung](https://docs.lumalabs.ai/docs/video-generation).
Inferenzaufruf von Luma AI
```
POST /async-invoke HTTP/1.1
Content-type: application/json
{
"modelId": "luma.ray-v2:0",
"modelInput": {
"prompt": "your input text here",
"aspect_ratio": "16:9",
"loop": false,
"duration": "5s",
"resolution": "720p"
},
"outputDataConfig": {
"s3OutputDataConfig": {
"s3Uri": "s3://your-bucket-name"
}
}
}
```
**Felder**
+ **prompt** – (Zeichenfolge) der für das Ausgabevideo benötigte Inhalt (1 <= Länge <= 5 000 Zeichen)
+ **aspect\$1ratio** – (Aufzählung) das Seitenverhältnis des Ausgabevideos („1:1“, „16:9“, „9:16“, „4:3“, „3:4“, „21:9“, „9:21“)
+ **loop** – (boolesch) die Angabe, ob das Ausgabevideo in einer Schleife wiederholt werden soll
+ **duration** – (Aufzählung) die Dauer des Ausgabevideos („5s“, „9s“)
+ **resolution** – (Aufzählung) die Auflösung des Ausgabevideos („540p“, „720p“)
Die MP4 Datei wird im Amazon S3 S3-Bucket gespeichert, wie in der Antwort konfiguriert.
## Text-to-Video Generierung
Generieren Sie mit dem Modell Luma Ray 2 Videos aus Text-Prompts. Das Modell unterstützt verschiedene Anpassungsoptionen, darunter Seitenverhältnis, Dauer, Auflösung und Schleife.
**Grundlegende Text-to-Video Anfrage**
```
{
"modelId": "luma.ray-v2:0",
"modelInput": {
"prompt": "an old lady laughing underwater, wearing a scuba diving suit"
},
"outputDataConfig": {
"s3OutputDataConfig": {
"s3Uri": "s3://your-bucket-name"
}
}
}
```
**Fortgeschritten Text-to-Video mit Optionen**
```
{
"modelId": "luma.ray-v2:0",
"modelInput": {
"prompt": "an old lady laughing underwater, wearing a scuba diving suit",
"aspect_ratio": "16:9",
"loop": true,
"duration": "5s",
"resolution": "720p"
},
"outputDataConfig": {
"s3OutputDataConfig": {
"s3Uri": "s3://your-bucket-name"
}
}
}
```
**Weiteres Text-to-Video Beispiel**
Beispiel mit Parametern für Auflösung und Dauer
```
{
"modelId": "luma.ray-v2:0",
"modelInput": {
"prompt": "a car",
"resolution": "720p",
"duration": "5s"
},
"outputDataConfig": {
"s3OutputDataConfig": {
"s3Uri": "s3://your-bucket-name"
}
}
}
```
## Image-to-Video Generation
Verwandeln Sie statische Bilder in dynamische Videos, indem Sie Keyframes bereitstellen. Sie können Startframes, Endframes oder beides angeben, um den Videogenerierungsprozess zu steuern.
** Image-to-VideoGrundlegend mit Start Frame**
```
{
"modelId": "luma.ray-v2:0",
"modelInput": {
"prompt": "A tiger walking in snow",
"keyframes": {
"frame0": {
"type": "image",
"source": {
"type": "base64",
"media_type": "image/jpeg",
"data": "iVBORw0KGgoAAAANSUhEUgAAAAgAAAAIAQMAAAD+wSzIAAAABlBMVEX///+/v7+jQ3"
}
}
}
},
"outputDataConfig": {
"s3OutputDataConfig": {
"s3Uri": "s3://your-bucket-name"
}
}
}
```
**Image-to-Video mit Start- und End-Frames**
```
{
"modelId": "luma.ray-v2:0",
"modelInput": {
"prompt": "A tiger walking in snow",
"keyframes": {
"frame0": {
"type": "image",
"source": {
"type": "base64",
"media_type": "image/jpeg",
"data": "iVBORw0KGgoAAAANSUhEUgAAAAgAAAAIAQMAAAD+wSzIAAAABlBMVEX///+/v7+jQ3"
}
},
"frame1": {
"type": "image",
"source": {
"type": "base64",
"media_type": "image/jpeg",
"data": "iVBORw0KGgoAAAANSUhEUgAAAAgAAAAIAQMAAAD+wSzIAAAABlBMVEX///+/v7+jQ3"
}
}
},
"loop": false,
"aspect_ratio": "16:9"
},
"outputDataConfig": {
"s3OutputDataConfig": {
"s3Uri": "s3://your-bucket-name"
}
}
}
```
**Zusätzliche Parameter für Image-to-Video**
+ **Keyframes** — (Objekt) Definiert Start-Keyframes (Frame0) und and/or Ende (Frame1)
+ **frame0** – Keyframe-Bild am Anfang
+ **frame1** – Keyframe-Bild am Ende
+ **type** – Muss „Bild“ sein
+ **source** – Bildquelle
## Fehlerbehebung
Häufige Probleme und deren Lösungen bei der Arbeit mit Luma-AI-Modellen:
+ **Auftragsstatus „Fehlgeschlagen“** – Vergewissern Sie sich, dass Ihr S3-Bucket über die richtigen Schreibberechtigungen verfügt und dass sich der Bucket in derselben Region wie Ihr Bedrock-Service befindet.
+ **Fehler beim Zugriff auf Bild-URLs** — Stellen Sie sicher, dass Bilder öffentlich zugänglich URLs sind, und verwenden Sie HTTPS. Bilder müssen in unterstützten Formaten (JPEG, PNG) vorliegen.
+ **Fehler aufgrund ungültiger Parameter** – Stellen Sie sicher, dass die Seitenverhältniswerte den unterstützten Optionen („1:1“, „16:9“, „9:16“, „4:3“, „3:4“, „21:9“, „9:21“) entsprechen und die Dauer entweder „5s“ oder „9s“ ist.
+ **Timeout-Probleme** – Verwenden Sie `GetAsyncInvoke`, um den Auftragsstatus zu überprüfen, anstatt synchron zu warten. Die Videogenerierung kann einige Minuten dauern.
+ **Fehler bei der Länge des Prompts** – Verwenden Sie Prompts zwischen 1 und 5 000 Zeichen. Längere Prompts werden abgelehnt.
## Hinweise zur Leistung
Wichtige Überlegungen zur Leistung und zu den Einschränkungen von Luma-AI-Modellen:
+ **Verarbeitungszeit** – Die Videogenerierung dauert je nach Komplexität in der Regel 2–5 Minuten für 5-Sekunden-Videos und 4–8 Minuten für 9-Sekunden-Videos.
+ **Anforderungen für Bilder** – Die Eingabebilder sollten von hoher Qualität sein und eine Mindestauflösung von 512 x 512 Pixeln aufweisen. Die maximal unterstützte Bildgröße beträgt 4 096 x 4 096 Pixel.
+ **Größe des Ausgabevideos** – Die generierten Videos liegen je nach Dauer, Auflösung und Komplexität des Inhalts zwischen 5 und 50 MB.
+ **Ratenlimits** – Asynchrone API-Aufrufe unterliegen Servicekontingenten. Überwachen Sie Ihre Nutzung und fordern Sie bei Bedarf Kontingenterhöhungen an.
+ **S3-Speicher** – Sorgen Sie für ausreichend S3-Speicherkapazität für die Ausgabe von Videos und berücksichtigen Sie zur Kostenoptimierung Lebenszyklusrichtlinien.
## Zugehörige Dokumentation
Weitere Informationen und zugehörige Services finden Sie unter:
+ **Amazon-S3-Konfiguration** – [Erstellen von S3-Buckets](https://docs.aws.amazon.com/s3/latest/userguide/creating-buckets-s3.html) und [Bucket-Richtlinien](https://docs.aws.amazon.com/s3/latest/userguide/bucket-policies.html) für den Ausgabespeicher
+ **Asynchrone API-Operationen** — [StartAsyncInvoke](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_StartAsyncInvoke.html), [GetAsyncInvoke](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_GetAsyncInvoke.html), und [ListAsyncInvokes](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_ListAsyncInvokes.html)API-Referenz.
+ **Servicekontingente** – [Kontingente für Amazon Bedrock](quotas.md) für Bedrock-Servicelimits und Anforderungen für Kontingenterhöhungen
+ **Best Practices zur Videoverarbeitung** – [So senden Sie Prompts und generieren Antworten mithilfe der Modellinferenz](inference.md) als allgemeine Anleitung zur Modellinferenz
+ **Luma-KI-Dokumentation** – Die [Luma-Labs-Dokumentation zur Videogenerierung](https://docs.lumalabs.ai/docs/video-generation) enthält detaillierte Modellfunktionen und erweiterte Features.
# MetaModelleLlama
In diesem Abschnitt werden die Anforderungsparameter und Antwortfelder für Meta-Llama-Modelle beschrieben. Verwenden Sie diese Informationen, um mit den (Streaming-) Operationen [InvokeModel](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModel.html) und [InvokeModelWithResponseStream](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModelWithResponseStream.html) Inferenzaufrufe an Meta-Llama-Modelle durchzuführen. Dieser Abschnitt enthält auch Python-Codebeispiele, die zeigen, wie Meta-Llama-Modelle aufgerufen werden. Sie benötigen die Modell-ID für das Modell, um ein Modell in einer Inferenzoperation verwenden zu können. Informationen zum Abrufen der Modell-ID finden Sie unter [Unterstützte Basismodelle in Amazon Bedrock](models-supported.md). Einige Modelle funktionieren auch mit der [Converse-API](conversation-inference.md). Informationen darüber, ob die Converse-API ein bestimmtes Meta-Llama-Modell unterstützt, finden Sie unter [Unterstützte Modelle und Modellfeatures](conversation-inference-supported-models-features.md). Weitere Codebeispiele finden Sie unter [Codebeispiele für Amazon Bedrock mit AWS SDKs](service_code_examples.md).
Basismodelle in Amazon Bedrock unterstützen Eingabe- und Ausgabemodalitäten, die von Modell zu Modell variieren. Informationen zu den Modalitäten, die von Meta-Llama-Modellen unterstützt werden, finden Sie unter [Unterstützte Basismodelle in Amazon Bedrock](models-supported.md). Informationen darüber, welche Amazon-Bedrock-Features Meta-Llama-Modelle unterstützen, finden Sie unter [Unterstützte Basismodelle in Amazon Bedrock](models-supported.md). Informationen darüber, in welchen AWS-Regionen diese Meta-Llama-Modelle verfügbar sind, finden Sie unter [Unterstützte Basismodelle in Amazon Bedrock](models-supported.md).
Wenn Sie Inferenzaufrufe mit Meta-Llama-Modellen tätigen, schließen Sie einen Prompt für das Modell ein. Allgemeine Informationen zum Erstellen von Prompts für die Modelle, die von Amazon Bedrock unterstützt werden, finden Sie unter [Prompt-Engineering-Konzepte](prompt-engineering-guidelines.md). Für Meta Llama spezifische Informationen zu Prompts finden Sie im [Handbuch zu Llama-Prompt-Engineering von Meta](https://ai.meta.com/llama/get-started/#prompting).
**Anmerkung**
Die Modelle Llama 3.2 Instruct und Llama 3.3 Instruct verwenden Geofencing. Das bedeutet, dass diese Modelle außerhalb der AWS-Regionen, die für diese in der Tabelle „Regionen“ aufgeführten Modelle verfügbar sind, nicht verwendet werden können.
Dieser Abschnitt enthält Informationen zur Verwendung der folgenden Modelle von Meta.
+ Llama 3 Instruct
+ Llama 3.1 Instruct
+ Llama 3.2 Instruct
+ Llama 3.3 Instruct
+ Llama 4 Instruct
**Topics**
+ [Anforderung und Antwort](#model-parameters-meta-request-response)
+ [Beispiel-Code](#api-inference-examples-meta-llama)
## Anforderung und Antwort
Der Anforderungstext wird im `body`-Feld einer Anforderung an [InvokeModel](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModel.html) oder [InvokeModelWithResponseStream](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModelWithResponseStream.html) übergeben.
**Anmerkung**
Sie können die (Streaming-) Operationen [InvokeModelWithResponseStream](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModelWithResponseStream.html) oder [ConverseStream](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_ConverseStream.html) nicht mit Llama 4 Instruct verwenden.
------
#### [ Request ]
Die Modelle Llama 3 Instruct, Llama 3.1 Instruct, Llama 3.2 Instruct und Llama 4 Instruct haben die folgenden Inferenzparameter:
```
{
"prompt": string,
"temperature": float,
"top_p": float,
"max_gen_len": int
}
```
HINWEIS: Llama-3.2-Modelle und neuer ergänzen die Anforderungsstruktur durch `images`, wobei es sich um eine Liste von Zeichenfolgen handelt. Beispiel: `images: Optional[List[str]]`
Die folgenden Parameter sind erforderlich:
+ **prompt** – (erforderlich) Der Prompt, den Sie an das Modell übergeben möchten. Optimale Ergebnisse erzielen Sie, wenn Sie die Konversation mit der folgenden Vorlage formatieren.
```
<|begin_of_text|><|start_header_id|>user<|end_header_id|>
What can you help me with?<|eot_id|><|start_header_id|>assistant<|end_header_id|>
```
**Beispielvorlage mit System-Prompt**
Im Folgenden finden Sie ein Beispiel für einen Prompt, der einen System-Prompt enthält.
```
<|begin_of_text|><|start_header_id|>system<|end_header_id|>
You are a helpful AI assistant for travel tips and recommendations<|eot_id|><|start_header_id|>user<|end_header_id|>
What can you help me with?<|eot_id|><|start_header_id|>assistant<|end_header_id|>
```
**Beispiel für eine Konversation mit mehreren Runden**
Es folgt ein Beispiel eines Prompts für eine Konversation mit mehreren Runden.
```
<|begin_of_text|><|start_header_id|>user<|end_header_id|>
What is the capital of France?<|eot_id|><|start_header_id|>assistant<|end_header_id|>
The capital of France is Paris!<|eot_id|><|start_header_id|>user<|end_header_id|>
What is the weather like in Paris?<|eot_id|><|start_header_id|>assistant<|end_header_id|>
```
**Beispielvorlage mit System-Prompt**
Weitere Informationen finden Sie unter [Meta Llama 3](https://llama.meta.com/docs/model-cards-and-prompt-formats/meta-llama-3).
Die folgenden Parameter sind optional:
+ **Temperatur** – Verwenden Sie einen niedrigeren Wert, um die Zufälligkeit der Antwort zu verringern.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/bedrock/latest/userguide/model-parameters-meta.html)
+ **top\$1p** – Verwenden Sie einen niedrigeren Wert, um weniger wahrscheinliche Optionen zu ignorieren. Legen Sie den Wert auf 0 oder 1,0 fest, um den Parameter zu deaktivieren.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/bedrock/latest/userguide/model-parameters-meta.html)
+ **max\$1gen\$1len** – Geben Sie die maximale Anzahl von Token an, die in der generierten Antwort verwendet werden soll. Das Modell kürzt die Antwort, sobald der generierte Text den Wert überschreitet `max_gen_len`.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/bedrock/latest/userguide/model-parameters-meta.html)
------
#### [ Response ]
Die Modelle von Llama 3 Instruct verfügen über die folgenden Felder für Inferenzaufrufe zur Textvervollständigung.
```
{
"generation": "\n\n",
"prompt_token_count": int,
"generation_token_count": int,
"stop_reason" : string
}
```
Weitere Informationen zu den einzelnen Feldern finden Sie weiter unten.
+ **generation** – Der generierte Text
+ **prompt\$1token\$1count** – Die Anzahl der Token im Prompt
+ **generation\$1token\$1count** – Die Anzahl der Token im generierten Text
+ **stop\$1reason** – Der Grund, warum die Antwort keinen Text mehr generiert hat. Die möglichen Werte sind:
+ **Stopp** – Das Modell hat die Textgenerierung für die Eingabeaufforderung abgeschlossen.
+ **Länge** – Die Länge der Token für den generierten Text überschreitet den Wert von `max_gen_len` im Aufruf von `InvokeModel` (`InvokeModelWithResponseStream`, wenn Sie die Ausgabe streamen). Die Antwort wird auf `max_gen_len` Token gekürzt. Erwägen Sie, den Wert `max_gen_len` zu erhöhen und es erneut zu versuchen.
------
## Beispiel-Code
Das folgende Beispiel zeigt, wie das Modell *Llama 3 Instruct* aufgerufen wird.
```
# Use the native inference API to send a text message to Meta Llama 3.
import boto3
import json
from botocore.exceptions import ClientError
# Create a Bedrock Runtime client in the AWS-Region of your choice.
client = boto3.client("bedrock-runtime", region_name="us-west-2")
# Set the model ID, e.g., Llama 3 70b Instruct.
model_id = "meta.llama3-70b-instruct-v1:0"
# Define the prompt for the model.
prompt = "Describe the purpose of a 'hello world' program in one line."
# Embed the prompt in Llama 3's instruction format.
formatted_prompt = f"""
<|begin_of_text|><|start_header_id|>user<|end_header_id|>
{prompt}
<|eot_id|>
<|start_header_id|>assistant<|end_header_id|>
"""
# Format the request payload using the model's native structure.
native_request = {
"prompt": formatted_prompt,
"max_gen_len": 512,
"temperature": 0.5,
}
# Convert the native request to JSON.
request = json.dumps(native_request)
try:
# Invoke the model with the request.
response = client.invoke_model(modelId=model_id, body=request)
except (ClientError, Exception) as e:
print(f"ERROR: Can't invoke '{model_id}'. Reason: {e}")
exit(1)
# Decode the response body.
model_response = json.loads(response["body"].read())
# Extract and print the response text.
response_text = model_response["generation"]
print(response_text)
```
Dieses Beispiel veranschaulicht, wie Sie die Länge der generierten Antworten mit Modellen von Llama 3 Instruct steuern. Für detaillierte Antworten oder Zusammenfassungen passen Sie „max\$1gen\$1len“ an und fügen Sie Ihrem Prompt spezifische Anweisungen hinzu.
# Modelle von Mistral AI
In diesem Abschnitt werden die Anforderungsparameter und Antwortfelder für Modelle von Mistral AI beschrieben. Verwenden Sie diese Informationen, um mit den (Streaming-) Operationen [InvokeModel](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModel.html) und [InvokeModelWithResponseStream](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModelWithResponseStream.html) Inferenzaufrufe an Modelle von Mistral AI durchzuführen. Dieser Abschnitt enthält auch Python-Codebeispiele, die zeigen, wie Modelle von Mistral AI aufgerufen werden. Sie benötigen die Modell-ID für das Modell, um ein Modell in einer Inferenzoperation verwenden zu können. Informationen zum Abrufen der Modell-ID finden Sie unter [Unterstützte Basismodelle in Amazon Bedrock](models-supported.md). Einige Modelle funktionieren auch mit der [Converse-API](conversation-inference.md). Informationen darüber, ob die Converse-API ein bestimmtes Modell von Mistral AI unterstützt, finden Sie unter [Unterstützte Modelle und Modellfeatures](conversation-inference-supported-models-features.md). Weitere Codebeispiele finden Sie unter [Codebeispiele für Amazon Bedrock mit AWS SDKs](service_code_examples.md).
Basismodelle in Amazon Bedrock unterstützen Eingabe- und Ausgabemodalitäten, die von Modell zu Modell variieren. Informationen zu den Modalitäten, die von Modellen von Mistral AI unterstützt werden, finden Sie unter [Unterstützte Basismodelle in Amazon Bedrock](models-supported.md). Informationen darüber, welche Amazon-Bedrock-Features die Modelle von Mistral AI unterstützen, finden Sie unter [Unterstützte Basismodelle in Amazon Bedrock](models-supported.md). Informationen darüber, in welchen AWS-Regionen diese Modelle von Mistral AI verfügbar sind, finden Sie unter [Unterstützte Basismodelle in Amazon Bedrock](models-supported.md).
Wenn Sie Inferenzaufrufe mit Modellen von Mistral AI tätigen, schließen Sie einen Prompt für das Modell ein. Allgemeine Informationen zum Erstellen von Prompts für die Modelle, die von Amazon Bedrock unterstützt werden, finden Sie unter [Prompt-Engineering-Konzepte](prompt-engineering-guidelines.md). Für Mistral AI spezifische Informationen zu Prompts finden Sie im [Handbuch zu Prompt-Engineering von Mistral AI](https://docs.mistral.ai/guides/prompting_capabilities/).
**Topics**
+ [Textvervollständigung mit Mistral AI](model-parameters-mistral-text-completion.md)
+ [Chat-Vervollständigung von Mistral AI](model-parameters-mistral-chat-completion.md)
+ [Parameter und Inferenz von Mistral AI Large (24.07)](model-parameters-mistral-large-2407.md)
+ [Parameter und Inferenz von Pixtral Large (25.02)](model-parameters-mistral-pixtral-large.md)
# Textvervollständigung mit Mistral AI
Mit der Textvervollständigungs-API von Mistral AI können Sie Text mit einem Modell von Mistral AI generieren.
Mit [InvokeModel](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModel.html) oder [InvokeModelWithResponseStream](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModelWithResponseStream.html) (Streaming) nehmen Sie Inferenzanforderungen an Modelle von Mistral AI vor.
Modelle von Mistral AI sind unter der [Apache-2.0-Lizenz](https://www.apache.org/licenses/LICENSE-2.0.txt) verfügbar. Weitere Informationen zur Verwendung von Modellen von Mistral AI finden Sie in der [Dokumentation für Mistral AI](https://docs.mistral.ai/).
**Topics**
+ [Unterstützte Modelle](#mistral--text-completion-supported-models)
+ [Anforderung und Antwort](#model-parameters-mistral-text-completion-request-response)
+ [Codebeispiel](#api-inference-examples-mistral-text-completion)
## Unterstützte Modelle
Sie können die folgenden Modelle von Mistral AI verwenden.
+ Mistral 7B Instruct
+ Mixtral 8X7B Instruct
+ Mistral Large
+ Mistral Small
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).
## Anforderung und Antwort
------
#### [ Request ]
Die Modelle von Mistral AI haben die folgenden Inferenzparameter.
```
{
"prompt": string,
"max_tokens" : int,
"stop" : [string],
"temperature": float,
"top_p": float,
"top_k": int
}
```
Die folgenden Parameter sind erforderlich.
+ **prompt** – (erforderlich) Der Prompt, den Sie an das Modell übergeben möchten, wie in folgendem Beispiel gezeigt.
```
[INST] What is your favourite condiment? [/INST]
```
Das folgende Beispiel zeigt die Formatierung eines Prompts für Multi-Turn-Konversationen.
```
[INST] What is your favourite condiment? [/INST]
Well, I'm quite partial to a good squeeze of fresh lemon juice.
It adds just the right amount of zesty flavour to whatever I'm cooking up in the kitchen!
[INST] Do you have mayonnaise recipes? [/INST]
```
Der Text für die Benutzerrolle befindet sich innerhalb der Token `[INST]...[/INST]`, der Text außerhalb entspricht der Rolle des Assistenten. Der Anfang und das Ende einer Zeichenfolge werden durch die Token `` (Anfang der Zeichenfolge) und `` (Ende der Zeichenfolge) dargestellt. Informationen zum Senden eines Chat-Prompts im richtigen Format finden Sie in der Dokumentation für Mistral AI unter [Chat-Vorlage](https://docs.mistral.ai/models/#chat-template).
Die folgenden Parameter sind optional.
+ **max\$1tokens** – Geben Sie die maximale Anzahl von Token an, die in der generierten Antwort verwendet werden soll. Das Modell kürzt die Antwort, sobald der generierte Text den Wert überschreitet `max_tokens`.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/bedrock/latest/userguide/model-parameters-mistral-text-completion.html)
+ **stop** – Eine Liste von Stoppsequenzen, die, wenn sie vom Modell generiert werden, verhindern, dass das Modell weitere Ausgaben generiert.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/bedrock/latest/userguide/model-parameters-mistral-text-completion.html)
+ **temperature** – Steuert die Zufälligkeit der vom Modell getroffenen Vorhersagen. Weitere Informationen finden Sie unter [So beeinflussen Sie die Antwortgenerierung mit Inferenzparametern](inference-parameters.md).
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/bedrock/latest/userguide/model-parameters-mistral-text-completion.html)
+ **top\$1p** – Steuert die Diversität des Texts, den das Modell generiert, indem der Prozentsatz der wahrscheinlichsten Kandidaten festgelegt wird, die das Modell für das nächste Token in Erwägung zieht. Weitere Informationen finden Sie unter [So beeinflussen Sie die Antwortgenerierung mit Inferenzparametern](inference-parameters.md).
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/bedrock/latest/userguide/model-parameters-mistral-text-completion.html)
+ **top\$1k** – Die Anzahl der wahrscheinlichsten Kandidaten, die das Modell für das nächste Token in Erwägung zieht. Weitere Informationen finden Sie unter [So beeinflussen Sie die Antwortgenerierung mit Inferenzparametern](inference-parameters.md).
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/bedrock/latest/userguide/model-parameters-mistral-text-completion.html)
------
#### [ Response ]
Die `body`-Antwort eines Aufrufs von `InvokeModel` lautet wie folgt:
```
{
"outputs": [
{
"text": string,
"stop_reason": string
}
]
}
```
Die `body`-Antwort enthält folgende mögliche Felder:
+ **outputs** – Eine Liste der Ausgaben des Modells. Jede Ausgabe enthält die folgenden Felder.
+ **text** – Der Text, den das Modell generiert hat
+ **stop\$1reason** – Der Grund, warum die Antwort keinen Text mehr generiert hat. Die möglichen Werte sind:
+ **Stopp** – Das Modell hat die Textgenerierung für die Eingabeaufforderung abgeschlossen. Das Modell wird beendet, weil kein Inhalt mehr generiert werden muss oder wenn das Modell eine der Stoppsequenzen generiert, die Sie im Anforderungsparameter `stop` definieren.
+ **Länge** – Die Länge der Token für den generierten Text überschreitet den Wert von `max_tokens` im Aufruf von `InvokeModel` (`InvokeModelWithResponseStream`, wenn Sie die Ausgabe streamen). Die Antwort wird auf `max_tokens` Token gekürzt.
------
## Codebeispiel
Dieses Beispiel zeigt, wie das Modell Mistral 7B Instruct aufgerufen wird.
```
# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
# SPDX-License-Identifier: Apache-2.0
"""
Shows how to generate text using a Mistral AI 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 Mistral AI model.
Args:
model_id (str): The model ID to use.
body (str) : The request body to use.
Returns:
JSON: The response from the model.
"""
logger.info("Generating text with Mistral AI 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 Mistral AI model %s", model_id)
return response
def main():
"""
Entrypoint for Mistral AI example.
"""
logging.basicConfig(level=logging.INFO,
format="%(levelname)s: %(message)s")
try:
model_id = 'mistral.mistral-7b-instruct-v0:2'
prompt = """[INST] In Bash, how do I list all text files in the current directory
(excluding subdirectories) that have been modified in the last month? [/INST]"""
body = json.dumps({
"prompt": prompt,
"max_tokens": 400,
"temperature": 0.7,
"top_p": 0.7,
"top_k": 50
})
response = generate_text(model_id=model_id,
body=body)
response_body = json.loads(response.get('body').read())
outputs = response_body.get('outputs')
for index, output in enumerate(outputs):
print(f"Output {index + 1}\n----------")
print(f"Text:\n{output['text']}\n")
print(f"Stop reason: {output['stop_reason']}\n")
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 Mistral AI model {model_id}.")
if __name__ == "__main__":
main()
```
# Chat-Vervollständigung von Mistral AI
Mit der API zur Chat-Vervollständigung von Mistral AI können Konversationsanwendungen erstellt werden.
**Tipp**
Sie können die API von Mistral AI zur Chat-Vervollständigung mit den grundlegenden Inferenzoperationen ([InvokeModel](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModel.html) oder [InvokeModelWithResponseStream](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModelWithResponseStream.html)) verwenden. Wir empfehlen jedoch, die Converse-API zu verwenden, um Nachrichten in Ihrer Anwendung zu implementieren. Die 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 einer Konversation mit den Converse-API-Operationen](conversation-inference.md).
Modelle von Mistral AI sind unter der [Apache-2.0-Lizenz](https://www.apache.org/licenses/LICENSE-2.0.txt) verfügbar. Weitere Informationen zur Verwendung von Modellen von Mistral AI finden Sie in der [Dokumentation für Mistral AI](https://docs.mistral.ai/).
**Topics**
+ [Unterstützte Modelle](#mistral-supported-models-chat-completion)
+ [Anforderung und Antwort](#model-parameters-mistral-chat-completion-request-response)
## Unterstützte Modelle
Sie können die folgenden Modelle von Mistral AI verwenden.
+ Mistral Large
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).
## Anforderung und Antwort
------
#### [ Request ]
Die Modelle von Mistral AI haben die folgenden Inferenzparameter.
```
{
"messages": [
{
"role": "system"|"user"|"assistant",
"content": str
},
{
"role": "assistant",
"content": "",
"tool_calls": [
{
"id": str,
"function": {
"name": str,
"arguments": str
}
}
]
},
{
"role": "tool",
"tool_call_id": str,
"content": str
}
],
"tools": [
{
"type": "function",
"function": {
"name": str,
"description": str,
"parameters": dict
}
}
],
"tool_choice": "auto"|"any"|"none",
"max_tokens": int,
"top_p": float,
"temperature": float
}
```
Die folgenden Parameter sind erforderlich.
+ **messages** – (erforderlich) Die Nachrichten, die Sie an das Modell übergeben möchten
+ **role** – Die Rolle für die Nachricht. Gültige Werte sind:
+ **system** – legt das Verhalten und den Kontext für das Modell in der Konversation fest
+ **user** – Die Benutzernachricht, die an das Modell gesendet werden soll
+ **assistant** – Die Antwort des Modells
+ **content** – Der Inhalt der Nachricht
```
[
{
"role": "user",
"content": "What is the most popular song on WZPZ?"
}
]
```
Verwenden Sie JSON mit den folgenden Feldern, um ein Tool-Ergebnis zu übergeben.
+ **role** – Die Rolle für die Nachricht. Der -Wert muss lauten `tool`.
+ **tool\$1call\$1id** – Die ID der Tool-Anfrage. Sie erhalten die ID aus den `tool_calls`-Feldern in der Antwort der vorherigen Anforderung.
+ **content** – Das Ergebnis des Tools
Das folgende Beispiel ist das Ergebnis eines Tools, das den beliebtesten Song eines Radiosenders ermittelt.
```
{
"role": "tool",
"tool_call_id": "v6RMMiRlT7ygYkT4uULjtg",
"content": "{\"song\": \"Elemental Hotel\", \"artist\": \"8 Storey Hike\"}"
}
```
Die folgenden Parameter sind optional.
+ **tools** – Definitionen von Werkzeugen, die das Modell verwenden kann.
Wenn Sie `tools` in Ihrer Anforderung angeben, gibt das Modell möglicherweise ein Feld `tool_calls` in der Nachricht zurück, das die Verwendung dieser Tools durch das Modell darstellt. Sie können diese Tools dann mit der vom Modell generierten Tool-Eingabe ausführen und anschließend optional Ergebnisse mithilfe von `tool_result`-Inhaltsblöcken an das Modell zurückgeben.
Das folgende Beispiel bezieht sich auf ein Tool, das den beliebtesten Song eines Radiosenders ermittelt.
```
[
{
"type": "function",
"function": {
"name": "top_song",
"description": "Get the most popular song played on a radio station.",
"parameters": {
"type": "object",
"properties": {
"sign": {
"type": "string",
"description": "The call sign for the radio station for which you want the most popular song. Example calls signs are WZPZ and WKRP."
}
},
"required": [
"sign"
]
}
}
}
]
```
+ **tool\$1choice** – Gibt an, wie Funktionen aufgerufen werden. Wenn diese Option auf `none` festgelegt ist, ruft das Modell keine Funktion auf und generiert stattdessen eine Nachricht. Wenn diese Option `auto` eingestellt ist, kann das Modell wählen, ob entweder eine Nachricht generiert oder eine Funktion aufgerufen werden soll. Wenn diese Option auf `any` festgelegt ist, ist das Modell gezwungen, eine Funktion aufzurufen.
+ **max\$1tokens** – Geben Sie die maximale Anzahl von Token an, die in der generierten Antwort verwendet werden soll. Das Modell kürzt die Antwort, sobald der generierte Text den Wert überschreitet `max_tokens`.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/bedrock/latest/userguide/model-parameters-mistral-chat-completion.html)
+ **temperature** – Steuert die Zufälligkeit der vom Modell getroffenen Vorhersagen. Weitere Informationen finden Sie unter [So beeinflussen Sie die Antwortgenerierung mit Inferenzparametern](inference-parameters.md).
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/bedrock/latest/userguide/model-parameters-mistral-chat-completion.html)
+ **top\$1p** – Steuert die Diversität des Texts, den das Modell generiert, indem der Prozentsatz der wahrscheinlichsten Kandidaten festgelegt wird, die das Modell für das nächste Token in Erwägung zieht. Weitere Informationen finden Sie unter [So beeinflussen Sie die Antwortgenerierung mit Inferenzparametern](inference-parameters.md).
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/bedrock/latest/userguide/model-parameters-mistral-chat-completion.html)
------
#### [ Response ]
Die `body`-Antwort eines Aufrufs von `InvokeModel` lautet wie folgt:
```
{
"choices": [
{
"index": 0,
"message": {
"role": "assistant",
"content": str,
"tool_calls": [...]
},
"stop_reason": "stop"|"length"|"tool_calls"
}
]
}
```
Die `body`-Antwort enthält folgende mögliche Felder:
+ **choices** – Die Ausgabe aus den Modellfeldern
+ **index** – Der Index für die Nachricht
+ **message** – Die Nachricht des Modells
+ **role** – Die Rolle für die Nachricht.
+ **content** – Der Inhalt der Nachricht
+ **tool\$1calls** – Wenn der Wert von `stop_reason` `tool_calls` lautet, enthält dieses Feld eine Liste von Tool-Anfragen, die Sie laut Modell ausführen sollen.
+ **id** – Die ID für die Tool-Anfrage
+ **function** – Die Funktion, die das Modell anfordert
+ **name** – Der Name der Funktion
+ **arguments** – Die Argumente, die an das Tool übergeben werden sollen
Das folgende Beispiel ist eine Anforderung für ein Tool, das den beliebtesten Song eines Radiosenders ermittelt.
```
[
{
"id": "v6RMMiRlT7ygYkT4uULjtg",
"function": {
"name": "top_song",
"arguments": "{\"sign\": \"WZPZ\"}"
}
}
]
```
+ **stop\$1reason** – Der Grund, warum die Antwort keinen Text mehr generiert hat. Die möglichen Werte sind:
+ **Stopp** – Das Modell hat die Textgenerierung für die Eingabeaufforderung abgeschlossen. Das Modell wird beendet, weil kein Inhalt mehr generiert werden muss oder wenn das Modell eine der Stoppsequenzen generiert, die Sie im Anforderungsparameter `stop` definieren.
+ **length** – Die Länge der Token für den generierten Text überschreitet den Wert `max_tokens`. Die Antwort wird auf `max_tokens` Token gekürzt.
+ **tool\$1calls** – Das Modell fordert Sie auf, ein Tool auszuführen.
------
# Parameter und Inferenz von Mistral AI Large (24.07)
Mit der API zur Chat-Vervollständigung von Mistral AI können Sie Konversationsanwendungen erstellen. Sie können auch die Converse-API von Amazon Bedrock mit diesem Modell verwenden. Sie können Tools nutzen, um Funktionsaufrufe zu tätigen.
**Tipp**
Sie können die API von Mistral AI zur Chat-Vervollständigung mit den grundlegenden Inferenzoperationen ([InvokeModel](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModel.html) oder [InvokeModelWithResponseStream](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModelWithResponseStream.html)) verwenden. Wir empfehlen jedoch, die Converse-API zu verwenden, um Nachrichten in Ihrer Anwendung zu implementieren. Die 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 einer Konversation mit den Converse-API-Operationen](conversation-inference.md).
Modelle von Mistral AI sind unter der [Apache-2.0-Lizenz](https://www.apache.org/licenses/LICENSE-2.0.txt) verfügbar. Weitere Informationen zur Verwendung von Modellen von Mistral AI finden Sie in der [Dokumentation für Mistral AI](https://docs.mistral.ai/).
**Topics**
+ [Unterstützte Modelle](#mistral-supported-models-chat-completion)
+ [Beispiele für Anforderung und Antwort](#model-parameters-mistral-large-2407-request-response)
## Unterstützte Modelle
Sie können die folgenden Modelle von Mistral AI mit den Codebeispielen auf dieser Seite verwenden.
+ Mistral Large 2 (24.07)
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).
## Beispiele für Anforderung und Antwort
------
#### [ Request ]
Beispiel für den Modellaufruf von Mistral AI Large (24.07)
```
import boto3
import json
bedrock = session.client('bedrock-runtime', 'us-west-2')
response = bedrock.invoke_model(
modelId='mistral.mistral-large-2407-v1:0',
body=json.dumps({
'messages': [
{
'role': 'user',
'content': 'which llm are you?'
}
],
})
)
print(json.dumps(json.loads(response['body']), indent=4))
```
------
#### [ Converse ]
Converse-Beispiel von Mistral AI Large (24.07)
```
import boto3
import json
bedrock = session.client('bedrock-runtime', 'us-west-2')
response = bedrock.converse(
modelId='mistral.mistral-large-2407-v1:0',
messages=[
{
'role': 'user',
'content': [
{
'text': 'which llm are you?'
}
]
}
]
)
print(json.dumps(json.loads(response['body']), indent=4))
```
------
#### [ invoke\$1model\$1with\$1response\$1stream ]
Beispiel für invoke\$1model\$1with\$1response\$1stream von Mistral AI Large (24.07)
```
import boto3
import json
bedrock = session.client('bedrock-runtime', 'us-west-2')
response = bedrock.invoke_model_with_response_stream(
"body": json.dumps({
"messages": [{"role": "user", "content": "What is the best French cheese?"}],
}),
"modelId":"mistral.mistral-large-2407-v1:0"
)
stream = response.get('body')
if stream:
for event in stream:
chunk=event.get('chunk')
if chunk:
chunk_obj=json.loads(chunk.get('bytes').decode())
print(chunk_obj)
```
------
#### [ converse\$1stream ]
Converse\$1stream-Beispiel von Mistral AI Large (24.07)
```
import boto3
import json
bedrock = session.client('bedrock-runtime', 'us-west-2')
mistral_params = {
"messages": [{
"role": "user","content": [{"text": "What is the best French cheese? "}]
}],
"modelId":"mistral.mistral-large-2407-v1:0",
}
response = bedrock.converse_stream(**mistral_params)
stream = response.get('stream')
if stream:
for event in stream:
if 'messageStart' in event:
print(f"\nRole: {event['messageStart']['role']}")
if 'contentBlockDelta' in event:
print(event['contentBlockDelta']['delta']['text'], end="")
if 'messageStop' in event:
print(f"\nStop reason: {event['messageStop']['stopReason']}")
if 'metadata' in event:
metadata = event['metadata']
if 'usage' in metadata:
print("\nToken usage ... ")
print(f"Input tokens: {metadata['usage']['inputTokens']}")
print(
f":Output tokens: {metadata['usage']['outputTokens']}")
print(f":Total tokens: {metadata['usage']['totalTokens']}")
if 'metrics' in event['metadata']:
print(
f"Latency: {metadata['metrics']['latencyMs']} milliseconds")
```
------
#### [ JSON Output ]
JSON-Ausgabebeispiel von Mistral AI Large (24.07)
```
import boto3
import json
bedrock = session.client('bedrock-runtime', 'us-west-2')
mistral_params = {
"body": json.dumps({
"messages": [{"role": "user", "content": "What is the best French meal? Return the name and the ingredients in short JSON object."}]
}),
"modelId":"mistral.mistral-large-2407-v1:0",
}
response = bedrock.invoke_model(**mistral_params)
body = response.get('body').read().decode('utf-8')
print(json.loads(body))
```
------
#### [ Tooling ]
Tools-Beispiel von Mistral AI Large (24.07)
```
data = {
'transaction_id': ['T1001', 'T1002', 'T1003', 'T1004', 'T1005'],
'customer_id': ['C001', 'C002', 'C003', 'C002', 'C001'],
'payment_amount': [125.50, 89.99, 120.00, 54.30, 210.20],
'payment_date': ['2021-10-05', '2021-10-06', '2021-10-07', '2021-10-05', '2021-10-08'],
'payment_status': ['Paid', 'Unpaid', 'Paid', 'Paid', 'Pending']
}
# Create DataFrame
df = pd.DataFrame(data)
def retrieve_payment_status(df: data, transaction_id: str) -> str:
if transaction_id in df.transaction_id.values:
return json.dumps({'status': df[df.transaction_id == transaction_id].payment_status.item()})
return json.dumps({'error': 'transaction id not found.'})
def retrieve_payment_date(df: data, transaction_id: str) -> str:
if transaction_id in df.transaction_id.values:
return json.dumps({'date': df[df.transaction_id == transaction_id].payment_date.item()})
return json.dumps({'error': 'transaction id not found.'})
tools = [
{
"type": "function",
"function": {
"name": "retrieve_payment_status",
"description": "Get payment status of a transaction",
"parameters": {
"type": "object",
"properties": {
"transaction_id": {
"type": "string",
"description": "The transaction id.",
}
},
"required": ["transaction_id"],
},
},
},
{
"type": "function",
"function": {
"name": "retrieve_payment_date",
"description": "Get payment date of a transaction",
"parameters": {
"type": "object",
"properties": {
"transaction_id": {
"type": "string",
"description": "The transaction id.",
}
},
"required": ["transaction_id"],
},
},
}
]
names_to_functions = {
'retrieve_payment_status': functools.partial(retrieve_payment_status, df=df),
'retrieve_payment_date': functools.partial(retrieve_payment_date, df=df)
}
test_tool_input = "What's the status of my transaction T1001?"
message = [{"role": "user", "content": test_tool_input}]
def invoke_bedrock_mistral_tool():
mistral_params = {
"body": json.dumps({
"messages": message,
"tools": tools
}),
"modelId":"mistral.mistral-large-2407-v1:0",
}
response = bedrock.invoke_model(**mistral_params)
body = response.get('body').read().decode('utf-8')
body = json.loads(body)
choices = body.get("choices")
message.append(choices[0].get("message"))
tool_call = choices[0].get("message").get("tool_calls")[0]
function_name = tool_call.get("function").get("name")
function_params = json.loads(tool_call.get("function").get("arguments"))
print("\nfunction_name: ", function_name, "\nfunction_params: ", function_params)
function_result = names_to_functions[function_name](**function_params)
message.append({"role": "tool", "content": function_result, "tool_call_id":tool_call.get("id")})
new_mistral_params = {
"body": json.dumps({
"messages": message,
"tools": tools
}),
"modelId":"mistral.mistral-large-2407-v1:0",
}
response = bedrock.invoke_model(**new_mistral_params)
body = response.get('body').read().decode('utf-8')
body = json.loads(body)
print(body)
invoke_bedrock_mistral_tool()
```
------
# Parameter und Inferenz von Pixtral Large (25.02)
Pixtral Large 25.02 ist ein multimodales Modell mit 124 B Parametern, das state-of-the-art Bildverständnis mit leistungsstarken Textverarbeitungsfunktionen kombiniert. AWS ist der erste Cloud-Anbieter, der Pixtral Large (25.02) als vollständig verwaltetes, serverloses Modell anbietet. Dieses Modell bietet erstklassige Leistung bei der Durchführung von Dokumentenanalysen, der Interpretation von Diagrammen und dem Verständnis natürlicher Bilder und behält gleichzeitig die erweiterten Textfunktionen von Mistral Large 2 bei.
Mit einem 128K-Kontextfenster erreicht Pixtral Large 25.02 best-in-class Leistung bei wichtigen Benchmarks wie DocVQA und. MathVista VQAv2 Das Modell bietet umfassende mehrsprachige Unterstützung in vielen Sprachen und wurde in über 80 Programmiersprachen trainiert. Zu den wichtigsten Funktionen gehören fortgeschrittenes mathematisches Denken, systemeigener Funktionsaufruf, JSON-Ausgabe und robuste Kontexttreue für RAG-Anwendungen.
Mit der API zur Chat-Vervollständigung von Mistral AI können Sie Konversationsanwendungen erstellen. Sie können auch die Converse-API von Amazon Bedrock mit diesem Modell verwenden. Sie können Tools nutzen, um Funktionsaufrufe zu tätigen.
**Tipp**
Sie können die Mistral AI Chat-Abschluss-API mit den grundlegenden Inferenzoperationen (oder) verwenden. [InvokeModel[InvokeModelWithResponseStream](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModelWithResponseStream.html)](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModel.html) Wir empfehlen jedoch, die Converse-API zu verwenden, um Nachrichten in Ihrer Anwendung zu implementieren. Die 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 einer Konversation mit den Converse-API-Operationen](conversation-inference.md).
Das Modell Mistral AI Pixtral Large ist unter der [Mistral Research License](https://mistral.ai/licenses/MRL-0.1.md) erhältlich. Weitere Informationen zur Verwendung von Modellen von Mistral AI finden Sie in der [Dokumentation für Mistral AI](https://docs.mistral.ai/).
**Topics**
+ [Unterstützte Modelle](#mistral-supported-models-chat-completion)
+ [Beispiele für Anforderung und Antwort](#model-parameters-pixtral-large-2502-request-response)
## Unterstützte Modelle
Sie können die folgenden Modelle von Mistral AI mit den Codebeispielen auf dieser Seite verwenden.
+ Pixtral Large (25.02)
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).
## Beispiele für Anforderung und Antwort
------
#### [ Request ]
Beispiel für den Modellaufruf von Pixtral Large (25.02)
```
import boto3
import json
import base64
input_image = "image.png"
with open(input_image, "rb") as f:
image = f.read()
image_bytes = base64.b64encode(image).decode("utf-8")
bedrock = boto3.client(
service_name='bedrock-runtime',
region_name="us-east-1")
request_body = {
"messages" : [
{
"role" : "user",
"content" : [
{
"text": "Describe this picture:",
"type": "text"
},
{
"type" : "image_url",
"image_url" : {
"url" : f"data:image/png;base64,{image_bytes}"
}
}
]
}
],
"max_tokens" : 10
}
response = bedrock.invoke_model(
modelId='us.mistral.pixtral-large-2502-v1:0',
body=json.dumps(request_body)
)
print(json.dumps(json.loads(response.get('body').read()), indent=4))
```
------
#### [ Converse ]
Converse-Beispiel von Pixtral Large (25.02)
```
import boto3
import json
import base64
input_image = "image.png"
with open(input_image, "rb") as f:
image_bytes = f.read()
bedrock = boto3.client(
service_name='bedrock-runtime',
region_name="us-east-1")
messages =[
{
"role" : "user",
"content" : [
{
"text": "Describe this picture:"
},
{
"image": {
"format": "png",
"source": {
"bytes": image_bytes
}
}
}
]
}
]
response = bedrock.converse(
modelId='mistral.pixtral-large-2502-v1:0',
messages=messages
)
print(json.dumps(response.get('output'), indent=4))
```
------
#### [ invoke\$1model\$1with\$1response\$1stream ]
Beispiel für invoke\$1model\$1with\$1response\$1stream von Pixtral Large (25.02)
```
import boto3
import json
import base64
input_image = "image.png"
with open(input_image, "rb") as f:
image = f.read()
image_bytes = base64.b64encode(image).decode("utf-8")
bedrock = boto3.client(
service_name='bedrock-runtime',
region_name="us-east-1")
request_body = {
"messages" : [
{
"role" : "user",
"content" : [
{
"text": "Describe this picture:",
"type": "text"
},
{
"type" : "image_url",
"image_url" : {
"url" : f"data:image/png;base64,{image_bytes}"
}
}
]
}
],
"max_tokens" : 10
}
response = bedrock.invoke_model_with_response_stream(
modelId='us.mistral.pixtral-large-2502-v1:0',
body=json.dumps(request_body)
)
stream = response.get('body')
if stream:
for event in stream:
chunk=event.get('chunk')
if chunk:
chunk_obj=json.loads(chunk.get('bytes').decode())
print(chunk_obj)
```
------
#### [ converse\$1stream ]
Converse\$1stream-Beispiel von Pixtral Large (25.02)
```
import boto3
import json
import base64
input_image = "image.png"
with open(input_image, "rb") as f:
image_bytes = f.read()
bedrock = boto3.client(
service_name='bedrock-runtime',
region_name="us-east-1")
messages =[
{
"role" : "user",
"content" : [
{
"text": "Describe this picture:"
},
{
"image": {
"format": "png",
"source": {
"bytes": image_bytes
}
}
}
]
}
]
response = bedrock.converse_stream(
modelId='mistral.pixtral-large-2502-v1:0',
messages=messages
)
stream = response.get('stream')
if stream:
for event in stream:
if 'messageStart' in event:
print(f"\nRole: {event['messageStart']['role']}")
if 'contentBlockDelta' in event:
print(event['contentBlockDelta']['delta']['text'], end="")
if 'messageStop' in event:
print(f"\nStop reason: {event['messageStop']['stopReason']}")
if 'metadata' in event:
metadata = event['metadata']
if 'usage' in metadata:
print("\nToken usage ... ")
print(f"Input tokens: {metadata['usage']['inputTokens']}")
print(
f":Output tokens: {metadata['usage']['outputTokens']}")
print(f":Total tokens: {metadata['usage']['totalTokens']}")
if 'metrics' in event['metadata']:
print(
f"Latency: {metadata['metrics']['latencyMs']} milliseconds")
```
------
#### [ JSON Output ]
JSON-Ausgabebeispiel von Pixtral Large (25.02)
```
import boto3
import json
bedrock = session.client('bedrock-runtime', 'us-west-2')
mistral_params = {
"body": json.dumps({
"messages": [{"role": "user", "content": "What is the best French meal? Return the name and the ingredients in short JSON object."}]
}),
"modelId":"us.mistral.pixtral-large-2502-v1:0",
}
response = bedrock.invoke_model(**mistral_params)
body = response.get('body').read().decode('utf-8')
print(json.loads(body))
```
------
#### [ Tooling ]
Tools-Beispiel von Pixtral Large (25.02)
```
data = {
'transaction_id': ['T1001', 'T1002', 'T1003', 'T1004', 'T1005'],
'customer_id': ['C001', 'C002', 'C003', 'C002', 'C001'],
'payment_amount': [125.50, 89.99, 120.00, 54.30, 210.20],
'payment_date': ['2021-10-05', '2021-10-06', '2021-10-07', '2021-10-05', '2021-10-08'],
'payment_status': ['Paid', 'Unpaid', 'Paid', 'Paid', 'Pending']
}
# Create DataFrame
df = pd.DataFrame(data)
def retrieve_payment_status(df: data, transaction_id: str) -> str:
if transaction_id in df.transaction_id.values:
return json.dumps({'status': df[df.transaction_id == transaction_id].payment_status.item()})
return json.dumps({'error': 'transaction id not found.'})
def retrieve_payment_date(df: data, transaction_id: str) -> str:
if transaction_id in df.transaction_id.values:
return json.dumps({'date': df[df.transaction_id == transaction_id].payment_date.item()})
return json.dumps({'error': 'transaction id not found.'})
tools = [
{
"type": "function",
"function": {
"name": "retrieve_payment_status",
"description": "Get payment status of a transaction",
"parameters": {
"type": "object",
"properties": {
"transaction_id": {
"type": "string",
"description": "The transaction id.",
}
},
"required": ["transaction_id"],
},
},
},
{
"type": "function",
"function": {
"name": "retrieve_payment_date",
"description": "Get payment date of a transaction",
"parameters": {
"type": "object",
"properties": {
"transaction_id": {
"type": "string",
"description": "The transaction id.",
}
},
"required": ["transaction_id"],
},
},
}
]
names_to_functions = {
'retrieve_payment_status': functools.partial(retrieve_payment_status, df=df),
'retrieve_payment_date': functools.partial(retrieve_payment_date, df=df)
}
test_tool_input = "What's the status of my transaction T1001?"
message = [{"role": "user", "content": test_tool_input}]
def invoke_bedrock_mistral_tool():
mistral_params = {
"body": json.dumps({
"messages": message,
"tools": tools
}),
"modelId":"us.mistral.pixtral-large-2502-v1:0",
}
response = bedrock.invoke_model(**mistral_params)
body = response.get('body').read().decode('utf-8')
body = json.loads(body)
choices = body.get("choices")
message.append(choices[0].get("message"))
tool_call = choices[0].get("message").get("tool_calls")[0]
function_name = tool_call.get("function").get("name")
function_params = json.loads(tool_call.get("function").get("arguments"))
print("\nfunction_name: ", function_name, "\nfunction_params: ", function_params)
function_result = names_to_functions[function_name](**function_params)
message.append({"role": "tool", "content": function_result, "tool_call_id":tool_call.get("id")})
new_mistral_params = {
"body": json.dumps({
"messages": message,
"tools": tools
}),
"modelId":"us.mistral.pixtral-large-2502-v1:0",
}
response = bedrock.invoke_model(**new_mistral_params)
body = response.get('body').read().decode('utf-8')
body = json.loads(body)
print(body)
invoke_bedrock_mistral_tool()
```
------
# Modelle von OpenAI
OpenAI bietet die folgenden Open-Weight-Modelle an:
+ [https://huggingface.co/openai/gpt-oss-20b](https://huggingface.co/openai/gpt-oss-20b) – Ein kleineres Modell, das für geringere Latenz und lokale oder spezielle Anwendungsfälle optimiert ist
+ [https://huggingface.co/openai/gpt-oss-120b](https://huggingface.co/openai/gpt-oss-120b) – Ein größeres Modell, das für die Produktion und allgemeine Anwendungsfälle oder Anwendungsfälle mit anspruchsvollem Reasoning optimiert ist
In der folgenden Tabelle werden Informationen zu den Modellen zusammengefasst:
| Informationen | gpt-oss-20b | gpt-oss-120b |
| --- | --- | --- |
| Datum der Veröffentlichung | 5. August 2025 | 5. August 2025 |
| Modell-ID | openai.gpt-oss-20b-1:0 | openai.gpt-oss-120b-1:0 |
| Product iD (Produkt-ID) | – | – |
| Unterstützte Eingabemodalitäten | Text | Text |
| Unterstützte Ausgabemodalitäten | Text | Text |
| Kontextfenster | 128.000 | 128.000 |
Die OpenAI-Modelle unterstützen folgende Features:
+ [Modellaufruf](inference.md) mit den folgenden Operationen:
+ [InvokeModel](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModel.html)
+ [Converse](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_Converse.html)
+ [API für OpenAI-Chat-Vervollständigungen](inference-chat-completions.md)
+ [Batch-Inferenz](batch-inference.md) mit [CreateModelInvocationJob](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_CreateModelInvocationJob.html).
+ [Integritätsschutz](guardrails.md)-Anwendung durch die Verwendung von Headern in den Modellaufrufoperationen
**Topics**
+ [OpenAI-Anfragestext](#model-parameters-openai-request)
+ [OpenAI-Antworttext](#model-parameters-openai-response)
+ [Beispiel für die Verwendung von OpenAI-Modellen](#model-parameters-openai-use)
## OpenAI-Anfragestext
Informationen zu den Parametern im Anforderungstext und ihren Beschreibungen finden Sie unter [Erstellen der Chat-Vervollständigung](https://platform.openai.com/docs/api-reference/chat/create) in der OpenAI-Dokumentation.
Verwenden Sie die Anforderungstextfelder wie folgt:
+ Fügen Sie in einer Anfrage [InvokeModel](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModel.html)oder einer Anfrage zum Abschluss des OpenAI Chats die Felder in den Anfragetext ein.
+ Gehen Sie in einer [Converse](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_Converse.html)-Anfrage wie folgt vor:
+ Ordnen Sie `messages` wie folgt zu:
+ Fügen Sie für jede Nachricht, deren Rolle darin besteht`developer`, das `content` A [SystemContentBlock](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_SystemContentBlock.html)in das `system` Array ein.
+ Fügen Sie für jede Nachricht`assistant`, deren Rolle `user` oder ist, das `content` zu a [ContentBlock](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_ContentBlock.html)im `content` Feld hinzu und geben Sie das `role` im `role` Feld einer [Nachricht](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_Message.html) im `messages` Array an.
+ Ordnen Sie die Werte für die folgenden Felder den entsprechenden Feldern im `inferenceConfig`-Objekt zu:
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/bedrock/latest/userguide/model-parameters-openai.html)
+ Schließt alle anderen Felder in das `additionalModelRequestFields`-Objekt ein.
**Überlegungen zum Aufsetzen des Anforderungstextes**
+ Die OpenAI-Modelle unterstützen nur Texteingabe und -ausgabe.
+ Der Wert im Feld `model` muss mit dem Wert im Header übereinstimmen. Sie können dieses Feld weglassen, damit es automatisch mit demselben Wert wie im Header gefüllt wird.
+ Der Wert im Feld `stream` muss mit der API-Operation übereinstimmen, die Sie verwenden. Sie können dieses Feld weglassen, damit es automatisch mit dem korrekten Wert gefüllt wird.
+ Wenn Sie verwenden [InvokeModel](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModel.html), muss der `stream` Wert sein`false`.
## OpenAI-Antworttext
Der Antworttext für OpenAI-Modelle entspricht dem Objekt zur Chat-Vervollständigung, das von OpenAI zurückgegeben wurde. Weitere Informationen zu den Antwortfeldern finden Sie unter [Das Chat-Vervollständigungsobjekt](https://platform.openai.com/docs/api-reference/chat/object) in der OpenAI-Dokumentation.
**Anmerkung**
Wenn Sie `InvokeModel` verwenden, geht das Reasoning des Modells, umgeben von ``-Tags, dem Textinhalt der Antwort voraus.
## Beispiel für die Verwendung von OpenAI-Modellen
Dieser Abschnitt enthält einige Beispiele für die Verwendung der OpenAI-Modelle.
### Voraussetzungen
Bevor Sie diese Beispiele ausprobieren, überprüfen Sie, ob Sie die Voraussetzungen erfüllt haben:
+ **Authentifizierung** — Sie können sich entweder mit Ihren AWS Anmeldeinformationen oder mit einem Amazon Bedrock API-Schlüssel authentifizieren.
Richten Sie Ihre AWS Anmeldeinformationen ein oder generieren Sie einen Amazon Bedrock API-Schlüssel, um Ihre Anfrage zu authentifizieren.
+ Weitere Informationen zum Einrichten Ihrer AWS Anmeldeinformationen finden Sie unter [Programmatischer Zugriff mit AWS](https://docs.aws.amazon.com/IAM/latest/UserGuide/security-creds-programmatic-access.html) Sicherheitsanmeldedaten.
+ Weitere Informationen zu Amazon Bedrock API-Schlüsseln und deren Generierung finden Sie im Abschnitt API-Schlüssel im Kapitel Build.
**Anmerkung**
Wenn Sie die Chat-Vervollständigungs-API von OpenAI verwenden, können Sie sich nur mit einem API-Schlüssel von Amazon Bedrock authentifizieren.
+ **Endpunkt** — Finden Sie den Endpunkt, der der AWS Region entspricht, die in [Amazon Bedrock Runtime-Endpunkten und](https://docs.aws.amazon.com/general/latest/gr/bedrock.html#br-rt) -Kontingenten verwendet werden soll. Wenn Sie ein AWS SDK verwenden, müssen Sie bei der Einrichtung des Clients möglicherweise nur den Regionalcode und nicht den gesamten Endpunkt angeben. Sie müssen einen Endpunkt verwenden, der einer Region zugeordnet ist, die von dem im Beispiel verwendeten Modell unterstützt wird.
+ **Modellzugriff** – Fordern Sie den Zugriff auf ein OpenAI-Modell an. Weitere Informationen finden Sie unter [Modellzugriff mit SDK und CLI verwalten](model-access.md#model-access-modify).
+ **(Wenn das Beispiel ein SDK verwendet) Installieren Sie das SDK** — Richten Sie nach der Installation Standardanmeldedaten und eine AWS Standardregion ein. Wenn Sie keine Standardanmeldeinformationen oder -region einrichten, müssen Sie diese in den entsprechenden Codebeispielen explizit angeben. Weitere Informationen zu standardisierten Anbietern von Anmeldeinformationen finden Sie unter [AWS SDKs Tools für standardisierte Anmeldeinformationsanbieter](https://docs.aws.amazon.com/sdkref/latest/guide/standardized-credentials.html).
**Anmerkung**
Wenn Sie das OpenAI SDK verwenden, können Sie sich nur mit einem API-Schlüssel von Amazon Bedrock authentifizieren und müssen den Amazon-Bedrock-Endpunkt explizit festlegen.
Erweitern Sie den Abschnitt für das Beispiel, das Sie sehen möchten:
### Erstellen von OpenAI-Chat-Vervollständigungen
Wenn Sie Beispiele für die Verwendung der OpenAI-API zum Erstellen von Chat-Vervollständigungen sehen möchten, wählen Sie die Registerkarte für Ihre bevorzugte Methode aus und führen Sie dann die folgenden Schritte aus:
------
#### [ OpenAI SDK (Python) ]
Das folgende Python-Skript ruft die API zum Erstellen von Chat-Vervollständigungen mit dem OpenAI-Python SDK auf:
```
from openai import OpenAI
client = OpenAI(
base_url="https://bedrock-runtime.us-west-2.amazonaws.com/openai/v1",
api_key="$AWS_BEARER_TOKEN_BEDROCK" # Replace with actual API key
)
completion = client.chat.completions.create(
model="openai.gpt-oss-20b-1:0",
messages=[
{
"role": "developer",
"content": "You are a helpful assistant."
},
{
"role": "user",
"content": "Hello!"
}
]
)
print(completion.choices[0].message)
```
------
#### [ HTTP request using curl ]
Sie können den folgenden Befehl in einem Terminal ausführen, um die API zum Erstellen von Chat-Vervollständigungen mit curl aufzurufen:
```
curl -X POST https://bedrock-runtime.us-west-2.amazonaws.com/openai/v1/chat/completions \
-H "Content-Type: application/json" \
-H "Authorization: Bearer $AWS_BEARER_TOKEN_BEDROCK" \
-d '{
"model": "openai.gpt-oss-20b-1:0",
"messages": [
{
"role": "developer",
"content": "You are a helpful assistant."
},
{
"role": "user",
"content": "Hello!"
}
]
}'
```
------
### InvokeModel
Wählen Sie die Registerkarte für Ihre bevorzugte Methode aus und befolgen Sie dann die Schritte:
------
#### [ Python ]
```
import boto3
import json
# Initialize the Bedrock Runtime client
client = boto3.client('bedrock-runtime')
# Model ID
model_id = 'openai.gpt-oss-20b-1:0'
# Create the request body
native_request = {
"model": model_id, # You can omit this field
"messages": [
{
"role": "system",
"content": "You are a helpful assistant."
},
{
"role": "assistant",
"content": "Hello! How can I help you today?"
},
{
"role": "user",
"content": "What is the weather like today?"
}
],
"max_completion_tokens": 150,
"temperature": 0.7,
"top_p": 0.9,
"stream": False # You can omit this field
}
# Make the InvokeModel request
response = client.invoke_model(
modelId=model_id,
body=json.dumps(native_request)
)
# Parse and print the message for each choice in the chat completion
response_body = json.loads(response['body'].read().decode('utf-8'))
for choice in response_body['choices']:
print(choice['message']['content'])
```
------
### Converse
Wenn Sie die einheitliche [Converse](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_Converse.html)-API verwenden, müssen Sie die OpenAI-Felder zum Erstellen von Chat-Vervollständigungen dem entsprechenden Feld im Converse-Anfragestext zuordnen.
Vergleichen Sie beispielsweise den folgenden Text der Anforderung zur Chat-Vervollständigung mit dem entsprechenden Anforderungstext von Converse:
------
#### [ Create chat completion request body ]
```
{
"model": "openai.gpt-oss-20b-1:0",
"messages": [
{
"role": "developer",
"content": "You are a helpful assistant."
},
{
"role": "assistant",
"content": "Hello! How can I help you today?"
},
{
"role": "user",
"content": "What is the weather like today?"
}
],
"max_completion_tokens": 150,
"temperature": 0.7
}
```
------
#### [ Converse request body ]
```
{
"messages": [
{
"role": "user",
"content": [
{
"text": "Hello! How can I help you today?"
}
]
},
{
"role": "user",
"content": [
{
"text": "What is the weather like today?"
}
]
}
],
"system": [
{
"text": "You are a helpful assistant."
}
],
"inferenceConfig": {
"maxTokens": 150,
"temperature": 0.7
}
}
```
------
Wählen Sie die Registerkarte für Ihre bevorzugte Methode aus und befolgen Sie dann die Schritte:
------
#### [ Python ]
```
# Use the Conversation API to send a text message to Anthropic Claude.
import boto3
from botocore.exceptions import ClientError
# Initialize the Bedrock Runtime client
client = boto3.client("bedrock-runtime")
# Set the model ID
model_id = "openai.gpt-oss-20b-1:0"
# Set up messages and system message
messages = [
{
"role": "assistant",
"content": [
{
"text": "Hello! How can I help you today?"
}
]
},
{
"role": "user",
"content": [
{
"text": "What is the weather like today?"
}
]
}
]
system = [
{
"text": "You are a helpful assistant."
}
]
try:
# Send the message to the model, using a basic inference configuration.
response = client.converse(
modelId=model_id,
messages=messages,
system=system,
inferenceConfig={
"maxTokens": 150,
"temperature": 0.7,
"topP": 0.9
},
)
# Extract and print the response text.
for content_block in response["output"]["message"]["content"]:
print(content_block)
except (ClientError, Exception) as e:
print(f"ERROR: Can't invoke '{model_id}'. Reason: {e}")
exit(1)
```
------
### Leitplanken mit InvokeModel
Wenden Sie beim Ausführen eines Modellaufrufs einen Integritätsschutz an, indem Sie die Integritätsschutz-ID, die Version und die Information angeben, ob der Integritätsschutz-Trace im Header einer Modellaufrufanforderung aktiviert werden soll oder nicht.
Wählen Sie die Registerkarte für Ihre bevorzugte Methode aus und befolgen Sie die angegebenen Schritte:
------
#### [ Python ]
```
import boto3
from botocore.exceptions import ClientError
import json
# Initiate the Amazon Bedrock Runtime client
bedrock_runtime = boto3.client("bedrock-runtime")
# Model ID
model_id = "openai.gpt-oss-20b-1:0"
# Replace with actual values from your guardrail
guardrail_id = "GR12345"
guardrail_version = "DRAFT"
# Create the request body
native_request = {
"model": model_id, # You can omit this field
"messages": [
{
"role": "system",
"content": "You are a helpful assistant."
},
{
"role": "assistant",
"content": "Hello! How can I help you today?"
},
{
"role": "user",
"content": "What is the weather like today?"
}
],
"max_completion_tokens": 150,
"temperature": 0.7,
"top_p": 0.9,
"stream": False # You can omit this field
}
try:
response = bedrock_runtime.invoke_model(
modelId=model_id,
body=json.dumps(native_request),
guardrailIdentifier=guardrail_id,
guardrailVersion=guardrail_version,
trace='ENABLED',
)
response_body = json.loads(response.get('body').read())
print("Received response from InvokeModel API (Request Id: {})".format(response['ResponseMetadata']['RequestId']))
print(json.dumps(response_body, indent=2))
except ClientError as err:
print("RequestId = " + err.response['ResponseMetadata']['RequestId'])
raise err
```
------
### Integritätsschutz mit OpenAI-Chat-Vervollständigungen
Wenn Sie Beispiele für die Verwendung des Integritätsschutzes mit OpenAI-Chat-Vervollständigungen sehen möchten, wählen Sie die Registerkarte für Ihre bevorzugte Methode aus und führen Sie dann die folgenden Schritte aus:
------
#### [ OpenAI SDK (Python) ]
```
import openai
from openai import OpenAIError
# Endpoint for Amazon Bedrock Runtime
bedrock_endpoint = "https://bedrock-runtime.us-west-2.amazonaws.com/openai/v1"
# Model ID
model_id = "openai.gpt-oss-20b-1:0"
# Replace with actual values
bedrock_api_key = "$AWS_BEARER_TOKEN_BEDROCK"
guardrail_id = "GR12345"
guardrail_version = "DRAFT"
client = openai.OpenAI(
api_key=bedrock_api_key,
base_url=bedrock_endpoint,
)
try:
response = client.chat.completions.create(
model=model_id,
# Specify guardrail information in the header
extra_headers={
"X-Amzn-Bedrock-GuardrailIdentifier": guardrail_id,
"X-Amzn-Bedrock-GuardrailVersion": guardrail_version,
"X-Amzn-Bedrock-Trace": "ENABLED",
},
# Additional guardrail information can be specified in the body
extra_body={
"amazon-bedrock-guardrailConfig": {
"tagSuffix": "xyz" # Used for input tagging
}
},
messages=[
{
"role": "system",
"content": "You are a helpful assistant."
},
{
"role": "assistant",
"content": "Hello! How can I help you today?"
},
{
"role": "user",
"content": "What is the weather like today?"
}
]
)
request_id = response._request_id
print(f"Request ID: {request_id}")
print(response)
except OpenAIError as e:
print(f"An error occurred: {e}")
if hasattr(e, 'response') and e.response is not None:
request_id = e.response.headers.get("x-request-id")
print(f"Request ID: {request_id}")
```
------
#### [ OpenAI SDK (Java) ]
```
import com.openai.client.OpenAIClient;
import com.openai.client.okhttp.OpenAIOkHttpClient;
import com.openai.core.http.HttpResponseFor;
import com.openai.models.chat.completions.ChatCompletion;
import com.openai.models.chat.completions.ChatCompletionCreateParams;
// Endpoint for Amazon Bedrock Runtime
String bedrockEndpoint = "http://bedrock-runtime.us-west-2.amazonaws.com/openai/v1"
// Model ID
String modelId = "openai.gpt-oss-20b-1:0"
// Replace with actual values
String bedrockApiKey = "$AWS_BEARER_TOKEN_BEDROCK"
String guardrailId = "GR12345"
String guardrailVersion = "DRAFT"
OpenAIClient client = OpenAIOkHttpClient.builder()
.apiKey(bedrockApiKey)
.baseUrl(bedrockEndpoint)
.build()
ChatCompletionCreateParams request = ChatCompletionCreateParams.builder()
.addUserMessage("What is the temperature in Seattle?")
.model(modelId)
// Specify additional headers for the guardrail
.putAdditionalHeader("X-Amzn-Bedrock-GuardrailIdentifier", guardrailId)
.putAdditionalHeader("X-Amzn-Bedrock-GuardrailVersion", guardrailVersion)
// Specify additional body parameters for the guardrail
.putAdditionalBodyProperty(
"amazon-bedrock-guardrailConfig",
JsonValue.from(Map.of("tagSuffix", JsonValue.of("xyz"))) // Allows input tagging
)
.build();
HttpResponseFor rawChatCompletionResponse =
client.chat().completions().withRawResponse().create(request);
final ChatCompletion chatCompletion = rawChatCompletionResponse.parse();
System.out.println(chatCompletion);
```
------
### Batch-Inferenz
Mit [Batch-Inferenz](batch-inference.md) können Sie Modellinferenzen asynchron mit mehreren Prompts ausführen. Wenn Sie Batch-Inferenz mit einem OpenAI-Modell ausführen möchten, gehen Sie wie folgt vor:
1. Erstellen Sie eine JSONL-Datei und füllen Sie sie zumindest mit der Mindestanzahl von JSON-Objekten, die jeweils durch eine neue Zeile getrennt sind. Jedes `modelInput`-Objekt muss dem Format des Anforderungstexts zur [Erstellung der OpenAI-Chat-Vervollständigung](https://platform.openai.com/docs/api-reference/chat/create) entsprechen. Im Folgenden finden Sie ein Beispiel für die ersten beiden Zeilen einer JSONL-Datei, die Anforderungstexte für OpenAI enthält.
```
{
"recordId": "RECORD1",
"modelInput": {
"messages": [
{
"role": "system",
"content": "You are a helpful assistant."
},
{
"role": "user",
"content": "Can you generate a question with a factual answer?"
}
],
"max_completion_tokens": 1000
}
}
{
"recordId": "RECORD2",
"modelInput": {
"messages": [
{
"role": "system",
"content": "You are a helpful assistant."
},
{
"role": "user",
"content": "What is the weather like today?"
}
],
"max_completion_tokens": 1000
}
}
...
```
**Anmerkung**
Das Feld `model` ist optional, da der Batch-Inferenzservice es für Sie auf der Grundlage des Headers einfügt, wenn Sie es weglassen.
Stellen Sie sicher, dass Ihre JSONL-Datei den Batch-Inferenzkontingenten entspricht, wie unter [Formatieren und Hochladen Ihrer Batch-Inferenzdaten](batch-inference-data.md) beschrieben.
1. Laden Sie die Datei in einen Amazon-S3-Bucket hoch.
1. Senden Sie eine [CreateModelInvocationJob](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_CreateModelInvocationJob.html)Anfrage mit einem [Endpunkt der Amazon Bedrock-Steuerebene](https://docs.aws.amazon.com/general/latest/gr/bedrock.html#br-cp) mit dem im `inputDataConfig` Feld angegebenen S3-Bucket aus dem vorherigen Schritt und dem im `modelId` Feld angegebenen OpenAI Modell.
Ein end-to-end Codebeispiel finden Sie unter[Batch-Inferenz – Codebeispiel](batch-inference-example.md). Ersetzen Sie die Werte durch die entsprechenden Konfigurationen für die OpenAI-Modelle.
# Modelle von Stability AI
In diesem Abschnitt werden die Anforderungsparameter und Antwortfelder für Modelle von Stability AI beschrieben. Verwenden Sie diese Informationen, um im Rahmen der Operation Inferenzrufe an Stability AI-Modelle durchzuführen. [InvokeModel](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModel.html) Dieser Abschnitt enthält auch Python-Codebeispiele, die zeigen, wie Stability-AI-Modelle aufgerufen werden. Sie benötigen die Modell-ID für das Modell, um ein Modell in einer Inferenzoperation verwenden zu können. Informationen zum Abrufen der Modell-ID finden Sie unter [Unterstützte Basismodelle in Amazon Bedrock](models-supported.md). Einige Modelle funktionieren auch mit der [Converse-API](conversation-inference.md). Informationen darüber, ob die Converse-API ein bestimmtes Stability-AI-Modell unterstützt, finden Sie unter [Unterstützte Modelle und Modellfeatures](conversation-inference-supported-models-features.md). Weitere Codebeispiele finden Sie unter [Codebeispiele für Amazon Bedrock mit AWS SDKs](service_code_examples.md).
Basismodelle in Amazon Bedrock unterstützen Eingabe- und Ausgabemodalitäten, die von Modell zu Modell variieren. Informationen zu den Modalitäten, die von Stability-AI-Modellen unterstützt werden, finden Sie unter [Unterstützte Basismodelle in Amazon Bedrock](models-supported.md). Informationen darüber, welche Amazon-Bedrock-Features die Stability-AI-Modelle unterstützen, finden Sie unter [Unterstützte Basismodelle in Amazon Bedrock](models-supported.md). Informationen darüber, AWS in welchen Regionen Stability AI-Modelle verfügbar sind, finden Sie unter[Unterstützte Basismodelle in Amazon Bedrock](models-supported.md).
Wenn Sie Inferenzaufrufe mit Stability-AI-Modellen tätigen, schließen Sie einen Prompt für das Modell ein. Allgemeine Informationen zum Erstellen von Prompts für die Modelle, die von Amazon Bedrock unterstützt werden, finden Sie unter [Prompt-Engineering-Konzepte](prompt-engineering-guidelines.md). Für Stability-AI-spezifische Informationen zu Prompts finden Sie im [Handbuch zu Prompt-Engineering von Stability AI](https://platform.stability.ai/docs/getting-started).
## Unterstützte Modelle und Bildservices
Amazon Bedrock unterstützt die folgenden Modelle und Bildservices von Stability AI.
**Anmerkung**
Der Support für alle anderen Modelle von Stability AI wird nach und nach eingestellt.
| Modell | Anwendungsfälle | Beispiel |
| --- | --- | --- |
| [Stable Image Ultra](model-parameters-diffusion-stable-ultra-text-image-request-response.md) | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/bedrock/latest/userguide/model-parameters-stability-diffusion.html) | Eine Luxusmarke verwendet Stable Image Ultra, um atemberaubende Bilder ihrer neuesten Kollektion für Magazinausgaben zu erstellen und so ein erstklassiges Erscheinungsbild zu gewährleisten, das ihren hohen Standards entspricht. |
| [Stable Diffusion 3.5 Large](model-parameters-diffusion-3-5-large.md) | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/bedrock/latest/userguide/model-parameters-stability-diffusion.html) | Ein Spieleentwicklungsteam verwendet SD3 .5 Large, um detaillierte Umgebungstexturen und Charakterkonzepte zu erstellen und so die kreative Pipeline zu beschleunigen. |
| [Stable Image Core](model-parameters-diffusion-stable-image-core-text-image-request-response.md) | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/bedrock/latest/userguide/model-parameters-stability-diffusion.html) | Ein Online-Händler verwendet Stable Image Core, um schnell Produktbilder für Neuankömmlinge zu generieren, sodass er Artikel schneller anbieten und seinen Katalog verwalten kann. up-to-date |
| [Stability AI Image Services](stable-image-services.md) | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/bedrock/latest/userguide/model-parameters-stability-diffusion.html) | Ein Medienunternehmen verwendet Such- und Umfärbungsverfahren, die Übertragung von Stilen und das Entfernen von Hintergründen, um Variationen von Bildern für eine Werbekampagne zu erstellen. |
**Topics**
+ [Unterstützte Modelle und Bildservices](#supported-stability-models)
+ [Anforderung und Antwort von Stable Image Ultra](model-parameters-diffusion-stable-ultra-text-image-request-response.md)
+ [Stability.ai Stable Diffusion 3,5 Large](model-parameters-diffusion-3-5-large.md)
+ [Anforderung und Antwort von Stable Image Core](model-parameters-diffusion-stable-image-core-text-image-request-response.md)
+ [Stability AI Image Services](stable-image-services.md)
# Anforderung und Antwort von Stable Image Ultra
Der Anforderungstext wird im `body` Feld einer Anforderung an den [InvokeModel](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModel.html)Vorgang übergeben.
**Feld für den Hauptteil der Modellaufrufanforderung**
Wenn Sie mit einem Stable Image Ultra-Modell einen InvokeModel Anruf tätigen, füllen Sie das Textfeld mit einem JSON-Objekt, das wie das folgende aussieht.
+ **prompt** – (Zeichenfolge) Was im Ausgabebild angezeigt werden soll. Ein starker, aussagekräftiger Prompt, der Elemente, Farben und Motive klar definiert, führt zu besseren Ergebnissen.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/bedrock/latest/userguide/model-parameters-diffusion-stable-ultra-text-image-request-response.html)
**Textfeld für Modellaufrufantworten**
Wenn Sie einen `InvokeModel`-Aufruf mit einem Stable Image Ultra-Modell tätigen, sieht die Antwort wie folgt aus.
```
{
'seeds': [2130420379],
"finish_reasons":[null],
"images":["..."]
}
```
Eine Antwort mit einem abschließenden Grund, der nicht `null` ist, sieht wie folgt aus:
```
{
"finish_reasons":["Filter reason: prompt"]
}
```
+ **seeds** – (Zeichenfolge) Seed-Liste zum Generieren von Bildern für das Modell
+ **finish\$1reasons** – Aufzählung, die angibt, ob die Anforderung gefiltert wurde oder nicht. `null` gibt an, dass die Anforderung erfolgreich war. Aktuelle mögliche Werte: `"Filter reason: prompt", "Filter reason: output image", "Filter reason: input image", "Inference error", null`.
+ **images** – Eine Liste generierter Bilder im base64-Zeichenfolgenformat.
Weitere Informationen finden Sie unter [https://platform.us.stability. ai/docs/api-reference\$1tag/v1 Generation](https://platform.us.stability.ai/docs/api-reference#tag/v1generation).
------
#### [ Text to image ]
Das Modell Stability.ai Stable Image Ultra hat die folgenden Inferenzparameter für einen text-to-image Inferenzaufruf.
+ **prompt** – (Zeichenfolge) Was im Ausgabebild angezeigt werden soll. Ein starker, aussagekräftiger Prompt, der Elemente, Farben und Motive klar definiert, führt zu besseren Ergebnissen.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/bedrock/latest/userguide/model-parameters-diffusion-stable-ultra-text-image-request-response.html)
**Optionale Felder**
+ **aspect\$1ratio** – (Zeichenfolge) steuert das Seitenverhältnis des generierten Bildes. Dieser Parameter ist nur für text-to-image Anfragen gültig. Standard: 1:1 Aufzählung: 16:9, 1:1, 21:9, 2:3, 3:2, 4:5, 5:4, 9:16, 9:21.
+ **Modus** — Eingestellt auf text-to-image. Standard: text-to-image. Aufzählung: `text-to-image`.
+ **output\$1format** – Gibt das Format des Ausgabebilds an. Unterstützte Formate: JPEG, PNG. Unterstützte Dimensionen: Höhe 640 bis 1 536 Pixel, Breite 640 bis 1 536 Pixel.
+ **seed** – (Zahl) Ein bestimmter Wert, der als Richtwert für die „Zufälligkeit“ der Generierung dient. (Lassen Sie diesen Parameter weg oder übergeben Sie „0“, um einen zufälligen Seed-Wert zu verwenden.) Der Bereich liegt zwischen 0 und 4294967295.
+ **negative\$1prompt** – Schlüsselwörter für das, was Sie im Ausgabebild nicht sehen möchten. Maximum: 10 000 Zeichen.
```
import boto3
import json
import base64
import io
from PIL import Image
bedrock = boto3.client('bedrock-runtime', region_name='us-west-2')
response = bedrock.invoke_model(
modelId='stability.sd3-ultra-v1:1',
body=json.dumps({
'prompt': 'A car made out of vegetables.'
})
)
output_body = json.loads(response["body"].read().decode("utf-8"))
base64_output_image = output_body["images"][0]
image_data = base64.b64decode(base64_output_image)
image = Image.open(io.BytesIO(image_data))
image.save("image.png")
```
------
#### [ Image to image ]
Das Modell Stability.ai Stable Image Ultra hat die folgenden Inferenzparameter für einen image-to-image Inferenzaufruf.
+ **prompt** – (Zeichenfolge) Was im Ausgabebild angezeigt werden soll. Ein starker, aussagekräftiger Prompt, der Elemente, Farben und Motive klar definiert, führt zu besseren Ergebnissen.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/bedrock/latest/userguide/model-parameters-diffusion-stable-ultra-text-image-request-response.html)
**Optionale Felder**
+ **image** – Das Base64-Bild, das als Ausgangspunkt für die Generierung verwendet werden soll. Unterstützte Formate: JPEG, PNG, WebP.
+ **strength** – (Zahl) Wie viel Einfluss der Bildparameter auf das generierte Bild hat. Bilder mit niedrigeren strength-Werten ähneln eher dem Originalbild. Wertebereich: 0,0–1,0. Standard: 0,35.
+ **aspect\$1ratio** – (Zeichenfolge) steuert das Seitenverhältnis des generierten Bildes. Dieser Parameter ist nur für text-to-image Anfragen gültig. Standard: 1:1 Aufzählung: 16:9, 1:1, 21:9, 2:3, 3:2, 4:5, 5:4, 9:16, 9:21.
+ **output\$1format** – Gibt das Format des Ausgabebilds an. Unterstützte Formate: JPEG, PNG. Unterstützte Dimensionen: Höhe 640 bis 1 536 Pixel, Breite 640 bis 1 536 Pixel.
+ **seed** – (Zahl) Ein bestimmter Wert, der als Richtwert für die „Zufälligkeit“ der Generierung dient. (Lassen Sie diesen Parameter weg oder übergeben Sie „0“, um einen zufälligen Seed-Wert zu verwenden.) Der Bereich liegt zwischen 0 und 4294967295.
+ **negative\$1prompt** – Schlüsselwörter für das, was Sie im Ausgabebild nicht sehen möchten. Maximum: 10 000 Zeichen.
```
import boto3
import json
import base64
import io
from PIL import Image
bedrock = boto3.client('bedrock-runtime', region_name='us-west-2')
response = bedrock.invoke_model(
modelId='stability.sd3-ultra-v1:1',
body=json.dumps({
'prompt': 'A car made out of vegetables.'
})
)
output_body = json.loads(response["body"].read().decode("utf-8"))
base64_output_image = output_body["images"][0]
image_data = base64.b64decode(base64_output_image)
image = Image.open(io.BytesIO(image_data))
image.save("image.png")
```
------
# Stability.ai Stable Diffusion 3,5 Large
Das Modell Stable Diffusion 3.5 Large verwendet 8 Milliarden Parameter und unterstützt die Ausgabe text-to-image und image-to-image Generierung mit einer Auflösung von 1 Megapixel.
Der Text der Anfrage wird im `body` Feld einer Anfrage an [InvokeModel](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModel.html)übergeben.
**Feld für den Hauptteil der Modellaufrufanforderung**
Wenn Sie mit einem Stable Diffusion 3.5 Large-Modell einen InvokeModel Anruf tätigen, füllen Sie das Textfeld mit einem JSON-Objekt, das wie das folgende aussieht.
+ **prompt** – (Zeichenfolge) Textbeschreibung des gewünschten Ausgabebildes Maximal 10.000 Zeichen.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/bedrock/latest/userguide/model-parameters-diffusion-3-5-large.html)
**Textfeld für Modellaufrufantworten**
Wenn Sie einen `InvokeModel`-Aufruf mit einem Stable Diffusion 3.5 Large-Modell tätigen, sieht die Antwort wie folgt aus.
```
{
'seeds': [2130420379],
"finish_reasons":[null],
"images":["..."]
}
```
Eine Antwort mit einem abschließenden Grund, der nicht `null` ist, sieht wie folgt aus:
```
{
"finish_reasons":["Filter reason: prompt"]
}
```
+ **seeds** – (Zeichenfolge) Seed-Liste zum Generieren von Bildern für das Modell
+ **finish\$1reasons** – Aufzählung, die angibt, ob die Anforderung gefiltert wurde oder nicht. `null` gibt an, dass die Anforderung erfolgreich war. Aktuelle mögliche Werte: `"Filter reason: prompt", "Filter reason: output image", "Filter reason: input image", "Inference error", null`.
+ **images** – Eine Liste generierter Bilder im base64-Zeichenfolgenformat.
------
#### [ Text to image ]
Das Modell Stability.ai Stable Diffusion 3.5 Large hat die folgenden Inferenzparameter für einen text-to-image Inferenzaufruf.
+ **prompt** (string) — Textbeschreibung des gewünschten Ausgabebildes. Maximal 10.000 Zeichen.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/bedrock/latest/userguide/model-parameters-diffusion-3-5-large.html)
**Optionale Parameter**
+ **aspect\$1ratio** (string) — Steuert das Seitenverhältnis des generierten Bildes. Gilt nur für Anfragen text-to-image. Aufzählung: 16:9, 1:1, 21:9, 2:3, 3:2, 4:5, 5:4, 9:16, 9:21. Standard: 1:1
+ **mode** (string) (GenerationMode) — Standard: text-to-image. Enum: image-to-image oder text-to-image. Steuert, ob es sich um eine text-to-image image-to-image Oder-Generation handelt, was sich darauf auswirkt, welche Parameter erforderlich sind:
+ text-to-image benötigt nur den Prompt-Parameter.
+ image-to-image benötigt die Parameter prompt, image und strength.
+ **seed** (number) — Wert zur Steuerung der Zufälligkeit bei der Generierung. Der Bereich liegt zwischen 0 und 4294967294. Standard 0 (zufälliger Startwert).
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/bedrock/latest/userguide/model-parameters-diffusion-3-5-large.html)
+ **negative\$1prompt** (string) — Text, der Elemente beschreibt, die aus dem Ausgabebild ausgeschlossen werden sollen. Maximal 10.000 Zeichen.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/bedrock/latest/userguide/model-parameters-diffusion-3-5-large.html)
+ **output\$1format** (string) — Ausgabebildformat. Aufzählung: jpeg, png, webp. Standard: png
```
import boto3
import json
bedrock = boto3.client('bedrock-runtime', region_name='us-west-2')
response = bedrock.invoke_model(
modelId='stability.sd3-5-large-v1:0',
body=json.dumps({
'prompt': 'A car made out of vegetables.'
})
)
```
------
#### [ Image to image ]
Das Modell Stability.ai Stable Diffusion 3.5 Large hat die folgenden Inferenzparameter für einen image-to-image Inferenzaufruf.
+ **prompt** (string) — Textbeschreibung des gewünschten Ausgabebildes. Maximal 10.000 Zeichen.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/bedrock/latest/userguide/model-parameters-diffusion-3-5-large.html)
+ **image** (string) — Base64-kodiertes Eingabebild. Mindestens 64 Pixel pro Seite. Unterstützte Formate: JPEG, PNG, WebP.
+ **mode** (string) (GenerationMode) — Standard:. text-to-image Enum: image-to-image oder text-to-image. Steuert, ob es sich um eine text-to-image image-to-image Oder-Generation handelt, was sich darauf auswirkt, welche Parameter erforderlich sind:
+ text-to-image benötigt nur den Prompt-Parameter.
+ image-to-image benötigt die Parameter prompt, image und strength.
+ **Stärke** (Zahl) — Steuert den Einfluss des Eingabebilds auf die Ausgabe. Der Bereich liegt zwischen 0 und 1. Bei einem Wert von 0 wird das Eingabebild beibehalten, bei einem Wert von 1 wird das Eingabebild ignoriert.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/bedrock/latest/userguide/model-parameters-diffusion-3-5-large.html)
+ **seed** (number) — Wert zur Steuerung der Zufälligkeit bei der Generierung. Der Bereich liegt zwischen 0 und 4294967294. Standard 0 (zufälliger Startwert).
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/bedrock/latest/userguide/model-parameters-diffusion-3-5-large.html)
+ **negative\$1prompt** (string) — Text, der Elemente beschreibt, die aus dem Ausgabebild ausgeschlossen werden sollen. Maximal 10.000 Zeichen.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/bedrock/latest/userguide/model-parameters-diffusion-3-5-large.html)
+ **output\$1format** (string) — Ausgabebildformat. Aufzählung: jpeg, png, webp. Standard: png
```
import boto3
import base64
import json
# Load and encode image
with open('input_image.jpg', 'rb') as image_file:
image_base64 = base64.b64encode(image_file.read()).decode('utf-8')
bedrock = boto3.client('bedrock-runtime', region_name='us-west-2')
response = bedrock.invoke_model(
modelId='stability.sd3-5-large-v1:0',
body=json.dumps({
'prompt': 'A car made out of vegetables.',
'image': image_base64,
'strength': 0.7
})
)
```
------
# Anforderung und Antwort von Stable Image Core
Der Anfragetext wird im `body` Feld einer Anfrage an übergeben [InvokeModel](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModel.html).
**Feld für den Hauptteil der Modellaufrufanforderung**
Wenn Sie mit einem Stability AI Stable Diffusion Stable Image Core-Modell einen InvokeModel Anruf tätigen, füllen Sie das Textfeld mit einem JSON-Objekt, das wie das folgende aussieht.
```
{
'prompt': 'Create an image of a panda'
}
```
**Textfeld für Modellaufrufantworten**
Wenn Sie mit einem Stability AI Stable Diffusion Stable Image Core-Modell einen InvokeModel Anruf tätigen, sieht die Antwort wie folgt aus
```
{
'seeds': [2130420379],
'finish_reasons': [null],
'images': ['...']
}
```
+ **seeds** – (Zeichenfolge) Seed-Liste zum Generieren von Bildern für das Modell.
+ **finish\$1reasons** – Aufzählung, die angibt, ob die Anforderung gefiltert wurde oder nicht. `null` gibt an, dass die Anforderung erfolgreich war. Aktuelle mögliche Werte: `"Filter reason: prompt", "Filter reason: output image", "Filter reason: input image", "Inference error", null`.
+ **images** – Eine Liste generierter Bilder im base64-Zeichenfolgenformat.
Weitere Informationen finden Sie unter [https://platform.us.stability. ai/docs/api-reference\$1tag/v1 Generation](https://platform.us.stability.ai/docs/api-reference#tag/v1generation).
------
#### [ Text to image ]
Das Modell Stable Image Core verfügt über die folgenden Inferenzparameter für Text-zu-Bild-Inferenzaufrufe.
**text\$1prompts** (erforderlich): Eine Reihe von Textaufforderungen, die für die Generierung verwendet werden sollen. Jedes Element ist ein JSON-Objekt, das eine Eingabeaufforderung und eine Gewichtung der Eingabeaufforderung enthält.
+ **prompt** – (Zeichenfolge) Was im Ausgabebild angezeigt werden soll. Ein starker, aussagekräftiger Prompt, der Elemente, Farben und Motive klar definiert, führt zu besseren Ergebnissen.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/bedrock/latest/userguide/model-parameters-diffusion-stable-image-core-text-image-request-response.html)
**Optionale Felder**
+ **aspect\$1ratio** – (Zeichenfolge) steuert das Seitenverhältnis des generierten Bildes. Dieser Parameter ist nur für text-to-image Anfragen gültig. Standard: 1:1 Aufzählung: 16:9, 1:1, 21:9, 2:3, 3:2, 4:5, 5:4, 9:16, 9:21.
+ **output\$1format** – Gibt das Format des Ausgabebilds an. Unterstützte Formate: JPEG, PNG. Unterstützte Dimensionen: Höhe 640 bis 1 536 Pixel, Breite 640 bis 1 536 Pixel.
+ **seed** – (Zahl) Ein bestimmter Wert, der als Richtwert für die „Zufälligkeit“ der Generierung dient. (Lassen Sie diesen Parameter weg oder übergeben Sie „0“, um einen zufälligen Seed-Wert zu verwenden.) Der Bereich liegt zwischen 0 und 4294967295.
+ **negative\$1prompt** – Schlüsselwörter für das, was Sie im Ausgabebild nicht sehen möchten. Maximum: 10 000 Zeichen.
```
import boto3
import json
import base64
import io
from PIL import Image
bedrock = boto3.client('bedrock-runtime', region_name='us-west-2')
response = bedrock.invoke_model(
modelId='stability.stable-image-core-v1:0',
body=json.dumps({
'prompt': 'A car made out of vegetables.'
})
)
output_body = json.loads(response["body"].read().decode("utf-8"))
base64_output_image = output_body["images"][0]
image_data = base64.b64decode(base64_output_image)
image = Image.open(io.BytesIO(image_data))
image.save("image.png")
```
------
# Stability AI Image Services
Sie können Stability AI Image Services mit Amazon Bedrock verwenden, um auf dreizehn spezialisierte Bildbearbeitungstools zuzugreifen, die professionelle kreative Workflows beschleunigen sollen. Mit Stability AI Image Services können Sie Bilder aus einer Skizze generieren, ein vorhandenes Bild umstrukturieren und neugestalten oder die in einem Bild enthaltenen Objekte entfernen und ersetzen.
In diesem Abschnitt wird beschrieben, wie Sie mithilfe von Inferenzaufrufen an Stability AI Image Services senden. [InvokeModel](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModel.html) Dieser Abschnitt enthält auch Codebeispiele in Python sowie Beispiele für Bilder vor und nach der Verwendung von Stability AI Image Services.
Stability AI Image Services sind in den folgenden Kategorien verfügbar:
+ **Bearbeiten** – KI-basierte Bildbearbeitungsservices, einschließlich Inpainting mit Masken (generatives Füllen) oder mit Wörtern. Beinhaltet Tools für Produktplatzierung und Werbung sowie grundlegende Tools wie die Entfernung des Hintergrunds.
+ **Steuerung** – Kann Prompts, Karten und andere Anleitungen verwenden. Diese Dienste nutzen ControlNets und ähnliche Technologien, die auf stabilen Diffusionsmodellen basieren.
**Anmerkung**
Wenn Sie den Stability AI Image Service abonnieren, bearbeiten oder kontrollieren, werden Sie automatisch für alle dreizehn verfügbaren Stability AI Image Services registriert.
**Topics**
+ [Anforderung und Antwort](#model-parameters-stable-image-services-request-response)
+ [Gehoben](#stable-image-services-upscale)
+ [Bearbeiten](#stable-image-services-edit)
+ [Steuerung](#stable-image-services-control)
## Anforderung und Antwort
Der Text der Anfrage wird im `body` Feld einer Anfrage an übergeben. [InvokeModel](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModel.html)
**Feld für den Hauptteil der Modellaufrufanforderung**
Wenn Sie mit Stability AI Image Services einen InvokeModel Anruf tätigen, füllen Sie das Textfeld mit einem JSON-Objekt aus, das wie das folgende aussieht.
```
{
'prompt': 'Create an image of a panda'
}
```
**Textfeld für Modellaufrufantworten**
Wenn Sie mit Stability AI Image Services einen InvokeModel Anruf tätigen, sieht die Antwort wie folgt aus
```
{
'seeds': [2130420379],
'finish_reasons': [null],
'images': ['...']
}
```
+ **seeds** – (Zeichenfolge) Seed-Liste zum Generieren von Bildern für das Modell.
+ **finish\$1reasons** – Aufzählung, die angibt, ob die Anforderung gefiltert wurde oder nicht. `null` gibt an, dass die Anforderung erfolgreich war. Aktuelle mögliche Werte: `"Filter reason: prompt", "Filter reason: output image", "Filter reason: input image", "Inference error", null`.
+ **images** – Eine Liste generierter Bilder im base64-Zeichenfolgenformat.
Weitere Informationen finden Sie unter [https://platform.us.stability. ai/docs/api-reference\$1tag/v1 Generation](https://platform.us.stability.ai/docs/api-reference#tag/v1generation).
## Gehoben
Im folgenden Abschnitt werden die hochwertigen Stability AI Image Services beschrieben.
### Kreatives, gehobenes Design
Creative Upscale nimmt Bilder zwischen 64 x 64 und 1 Megapixel auf und skaliert sie auf eine 4K-Auflösung hoch. Mit diesem Service können Bilder um das 20- bis 40-fache hochskaliert werden, wobei die Qualität erhalten bleibt und häufig sogar verbessert wird. Creative Upscale funktioniert am besten bei stark verschlechterten Bildern und eignet sich nicht für Fotos mit 1 Megapixel oder mehr, da es umfangreiche Bildbearbeitungen erfordert.
Creative Upscale hat die folgenden erforderlichen Parameter:
+ **prompt** – Was im Ausgabebild angezeigt werden soll. Ein starker, aussagekräftiger Prompt, der Elemente, Farben und Motive klar definiert, führt zu besseren Ergebnissen. Um die Gewichtung eines bestimmten Wortes zu steuern, verwenden Sie das Format (word:weight), wobei „word“ das Wort darstellt, dessen Gewichtung Sie steuern möchten, und „weight“ ein Wert ist. Bei den Werten „0“ und „1,0“ wurde das Wort weniger betont und bei einem Wert zwischen „1,1“ und „2“ wurde es hervorgehoben. Zum Beispiel: Der Himmel war klar (blue:0.3) und (green:1.8) würde einen Himmel vermitteln, der blau und grün, jedoch eher grün als blau ist. Mindestens 0 und maximal 10 000 Zeichen.
+ **image** ‐ (string) Das Base64-Bild, das hochskaliert werden soll. Jede Seite des Bilds muss mindestens 64 Pixel groß sein. Die Gesamtpixelzahl muss zwischen 4.096 und 1.048.576 Pixeln liegen. Unterstützte Formate: JPEG, PNG, WebP.
Die folgenden Parameter sind optional:
+ **Kreativität** ‐ (Zahl) Gibt an, wie kreativ das Modell beim Hochskalieren eines Bilds sein sollte. Höhere Werte führen dazu, dass dem Bild beim Hochskalieren mehr Details hinzugefügt werden. Bereich zwischen 0,1 und 0,5. Die Standardeinstellung ist 0,3
+ **negative\$1prompt** – (Zeichenfolge) Ein kurzer Text, der beschreibt, was im Ausgabebild nicht angezeigt werden soll. Dies ist ein erweitertes Feature. Maximal 10000 Zeichen.
+ **seed** – (Zahl) Ein bestimmter Wert, der als Richtwert für die „Zufälligkeit“ der Generierung dient. (Lassen Sie diesen Parameter weg oder übergeben Sie „0“, um einen zufälligen Seed-Wert zu verwenden.) Der Bereich liegt zwischen 0 und 4294967294. Standard: 0
+ **output\$1format** – (Zeichenfolge) Gibt den Inhaltstyp des generierten Bilds vor. Aufzählung: jpeg, png, webp. Standard: png
+ **style\$1preset** – Richtet das Bildmodell auf einen bestimmten Stil aus. Aufzählung: 3d-model, analog-film, anime, cinematic, comic-book, digital-art, enhance, fantasy-art, isometric, line-art, low-poly, modeling-compound, neon-punk, origami, photographic, pixel-art, tile-texture.
------
#### [ API ]
```
import base64
import json
import requests
import io
import os
from PIL import Image
image = "./content/input.jpg"
region = "us-east-1"
model_id = "us.stability.stable-creative-upscale-v1:0"
url = f"https://bedrock-runtime.{region}.amazonaws.com/model/{model_id}/invoke"
api_key = os.getenv("AWS_BEARER_TOKEN_BEDROCK") # https://docs.aws.amazon.com/bedrock/latest/userguide/getting-started-api-keys.html
headers = {
"Content-Type":"application/json",
"Authorization":f"Bearer {api_key}"
}
try:
with open(image, "rb") as image_file:
image_base64 = base64.b64encode(image_file.read()).decode('utf-8')
params = {
"image": image_base64,
"prompt": "This dreamlike digital art captures a vibrant, kaleidoscopic Big Ben in London",
"creativity": 0.30
}
response = requests.request("POST", url, json=params, headers=headers)
response.raise_for_status()
model_response = json.loads(response.text)
base64_image_data = model_response["images"][0]
if not base64_image_data:
raise ValueError("No image data found in model response.")
image_data = base64.b64decode(base64_image_data)
image = Image.open(io.BytesIO(image_data))
image.save("image.png")
print("Successfully saved image.")
except Exception as e:
print(e)
```
------
#### [ Python ]
```
import boto3
import base64
import io
import json
from PIL import Image
image = "./content/input.jpg"
region = "us-east-1"
model_id = "us.stability.stable-creative-upscale-v1:0"
bedrock = boto3.client("bedrock-runtime", region_name=region)
try:
with open(image, "rb") as image_file:
image_base64 = base64.b64encode(image_file.read()).decode('utf-8')
params = {
"image": image_base64,
"prompt": "This dreamlike digital art captures a vibrant, kaleidoscopic Big Ben in London",
"creativity": 0.30
}
request = json.dumps(params)
response = bedrock.invoke_model(modelId=model_id, body=request)
model_response = json.loads(response["body"].read())
base64_image_data = model_response["images"][0]
if not base64_image_data:
raise ValueError("No image data found in model response.")
image_data = base64.b64decode(base64_image_data)
image = Image.open(io.BytesIO(image_data))
image.save("image.png")
print("Successfully saved image.")
except Exception as e:
print(e)
```
------
Die folgende Tabelle zeigt die Eingabe- und Ausgabebilder eines Creative Upscale-Vorgangs mit der folgenden Eingabeaufforderung: *Diese traumhafte digitale Kunst zeigt einen lebendigen, kaleidoskopischen Vogel in einem* üppigen Regenwald.
| Input | Ausgabe |
| --- | --- |
| ![\[alt text not found\]](http://docs.aws.amazon.com/de_de/bedrock/latest/userguide/images/stable-image-services/input-creative-upscale.jpg) | ![\[alt text not found\]](http://docs.aws.amazon.com/de_de/bedrock/latest/userguide/images/stable-image-services/output-creative-upscale.jpg) |
### Konservativ, gehoben
Conservative Upscale nimmt Bilder zwischen 64 x 64 und 1 Megapixel auf und skaliert sie auf eine 4K-Auflösung hoch. Dieser Service kann Bilder um das 20- bis 40-fache hochskalieren und dabei alle Aspekte beibehalten. Conservative Upscale minimiert Änderungen am Bild und sollte nicht verwendet werden, um ein Bild neu zu erfinden.
Conservative Upscale hat die folgenden erforderlichen Parameter:
+ **prompt** – Was im Ausgabebild angezeigt werden soll. Ein starker, aussagekräftiger Prompt, der Elemente, Farben und Motive klar definiert, führt zu besseren Ergebnissen. Um die Gewichtung eines bestimmten Wortes zu steuern, verwenden Sie das Format (word:weight), wobei „word“ das Wort darstellt, dessen Gewichtung Sie steuern möchten, und „weight“ ein Wert ist. Bei den Werten „0“ und „1,0“ wurde das Wort weniger betont und bei einem Wert zwischen „1,1“ und „2“ wurde es hervorgehoben. Zum Beispiel: Der Himmel war klar (blue:0.3) und (green:1.8) würde einen Himmel vermitteln, der blau und grün, jedoch eher grün als blau ist. Mindestens 0 und maximal 10 000 Zeichen.
+ **image** ‐ (string) Das Base64-Bild, das hochskaliert werden soll. Jede Seite des Bilds muss mindestens 64 Pixel groß sein. Die Gesamtpixelzahl darf 9 437 184 Pixel nicht überschreiten. Das Seitenverhältnis des Bilds muss zwischen 1:2,5 und 2,5:1 liegen. Unterstützte Formate: JPEG, PNG, WebP.
Die folgenden Parameter sind optional:
+ **Kreativität** ‐ (Zahl) Gibt an, wie kreativ das Modell sein sollte, wenn es ein Bild hochskaliert. Höhere Werte führen dazu, dass dem Bild beim Hochskalieren mehr Details hinzugefügt werden. Bereich zwischen 0,1 und 0,5. Die Standardeinstellung ist 0,35
+ **negative\$1prompt** – (Zeichenfolge) Ein kurzer Text, der beschreibt, was im Ausgabebild nicht angezeigt werden soll. Dies ist ein erweitertes Feature. Maximal 10000 Zeichen.
+ **seed** – (Zahl) Ein bestimmter Wert, der als Richtwert für die „Zufälligkeit“ der Generierung dient. (Lassen Sie diesen Parameter weg oder übergeben Sie „0“, um einen zufälligen Seed-Wert zu verwenden.) Der Bereich liegt zwischen 0 und 4294967294. Standard: 0
+ **output\$1format** – (Zeichenfolge) Gibt den Inhaltstyp des generierten Bilds vor. Aufzählung: jpeg, png, webp. Standard: png
------
#### [ API ]
```
import base64
import json
import requests
import io
import os
from PIL import Image
image = "./content/input.jpg"
region = "us-east-1"
model_id = "us.stability.stable-conservative-upscale-v1:0"
url = f"https://bedrock-runtime.{region}.amazonaws.com/model/{model_id}/invoke"
api_key = os.getenv("AWS_BEARER_TOKEN_BEDROCK") # https://docs.aws.amazon.com/bedrock/latest/userguide/getting-started-api-keys.html
headers = {
"Content-Type":"application/json",
"Authorization":f"Bearer {api_key}"
}
try:
with open(image, "rb") as image_file:
image_base64 = base64.b64encode(image_file.read()).decode('utf-8')
params = {
"image": image_base64,
"prompt": "This dreamlike digital art captures a vibrant, kaleidoscopic Big Ben in London",
"creativity": 0.30
}
response = requests.request("POST", url, json=params, headers=headers)
response.raise_for_status()
model_response = json.loads(response.text)
base64_image_data = model_response["images"][0]
if not base64_image_data:
raise ValueError("No image data found in model response.")
image_data = base64.b64decode(base64_image_data)
image = Image.open(io.BytesIO(image_data))
image.save("image.png")
print("Successfully saved image.")
except Exception as e:
print(e)
```
------
#### [ Python ]
```
import boto3
import base64
import io
import json
from PIL import Image
image = "./content/input.jpg"
region = "us-east-1"
model_id = "us.stability.stable-conservative-upscale-v1:0"
bedrock = boto3.client("bedrock-runtime", region_name=region)
try:
with open(image, "rb") as image_file:
image_base64 = base64.b64encode(image_file.read()).decode('utf-8')
params = {
"image": image_base64,
"prompt": "This dreamlike digital art captures a vibrant, kaleidoscopic Big Ben in London",
"creativity": 0.30
}
request = json.dumps(params)
response = bedrock.invoke_model(modelId=model_id, body=request)
model_response = json.loads(response["body"].read())
base64_image_data = model_response["images"][0]
if not base64_image_data:
raise ValueError("No image data found in model response.")
image_data = base64.b64decode(base64_image_data)
image = Image.open(io.BytesIO(image_data))
image.save("image.png")
print("Successfully saved image.")
except Exception as e:
print(e)
```
------
Die folgende Tabelle zeigt die Eingabe- und Ausgabebilder einer Operation im Bereich Conservative Upscale unter Verwendung der folgenden Eingabeaufforderung: *Foto eines riesigen Huhns in einem Wald*.
| Input | Ausgabe |
| --- | --- |
| ![\[alt text not found\]](http://docs.aws.amazon.com/de_de/bedrock/latest/userguide/images/stable-image-services/input-conservative-upscale.jpg) | ![\[alt text not found\]](http://docs.aws.amazon.com/de_de/bedrock/latest/userguide/images/stable-image-services/output-conservative-upscale.jpg) |
### Schnelles Hochskalieren
Fast Upscale verbessert die Bildauflösung mithilfe prädiktiver und generativer KI um das Vierfache. Dieser einfache und schnelle Dienst eignet sich ideal zur Verbesserung der Qualität komprimierter Bilder und eignet sich daher für Beiträge in sozialen Medien und andere Anwendungen.
Für Fast Upscale sind die folgenden Parameter erforderlich:
+ **image** ‐ (string) Das Base64-Bild, das hochskaliert werden soll. Die Breite muss zwischen 32 und 1.536 Pixeln liegen. Die Höhe muss zwischen 32 und 1.536 Pixeln liegen. Die Gesamtpixelzahl muss zwischen 1.024 und 1.048.576 Pixeln liegen. Unterstützte Formate: JPEG, PNG, WebP.
+ **output\$1format** – (Zeichenfolge) Gibt den Inhaltstyp des generierten Bilds vor. Aufzählung: jpeg, png, webp. Standard: png
------
#### [ API ]
```
import base64
import json
import requests
import io
import os
from PIL import Image
image = "./content/input.jpg"
region = "us-east-1"
model_id = "us.stability.stable-fast-upscale-v1:0"
url = f"https://bedrock-runtime.{region}.amazonaws.com/model/{model_id}/invoke"
api_key = os.getenv("AWS_BEARER_TOKEN_BEDROCK") # https://docs.aws.amazon.com/bedrock/latest/userguide/getting-started-api-keys.html
headers = {
"Content-Type":"application/json",
"Authorization":f"Bearer {api_key}"
}
try:
with open(image, "rb") as image_file:
image_base64 = base64.b64encode(image_file.read()).decode('utf-8')
params = {
"image": image_base64
}
response = requests.request("POST", url, json=params, headers=headers)
response.raise_for_status()
model_response = json.loads(response.text)
base64_image_data = model_response["images"][0]
if not base64_image_data:
raise ValueError("No image data found in model response.")
image_data = base64.b64decode(base64_image_data)
image = Image.open(io.BytesIO(image_data))
image.save("image.png")
print("Successfully saved image.")
except Exception as e:
print(e)
```
------
#### [ Python ]
```
import boto3
import base64
import io
import json
from PIL import Image
image = "./content/input.jpg"
region = "us-east-1"
model_id = "us.stability.stable-fast-upscale-v1:0"
bedrock = boto3.client("bedrock-runtime", region_name=region)
try:
with open(image, "rb") as image_file:
image_base64 = base64.b64encode(image_file.read()).decode('utf-8')
params = {
"image": image_base64
}
request = json.dumps(params)
response = bedrock.invoke_model(modelId=model_id, body=request)
model_response = json.loads(response["body"].read())
base64_image_data = model_response["images"][0]
if not base64_image_data:
raise ValueError("No image data found in model response.")
image_data = base64.b64decode(base64_image_data)
image = Image.open(io.BytesIO(image_data))
image.save("image.png")
print("Successfully saved image.")
except Exception as e:
print(e)
```
------
Die folgende Tabelle zeigt die Eingabe- und Ausgabebilder eines Fast-Upscale-Vorgangs.
| Input | Ausgabe |
| --- | --- |
| ![\[alt text not found\]](http://docs.aws.amazon.com/de_de/bedrock/latest/userguide/images/stable-image-services/input-fast-upscale.jpg) | ![\[alt text not found\]](http://docs.aws.amazon.com/de_de/bedrock/latest/userguide/images/stable-image-services/output-fast-upscale.jpg) |
## Bearbeiten
Im folgenden Abschnitt wird die Bearbeitung von Stability AI Image Services beschrieben.
### Inpaint
Mit Inpaint werden Bilder auf intelligente Weise geändert, indem bestimmte Bereiche ausgefüllt oder durch neuen Inhalt ersetzt werden, der auf dem Inhalt eines Maskenbilds basiert.
Inpaint verfügt über die folgenden erforderlichen Parameter:
+ **prompt** – Was im Ausgabebild angezeigt werden soll. Ein starker, aussagekräftiger Prompt, der Elemente, Farben und Motive klar definiert, führt zu besseren Ergebnissen. Um die Gewichtung eines bestimmten Wortes zu steuern, verwenden Sie das Format (word:weight), wobei „word“ das Wort darstellt, dessen Gewichtung Sie steuern möchten, und „weight“ ein Wert ist. Bei den Werten „0“ und „1,0“ wurde das Wort weniger betont und bei einem Wert zwischen „1,1“ und „2“ wurde es hervorgehoben. Zum Beispiel: Der Himmel war klar (blue:0.3) und (green:1.8) würde einen Himmel vermitteln, der blau und grün, jedoch eher grün als blau ist. Mindestens 0 und maximal 10 000 Zeichen.
+ **image** – (Zeichenfolge) Das Base64-Bild, für das Inpainting durchgeführt werden soll. Jede Seite des Bilds muss mindestens 64 Pixel groß sein. Die Gesamtpixelzahl darf 9 437 184 Pixel nicht überschreiten. Das Seitenverhältnis des Bilds muss zwischen 1:2,5 und 2,5:1 liegen. Unterstützte Formate: JPEG, PNG, WebP.
Die folgenden Parameter sind optional:
+ **style\$1preset** – (Zeichenfolge) Richtet das Bildmodell auf einen bestimmten Stil aus. Aufzählung: 3d-model, analog-film, anime, cinematic, comic-book, digital-art, enhance, fantasy-art, isometric, line-art, low-poly, modeling-compound, neon-punk, origami, photographic, pixel-art, tile-texture.
+ **negative\$1prompt** – (Zeichenfolge) Ein kurzer Text, der beschreibt, was im Ausgabebild nicht angezeigt werden soll. Dies ist ein erweitertes Feature. Maximal 10000 Zeichen.
+ **seed** – (Zahl) Ein bestimmter Wert, der als Richtwert für die „Zufälligkeit“ der Generierung dient. (Lassen Sie diesen Parameter weg oder übergeben Sie „0“, um einen zufälligen Seed-Wert zu verwenden.) Der Bereich liegt zwischen 0 und 4294967294. Standard: 0
+ **output\$1format** – (Zeichenfolge) Gibt den Inhaltstyp des generierten Bilds vor. Aufzählung: jpeg, png, webp. Standard: png
+ **mask** – (Zeichenfolge) Steuert die Stärke des Inpainting-Prozesses pro Pixel, entweder über ein zweites Bild (das an diesen Parameter übergeben wird) oder über den Alphakanal des Bildparameters.
+ **Maske übergeben** – Das an diesen Parameter übergebene Bild sollte ein Schwarzweißbild sein, das an jedem Pixel die Inpainting-Stärke darstellt, basierend darauf, wie dunkel oder hell das jeweilige Pixel ist. Vollständig schwarze Pixel stellen keine Inpainting-Stärke dar, vollständig weiße Pixel stehen hingegeben für maximale Stärke. Falls die Maske eine andere Größe als der Bildparameter aufweist, wird ihre Größe automatisch angepasst.
+ **Alphakanal-Unterstützung** – Wenn Sie keine explizite Maske angeben, wird eine aus dem Alphakanal des Bildparameters abgeleitet. Für transparente Pixel erfolgt ein Inpainting, undurchsichtige Pixel hingegeben werden beibehalten. Falls ein Bild mit einem Alphakanal zusammen mit einer Maske bereitgestellt wird, hat die Maske Vorrang.
+ **grow\$1mask** – Vergrößert die Kanten der Maske nach außen in alle Richtungen um die angegebene Anzahl von Pixeln. Der erweiterte Bereich um die Maske herum wird unscharf, was dazu beitragen kann, den Übergang zwischen Inhalt, für den ein Inpainting durchgeführt wurde, und dem Originalbild zu glätten. Der Bereich liegt zwischen 0 und 20. Standard: 5 Probieren Sie diesen Parameter aus, wenn Sie am Inhalt, für den kein Inpainting durchgeführt wurde, Übergänge oder raue Kanten bemerken. Beachten Sie, dass durch übermäßiges Wachstum feine Details in der and/or Maskenverschmelzung in der Nähe maskierter Bereiche verdeckt werden können.
------
#### [ API ]
```
import base64
import json
import requests
import io
import os
from PIL import Image
image = "./content/input.png"
mask = "./content/mask.png"
region = "us-east-1"
model_id = "us.stability.stable-image-inpaint-v1:0"
url = f"https://bedrock-runtime.{region}.amazonaws.com/model/{model_id}/invoke"
api_key = os.getenv("AWS_BEARER_TOKEN_BEDROCK") # https://docs.aws.amazon.com/bedrock/latest/userguide/getting-started-api-keys.html
headers = {
"Content-Type":"application/json",
"Authorization":f"Bearer {api_key}"
}
try:
with open(image, "rb") as image_file:
image_base64 = base64.b64encode(image_file.read()).decode('utf-8')
with open(mask, "rb") as mask_file:
mask_base64 = base64.b64encode(mask_file.read()).decode('utf-8')
params = {
"image": image_base64,
"mask": mask_base64,
"prompt": "artificer of time and space"
}
response = requests.request("POST", url, json=params, headers=headers)
response.raise_for_status()
model_response = json.loads(response.text)
base64_image_data = model_response["images"][0]
if not base64_image_data:
raise ValueError("No image data found in model response.")
image_data = base64.b64decode(base64_image_data)
image = Image.open(io.BytesIO(image_data))
image.save("image.png")
print("Successfully saved image.")
except Exception as e:
print(e)
```
------
#### [ Python ]
```
import boto3
import base64
import io
import json
from PIL import Image
image = "./content/input.png"
mask = "./content/mask.png"
region = "us-east-1"
model_id = "us.stability.stable-image-inpaint-v1:0"
bedrock = boto3.client("bedrock-runtime", region_name=region)
try:
with open(image, "rb") as image_file:
image_base64 = base64.b64encode(image_file.read()).decode('utf-8')
with open(mask, "rb") as mask_file:
mask_base64 = base64.b64encode(mask_file.read()).decode('utf-8')
params = {
"image": image_base64,
"mask": mask_base64,
"prompt": "artificer of time and space"
}
request = json.dumps(params)
response = bedrock.invoke_model(modelId=model_id, body=request)
model_response = json.loads(response["body"].read())
base64_image_data = model_response["images"][0]
if not base64_image_data:
raise ValueError("No image data found in model response.")
image_data = base64.b64decode(base64_image_data)
image = Image.open(io.BytesIO(image_data))
image.save("image.png")
print("Successfully saved image.")
except Exception as e:
print(e)
```
------
In der folgenden Tabelle sind die Eingabe- und Ausgabebilder eines Inpaint-Vorgangs aufgeführt.
| Input | Maske | Ausgabe |
| --- | --- | --- |
| ![\[alt text not found\]](http://docs.aws.amazon.com/de_de/bedrock/latest/userguide/images/stable-image-services/input-image-inpaint.jpg) | ![\[alt text not found\]](http://docs.aws.amazon.com/de_de/bedrock/latest/userguide/images/stable-image-services/mask-image-inpaint.png) | ![\[alt text not found\]](http://docs.aws.amazon.com/de_de/bedrock/latest/userguide/images/stable-image-services/output-image-inpaint.jpg) |
### Übermalen
Outpaint fügt zusätzlichen Inhalt in ein Bild ein, um den Raum in beliebiger Richtung auszufüllen. Im Vergleich zu anderen automatisierten oder manuellen Versuchen, den Inhalt in einem Bild zu erweitern, minimiert der Outpaint-Dienst Hinweise darauf, dass das Originalbild bearbeitet wurde.
Outpaint hat die folgenden erforderlichen Parameter:
+ **image** ‐ (Zeichenfolge) Das Base64-Bild, das übermalt werden soll. Jede Seite des Bilds muss mindestens 64 Pixel groß sein. Die Gesamtpixelzahl darf 9 437 184 Pixel nicht überschreiten. Das Seitenverhältnis des Bilds muss zwischen 1:2,5 und 2,5:1 liegen. Unterstützte Formate: JPEG, PNG, WebP.
**Anmerkung**
Für mindestens eine Ausmalrichtung (links, rechts, oben oder unten) muss ein Wert ungleich Null angegeben werden. Um optimale Ergebnisse zu erzielen, sollten Sie bei der Auswahl der Ausmalrichtungen die Zusammensetzung und den Inhalt Ihres Originalbilds berücksichtigen.
Die folgenden Parameter sind optional:
+ **prompt** – Was im Ausgabebild angezeigt werden soll. Ein starker, aussagekräftiger Prompt, der Elemente, Farben und Motive klar definiert, führt zu besseren Ergebnissen. Um die Gewichtung eines bestimmten Wortes zu steuern, verwenden Sie das Format (word:weight), wobei „word“ das Wort darstellt, dessen Gewichtung Sie steuern möchten, und „weight“ ein Wert ist. Bei den Werten „0“ und „1,0“ wurde das Wort weniger betont und bei einem Wert zwischen „1,1“ und „2“ wurde es hervorgehoben. Zum Beispiel: Der Himmel war klar (blue:0.3) und (green:1.8) würde einen Himmel vermitteln, der blau und grün, jedoch eher grün als blau ist. Mindestens 0 und maximal 10 000 Zeichen.
+ **style\$1preset** – (Zeichenfolge) Richtet das Bildmodell auf einen bestimmten Stil aus. Aufzählung: 3d-model, analog-film, anime, cinematic, comic-book, digital-art, enhance, fantasy-art, isometric, line-art, low-poly, modeling-compound, neon-punk, origami, photographic, pixel-art, tile-texture.
+ **seed** – (Zahl) Ein bestimmter Wert, der als Richtwert für die „Zufälligkeit“ der Generierung dient. (Lassen Sie diesen Parameter weg oder übergeben Sie „0“, um einen zufälligen Seed-Wert zu verwenden.) Der Bereich liegt zwischen 0 und 4294967294. Standard: 0
+ **output\$1format** – (Zeichenfolge) Gibt den Inhaltstyp des generierten Bilds vor. Aufzählung: jpeg, png, webp. Standard: png
+ **Kreativität** ‐ (Zahl) Gibt an, wie kreativ das Modell sein sollte, wenn es ein Bild übermalt. Höhere Werte führen dazu, dass dem Bild beim Übermalen mehr kreativer Inhalt hinzugefügt wird. Bereich zwischen 0,1 und 1,0. Standard: 0,5
+ **left** ‐ (Ganzzahl) Die Anzahl der Pixel, die auf der linken Seite des Bilds übermalt werden sollen. Für mindestens eine Übermalrichtung muss ein Wert ungleich Null angegeben werden. Bereich 0 bis 2000. Der Standardwert ist 0.
+ **right** ‐ (Ganzzahl) Die Anzahl der Pixel, die auf der rechten Seite des Bildes übermalt werden sollen. Für mindestens eine Übermalrichtung muss ein Wert ungleich Null angegeben werden. Bereich 0 bis 2000. Der Standardwert ist 0.
+ **up** ‐ (Ganzzahl) Die Anzahl der Pixel, die oben im Bild übermalt werden sollen. Für mindestens eine Übermalrichtung muss ein Wert ungleich Null angegeben werden. Bereich 0 bis 2000. Der Standardwert ist 0.
+ **down** ‐ (Ganzzahl) Die Anzahl der Pixel, die am unteren Bildrand übermalt werden sollen. Für mindestens eine Ausmalrichtung muss ein Wert ungleich Null angegeben werden. Bereich 0 bis 2000. Der Standardwert ist 0.
------
#### [ API ]
```
import base64
import json
import requests
import io
import os
from PIL import Image
image = "./content/input.jpg"
region = "us-east-1"
model_id = "us.stability.stable-outpaint-v1:0"
url = f"https://bedrock-runtime.{region}.amazonaws.com/model/{model_id}/invoke"
api_key = os.getenv("AWS_BEARER_TOKEN_BEDROCK") # https://docs.aws.amazon.com/bedrock/latest/userguide/getting-started-api-keys.html
headers = {
"Content-Type":"application/json",
"Authorization":f"Bearer {api_key}"
}
try:
with open(image, "rb") as image_file:
image_base64 = base64.b64encode(image_file.read()).decode('utf-8')
params = {
"image": image_base64,
"left": 512,
"right": 512,
"up": 200,
"down": 100
}
response = requests.request("POST", url, json=params, headers=headers)
response.raise_for_status()
model_response = json.loads(response.text)
base64_image_data = model_response["images"][0]
if not base64_image_data:
raise ValueError("No image data found in model response.")
image_data = base64.b64decode(base64_image_data)
image = Image.open(io.BytesIO(image_data))
image.save("image.png")
print("Successfully saved image.")
except Exception as e:
print(e)
```
------
#### [ Python ]
```
import boto3
import base64
import io
import json
from PIL import Image
image = "./content/input.png"
region = "us-east-1"
model_id = "us.stability.stable-outpaint-v1:0"
bedrock = boto3.client("bedrock-runtime", region_name=region)
try:
with open(image, "rb") as image_file:
image_base64 = base64.b64encode(image_file.read()).decode('utf-8')
params = {
"image": image_base64,
"left": 512,
"right": 512,
"up": 200,
"down": 100
}
request = json.dumps(params)
response = bedrock.invoke_model(modelId=model_id, body=request)
model_response = json.loads(response["body"].read())
base64_image_data = model_response["images"][0]
if not base64_image_data:
raise ValueError("No image data found in model response.")
image_data = base64.b64decode(base64_image_data)
image = Image.open(io.BytesIO(image_data))
image.save("image.png")
print("Successfully saved image.")
except Exception as e:
print(e)
```
------
Die folgende Tabelle zeigt die Eingabe- und Ausgabebilder einer Outpaint-Operation.
| Input | Ausgabe |
| --- | --- |
| ![\[alt text not found\]](http://docs.aws.amazon.com/de_de/bedrock/latest/userguide/images/stable-image-services/input-image-outpaint.jpg) | ![\[alt text not found\]](http://docs.aws.amazon.com/de_de/bedrock/latest/userguide/images/stable-image-services/output-image-outpaint.jpg) |
### Suchen und umfärben
Mit „Suchen und umfärben“ können Sie die Farbe eines bestimmten Objekts in einem Bild mithilfe eines Prompts ändern. Bei diesem Service handelt es sich um eine spezielle Version von Inpainting, für die keine Maske erforderlich ist. Er segmentiert das Objekt automatisch und färbt es mit den im Prompt angeforderten Farben um.
„Suchen und umfärben“ verfügt über die folgenden erforderlichen Parameter:
+ **prompt** – Was im Ausgabebild angezeigt werden soll. Ein starker, aussagekräftiger Prompt, der Elemente, Farben und Motive klar definiert, führt zu besseren Ergebnissen. Um die Gewichtung eines bestimmten Wortes zu steuern, verwenden Sie das Format (word:weight), wobei „word“ das Wort darstellt, dessen Gewichtung Sie steuern möchten, und „weight“ ein Wert ist. Bei den Werten „0“ und „1,0“ wurde das Wort weniger betont und bei einem Wert zwischen „1,1“ und „2“ wurde es hervorgehoben. Zum Beispiel: Der Himmel war klar (blue:0.3) und (green:1.8) würde einen Himmel vermitteln, der blau und grün, jedoch eher grün als blau ist. Mindestens 0 und maximal 10 000 Zeichen.
+ **image** – (Zeichenfolge) Das Base64-Bild, das umgefärbt werden soll. Jede Seite des Bilds muss mindestens 64 Pixel groß sein. Die Gesamtpixelzahl darf 9 437 184 Pixel nicht überschreiten. Das Seitenverhältnis des Bilds muss zwischen 1:2,5 und 2,5:1 liegen. Unterstützte Formate: JPEG, PNG, WebP.
+ **select\$1prompt** – (Zeichenfolge) Eine kurze Beschreibung dessen, wonach im Bild gesucht werden soll. Maximal 10000 Zeichen.
Die folgenden Parameter sind optional:
+ **style\$1preset** – (Zeichenfolge) Richtet das Bildmodell auf einen bestimmten Stil aus. Aufzählung: 3d-model, analog-film, anime, cinematic, comic-book, digital-art, enhance, fantasy-art, isometric, line-art, low-poly, modeling-compound, neon-punk, origami, photographic, pixel-art, tile-texture.
+ **negative\$1prompt** – (Zeichenfolge) Ein kurzer Text, der beschreibt, was im Ausgabebild nicht angezeigt werden soll. Dies ist ein erweitertes Feature. Maximal 10000 Zeichen.
+ **seed** – (Zahl) Ein bestimmter Wert, der als Richtwert für die „Zufälligkeit“ der Generierung dient. (Lassen Sie diesen Parameter weg oder übergeben Sie „0“, um einen zufälligen Seed-Wert zu verwenden.) Der Bereich liegt zwischen 0 und 4294967294. Standard: 0
+ **output\$1format** – (Zeichenfolge) Gibt den Inhaltstyp des generierten Bilds vor. Aufzählung: jpeg, png, webp. Standard: png
+ **grow\$1mask** – Vergrößert die Kanten der Maske nach außen in alle Richtungen um die angegebene Anzahl von Pixeln. Der erweiterte Bereich um die Maske herum wird unscharf, was dazu beitragen kann, den Übergang zwischen Inhalt, für den ein Inpainting durchgeführt wurde, und dem Originalbild zu glätten. Der Bereich liegt zwischen 0 und 20. Standard: 5 Probieren Sie diesen Parameter aus, wenn Sie am Inhalt, für den kein Inpainting durchgeführt wurde, Übergänge oder raue Kanten bemerken. Beachten Sie, dass durch übermäßiges Wachstum feine Details in der and/or Maskenverschmelzung in der Nähe maskierter Bereiche verdeckt werden können.
------
#### [ API ]
```
import base64
import json
import requests
import io
import os
from PIL import Image
image = "./content/input.png"
region = "us-east-1"
model_id = "us.stability.stable-image-search-recolor-v1:0"
url = f"https://bedrock-runtime.{region}.amazonaws.com/model/{model_id}/invoke"
api_key = os.getenv("AWS_BEARER_TOKEN_BEDROCK") # https://docs.aws.amazon.com/bedrock/latest/userguide/getting-started-api-keys.html
headers = {
"Content-Type":"application/json",
"Authorization":f"Bearer {api_key}"
}
try:
with open(image, "rb") as image_file:
image_base64 = base64.b64encode(image_file.read()).decode('utf-8')
params = {
"image": image_base64,
"prompt": "pink jacket",
"select_prompt": "jacket"
}
response = requests.request("POST", url, json=params, headers=headers)
response.raise_for_status()
model_response = json.loads(response.text)
base64_image_data = model_response["images"][0]
if not base64_image_data:
raise ValueError("No image data found in model response.")
image_data = base64.b64decode(base64_image_data)
image = Image.open(io.BytesIO(image_data))
image.save("image.png")
print("Successfully saved image.")
except Exception as e:
print(e)
```
------
#### [ Python ]
```
import boto3
import base64
import io
import json
from PIL import Image
image = "./content/input.png"
region = "us-east-1"
model_id = "us.stability.stable-image-search-recolor-v1:0"
bedrock = boto3.client("bedrock-runtime", region_name=region)
try:
with open(image, "rb") as image_file:
image_base64 = base64.b64encode(image_file.read()).decode('utf-8')
params = {
"image": image_base64,
"prompt": "pink jacket",
"select_prompt": "jacket"
}
request = json.dumps(params)
response = bedrock.invoke_model(modelId=model_id, body=request)
model_response = json.loads(response["body"].read())
base64_image_data = model_response["images"][0]
if not base64_image_data:
raise ValueError("No image data found in model response.")
image_data = base64.b64decode(base64_image_data)
image = Image.open(io.BytesIO(image_data))
image.save("image.png")
print("Successfully saved image.")
except Exception as e:
print(e)
```
------
*Die folgende Tabelle zeigt die Eingabe- und Ausgabebilder eines „Suchen und umfärben“-Vorgangs mit dem folgenden Prompt: pink jacket*.
| Input | Ausgabe |
| --- | --- |
| ![\[alt text not found\]](http://docs.aws.amazon.com/de_de/bedrock/latest/userguide/images/stable-image-services/input-search-recolor.jpg) | ![\[alt text not found\]](http://docs.aws.amazon.com/de_de/bedrock/latest/userguide/images/stable-image-services/output-search-recolor.jpg) |
### Suchen und ersetzen
„Suchen und ersetzen“ ermöglicht es Ihnen, mithilfe eines Such-Prompts ein Objekt in einfacher Sprache zu identifizieren, das ersetzt werden soll. Der Service segmentiert das Objekt automatisch und ersetzt es durch das im Prompt angeforderte Objekt, ohne dass eine Maske erforderlich ist.
„Suchen und ersetzen“ verfügt über die folgenden erforderlichen Parameter:
+ **prompt** – Was im Ausgabebild angezeigt werden soll. Ein starker, aussagekräftiger Prompt, der Elemente, Farben und Motive klar definiert, führt zu besseren Ergebnissen. Um die Gewichtung eines bestimmten Wortes zu steuern, verwenden Sie das Format (word:weight), wobei „word“ das Wort darstellt, dessen Gewichtung Sie steuern möchten, und „weight“ ein Wert ist. Bei den Werten „0“ und „1,0“ wurde das Wort weniger betont und bei einem Wert zwischen „1,1“ und „2“ wurde es hervorgehoben. Zum Beispiel: Der Himmel war klar (blue:0.3) und (green:1.8) würde einen Himmel vermitteln, der blau und grün, jedoch eher grün als blau ist. Mindestens 0 und maximal 10 000 Zeichen.
+ **image** – (Zeichenfolge) Das Base64-Bild, das umgefärbt werden soll. Jede Seite des Bilds muss mindestens 64 Pixel groß sein. Die Gesamtpixelzahl darf 9 437 184 Pixel nicht überschreiten. Das Seitenverhältnis des Bilds muss zwischen 1:2,5 und 2,5:1 liegen. Unterstützte Formate: JPEG, PNG, WebP.
+ **select\$1prompt** – (Zeichenfolge) Eine kurze Beschreibung dessen, wonach im Bild gesucht werden soll. Maximal 10000 Zeichen.
Die folgenden Parameter sind optional:
+ **style\$1preset** – (Zeichenfolge) Richtet das Bildmodell auf einen bestimmten Stil aus. Aufzählung: 3d-model, analog-film, anime, cinematic, comic-book, digital-art, enhance, fantasy-art, isometric, line-art, low-poly, modeling-compound, neon-punk, origami, photographic, pixel-art, tile-texture.
+ **negative\$1prompt** – (Zeichenfolge) Ein kurzer Text, der beschreibt, was im Ausgabebild nicht angezeigt werden soll. Dies ist ein erweitertes Feature. Maximal 10000 Zeichen.
+ **seed** – (Zahl) Ein bestimmter Wert, der als Richtwert für die „Zufälligkeit“ der Generierung dient. (Lassen Sie diesen Parameter weg oder übergeben Sie „0“, um einen zufälligen Seed-Wert zu verwenden.) Der Bereich liegt zwischen 0 und 4294967294. Standard: 0
+ **output\$1format** – (Zeichenfolge) Gibt den Inhaltstyp des generierten Bilds vor. Aufzählung: jpeg, png, webp. Standard: png
+ **grow\$1mask** – Vergrößert die Kanten der Maske nach außen in alle Richtungen um die angegebene Anzahl von Pixeln. Der erweiterte Bereich um die Maske herum wird unscharf, was dazu beitragen kann, den Übergang zwischen Inhalt, für den ein Inpainting durchgeführt wurde, und dem Originalbild zu glätten. Der Bereich liegt zwischen 0 und 20. Standard: 5 Probieren Sie diesen Parameter aus, wenn Sie am Inhalt, für den kein Inpainting durchgeführt wurde, Übergänge oder raue Kanten bemerken. Beachten Sie, dass durch übermäßiges Wachstum feine Details in der and/or Maskenverschmelzung in der Nähe maskierter Bereiche verdeckt werden können.
------
#### [ API ]
```
import base64
import json
import requests
import io
import os
from PIL import Image
image = "./content/input.png"
region = "us-east-1"
model_id = "us.stability.stable-image-search-replace-v1:0"
url = f"https://bedrock-runtime.{region}.amazonaws.com/model/{model_id}/invoke"
api_key = os.getenv("AWS_BEARER_TOKEN_BEDROCK") # https://docs.aws.amazon.com/bedrock/latest/userguide/getting-started-api-keys.html
headers = {
"Content-Type":"application/json",
"Authorization":f"Bearer {api_key}"
}
try:
with open(image, "rb") as image_file:
image_base64 = base64.b64encode(image_file.read()).decode('utf-8')
params = {
"image": image_base64,
"prompt": "jacket",
"search_prompt": "sweater",
}
response = requests.request("POST", url, json=params, headers=headers)
response.raise_for_status()
model_response = json.loads(response.text)
base64_image_data = model_response["images"][0]
if not base64_image_data:
raise ValueError("No image data found in model response.")
image_data = base64.b64decode(base64_image_data)
image = Image.open(io.BytesIO(image_data))
image.save("image.png")
print("Successfully saved image.")
except Exception as e:
print(e)
```
------
#### [ Python ]
```
import boto3
import base64
import io
import json
from PIL import Image
image = "./content/input.png"
region = "us-east-1"
model_id = "us.stability.stable-image-search-replace-v1:0"
bedrock = boto3.client("bedrock-runtime", region_name=region)
try:
with open(image, "rb") as image_file:
image_base64 = base64.b64encode(image_file.read()).decode('utf-8')
params = {
"image": image_base64,
"prompt": "jacket",
"search_prompt": "sweater",
}
request = json.dumps(params)
response = bedrock.invoke_model(modelId=model_id, body=request)
model_response = json.loads(response["body"].read())
base64_image_data = model_response["images"][0]
if not base64_image_data:
raise ValueError("No image data found in model response.")
image_data = base64.b64decode(base64_image_data)
image = Image.open(io.BytesIO(image_data))
image.save("image.png")
print("Successfully saved image.")
except Exception as e:
print(e)
```
------
Die folgende Tabelle zeigt die Eingabe- und Ausgabebilder eines „Suchen und ersetzen“-Vorgangs mit dem folgenden Prompt: *jacket.*
| Input | Ausgabe |
| --- | --- |
| ![\[alt text not found\]](http://docs.aws.amazon.com/de_de/bedrock/latest/userguide/images/stable-image-services/input-search-replace.jpg) | ![\[alt text not found\]](http://docs.aws.amazon.com/de_de/bedrock/latest/userguide/images/stable-image-services/output-search-replace.jpg) |
### Löschen
Mit „Löschen“ können Sie unerwünschte Elemente mithilfe von Bildmasken entfernen und gleichzeitig die Konsistenz des Hintergrunds auf intelligente Weise beibehalten.
„Löschen“ verfügt über die folgenden erforderlichen Parameter:
+ **image** – (Zeichenfolge) Das Base64-Bild, aus dem gelöscht werden soll. Jede Seite des Bilds muss mindestens 64 Pixel groß sein. Die Gesamtpixelzahl darf 9 437 184 Pixel nicht überschreiten. Das Seitenverhältnis des Bilds muss zwischen 1:2,5 und 2,5:1 liegen. Unterstützte Formate: JPEG, PNG, WebP.
Die folgenden Parameter sind optional:
+ **seed** – (Zahl) Ein bestimmter Wert, der als Richtwert für die „Zufälligkeit“ der Generierung dient. (Lassen Sie diesen Parameter weg oder übergeben Sie „0“, um einen zufälligen Seed-Wert zu verwenden.) Der Bereich liegt zwischen 0 und 4294967294. Standard: 0
+ **output\$1format** – (Zeichenfolge) Gibt den Inhaltstyp des generierten Bilds vor. Aufzählung: jpeg, png, webp. Standard: png
+ **mask** – (Zeichenfolge) Steuert die Stärke des Inpainting-Prozesses pro Pixel, entweder über ein zweites Bild (das an diesen Parameter übergeben wird) oder über den Alphakanal des Bildparameters.
+ **Maske übergeben** – Das an diesen Parameter übergebene Bild sollte ein Schwarzweißbild sein, das an jedem Pixel die Inpainting-Stärke darstellt, basierend darauf, wie dunkel oder hell das jeweilige Pixel ist. Vollständig schwarze Pixel stellen keine Inpainting-Stärke dar, vollständig weiße Pixel stehen hingegeben für maximale Stärke. Falls die Maske eine andere Größe als der Bildparameter aufweist, wird ihre Größe automatisch angepasst.
+ **Alphakanal-Unterstützung** – Wenn Sie keine explizite Maske angeben, wird eine aus dem Alphakanal des Bildparameters abgeleitet. Für transparente Pixel erfolgt ein Inpainting, undurchsichtige Pixel hingegeben werden beibehalten. Falls ein Bild mit einem Alphakanal zusammen mit einer Maske bereitgestellt wird, hat die Maske Vorrang.
+ **grow\$1mask** – Vergrößert die Kanten der Maske nach außen in alle Richtungen um die angegebene Anzahl von Pixeln. Der erweiterte Bereich um die Maske herum wird unscharf, was dazu beitragen kann, den Übergang zwischen Inhalt, für den ein Inpainting durchgeführt wurde, und dem Originalbild zu glätten. Der Bereich liegt zwischen 0 und 20. Standard: 5 Probieren Sie diesen Parameter aus, wenn Sie am Inhalt, für den kein Inpainting durchgeführt wurde, Übergänge oder raue Kanten bemerken. Beachten Sie, dass übermäßiges Wachstum feine Details in der Maskenverschmelzung in der Nähe von and/or maskierten Bereichen verdecken kann.
**Anmerkung**
Stellen Sie sicher, dass Ihre Maske die zu entfernenden Bereiche genau definiert, um optimale Löschergebnisse zu erzielen. Wenn keine explizite Maske angegeben wird, verwendet der Service den Alphakanal des Eingabebildes. Wenn beide angegeben sind, hat die Maske Vorrang.
------
#### [ API ]
```
import base64
import json
import requests
import io
import os
from PIL import Image
image = "./content/input.png"
mask = "./content/mask.png"
region = "us-east-1"
model_id = "us.stability.stable-image-erase-object-v1:0"
url = f"https://bedrock-runtime.{region}.amazonaws.com/model/{model_id}/invoke"
api_key = os.getenv("AWS_BEARER_TOKEN_BEDROCK") # https://docs.aws.amazon.com/bedrock/latest/userguide/getting-started-api-keys.html
headers = {
"Content-Type":"application/json",
"Authorization":f"Bearer {api_key}"
}
try:
with open(image, "rb") as image_file:
image_base64 = base64.b64encode(image_file.read()).decode('utf-8'),
with open(mask, "rb") as mask_file:
mask_base64 = base64.b64encode(mask_file.read()).decode('utf-8')
params = {
"image": image_base64,
"mask": mask_base64
}
response = requests.request("POST", url, json=params, headers=headers)
response.raise_for_status()
model_response = json.loads(response.text)
base64_image_data = model_response["images"][0]
if not base64_image_data:
raise ValueError("No image data found in model response.")
image_data = base64.b64decode(base64_image_data)
image = Image.open(io.BytesIO(image_data))
image.save("image.png")
print("Successfully saved image.")
except Exception as e:
print(e)
```
------
#### [ Python ]
```
import boto3
import base64
import io
import json
from PIL import Image
image = "./content/input.png"
mask = "./content/mask.png"
region = "us-east-1"
model_id = "us.stability.stable-image-erase-object-v1:0"
bedrock = boto3.client("bedrock-runtime", region_name=region)
try:
with open(image, "rb") as image_file:
image_base64 = base64.b64encode(image_file.read()).decode('utf-8'),
with open(mask, "rb") as mask_file:
mask_base64 = base64.b64encode(mask_file.read()).decode('utf-8')
params = {
"image": image_base64,
"mask": mask_base64
}
request = json.dumps(params)
response = bedrock.invoke_model(modelId=model_id, body=request)
model_response = json.loads(response["body"].read())
base64_image_data = model_response["images"][0]
if not base64_image_data:
raise ValueError("No image data found in model response.")
image_data = base64.b64decode(base64_image_data)
image = Image.open(io.BytesIO(image_data))
image.save("image.png")
print("Successfully saved image.")
except Exception as e:
print(e)
```
------
In der folgenden Tabelle sind die Eingabe- und Ausgabebilder eines Löschvorgangs aufgeführt.
| Input | Maske | Ausgabe |
| --- | --- | --- |
| ![\[alt text not found\]](http://docs.aws.amazon.com/de_de/bedrock/latest/userguide/images/stable-image-services/input-erase-object.jpg) | ![\[alt text not found\]](http://docs.aws.amazon.com/de_de/bedrock/latest/userguide/images/stable-image-services/mask-erase-object.png) | ![\[alt text not found\]](http://docs.aws.amazon.com/de_de/bedrock/latest/userguide/images/stable-image-services/output-erase-object.jpg) |
### Hintergrund entfernen
Mit der Option „Hintergrund entfernen“ können Sie Objekte präzise vom Hintergrund isolieren.
„Hintergrund entfernen“ verfügt über die folgenden erforderlichen Parameter:
+ **image** – (Zeichenfolge) Das Base64-Bild, aus dem der Hintergrund entfernt werden soll. Jede Seite des Bilds muss mindestens 64 Pixel groß sein. Die Gesamtpixelzahl darf 9 437 184 Pixel nicht überschreiten. Das Seitenverhältnis des Bilds muss zwischen 1:2,5 und 2,5:1 liegen. Unterstützte Formate: JPEG, PNG, WebP.
Die folgenden Parameter sind optional:
+ **output\$1format** – (Zeichenfolge) Gibt den Inhaltstyp des generierten Bilds vor. Aufzählung: jpeg, png, webp. Standard: png
------
#### [ API ]
```
import base64
import json
import requests
import io
import os
from PIL import Image
image = "./content/input.png"
region = "us-east-1"
model_id = "us.stability.stable-image-remove-background-v1:0"
url = f"https://bedrock-runtime.{region}.amazonaws.com/model/{model_id}/invoke"
api_key = os.getenv("AWS_BEARER_TOKEN_BEDROCK") # https://docs.aws.amazon.com/bedrock/latest/userguide/getting-started-api-keys.html
headers = {
"Content-Type":"application/json",
"Authorization":f"Bearer {api_key}"
}
try:
with open(image, "rb") as image_file:
image_base64 = base64.b64encode(image_file.read()).decode('utf-8')
params = {
"image": image_base64,
}
response = requests.request("POST", url, json=params, headers=headers)
response.raise_for_status()
model_response = json.loads(response.text)
base64_image_data = model_response["images"][0]
if not base64_image_data:
raise ValueError("No image data found in model response.")
image_data = base64.b64decode(base64_image_data)
image = Image.open(io.BytesIO(image_data))
image.save("image.png")
print("Successfully saved image.")
except Exception as e:
print(e)
```
------
#### [ Python ]
```
import boto3
import base64
import io
import json
from PIL import Image
image = "./content/input.png"
region = "us-east-1"
model_id = "us.stability.stable-image-remove-background-v1:0"
bedrock = boto3.client("bedrock-runtime", region_name=region)
try:
with open(image, "rb") as image_file:
image_base64 = base64.b64encode(image_file.read()).decode('utf-8')
params = {
"image": image_base64
}
request = json.dumps(params)
response = bedrock.invoke_model(modelId=model_id, body=request)
model_response = json.loads(response["body"].read())
base64_image_data = model_response["images"][0]
if not base64_image_data:
raise ValueError("No image data found in model response.")
image_data = base64.b64decode(base64_image_data)
image = Image.open(io.BytesIO(image_data))
image.save("image.png")
print("Successfully saved image.")
except Exception as e:
print(e)
```
------
Die folgende Tabelle zeigt die Eingabe- und Ausgabebilder eines „Hintergrund entfernen“-Vorgangs.
| Input | Ausgabe |
| --- | --- |
| ![\[alt text not found\]](http://docs.aws.amazon.com/de_de/bedrock/latest/userguide/images/stable-image-services/input-remove-background.jpg) | ![\[alt text not found\]](http://docs.aws.amazon.com/de_de/bedrock/latest/userguide/images/stable-image-services/output-remove-background.jpg) |
## Steuerung
Im folgenden Abschnitt wird die Steuerung für Stability AI Image Services beschrieben.
### Steuerungsskizze
Werten Sie grobe Handskizzen mit präziser Steuerung zu verfeinerten Ausgaben auf. Bei Bildern, bei denen es sich nicht um Skizzen handelt, ermöglicht „Steuerungsskizze“ eine detaillierte Bearbeitung des endgültigen Erscheinungsbilds durch die Nutzung der Konturlinien und Kanten innerhalb des Bilds.
„Steuerungsskizze“ verfügt über die folgenden erforderlichen Parameter:
+ **prompt** – Was im Ausgabebild angezeigt werden soll. Ein starker, aussagekräftiger Prompt, der Elemente, Farben und Motive klar definiert, führt zu besseren Ergebnissen. Um die Gewichtung eines bestimmten Wortes zu steuern, verwenden Sie das Format (word:weight), wobei „word“ das Wort darstellt, dessen Gewichtung Sie steuern möchten, und „weight“ ein Wert ist. Bei den Werten „0“ und „1,0“ wurde das Wort weniger betont und bei einem Wert zwischen „1,1“ und „2“ wurde es hervorgehoben. Zum Beispiel: Der Himmel war klar (blue:0.3) und (green:1.8) würde einen Himmel vermitteln, der blau und grün, jedoch eher grün als blau ist. Mindestens 0 und maximal 10 000 Zeichen.
+ **image** – (Zeichenfolge) Das Base64-Bild der Skizze. Jede Seite des Bilds muss mindestens 64 Pixel groß sein. Die Gesamtpixelzahl darf 9 437 184 Pixel nicht überschreiten. Das Seitenverhältnis des Bilds muss zwischen 1:2,5 und 2,5:1 liegen. Unterstützte Formate: JPEG, PNG, WebP.
Die folgenden Parameter sind optional:
+ **control\$1strength** – (Zahl) Gibt an, inwiefern das Bild die Generierung beeinflusst bzw. steuert. Wird als Gleitkommazahl zwischen „0“ und „1“ dargestellt, wobei „0“ den geringsten und „1“ den maximalen Einfluss darstellt. Standard: 0,7
+ **negative\$1prompt** – (Zeichenfolge) Ein kurzer Text, der beschreibt, was im Ausgabebild nicht angezeigt werden soll. Dies ist ein erweitertes Feature. Maximal 10000 Zeichen.
+ **seed** – (Zahl) Ein bestimmter Wert, der als Richtwert für die „Zufälligkeit“ der Generierung dient. (Lassen Sie diesen Parameter weg oder übergeben Sie „0“, um einen zufälligen Seed-Wert zu verwenden.) Der Bereich liegt zwischen 0 und 4294967294. Standard: 0
+ **output\$1format** – (Zeichenfolge) Gibt den Inhaltstyp des generierten Bilds vor. Aufzählung: jpeg, png, webp. Standard: png
+ **style\$1preset** – Richtet das Bildmodell auf einen bestimmten Stil aus. Aufzählung: 3d-model, analog-film, anime, cinematic, comic-book, digital-art, enhance, fantasy-art, isometric, line-art, low-poly, modeling-compound, neon-punk, origami, photographic, pixel-art, tile-texture.
------
#### [ API ]
```
import base64
import json
import requests
import io
import os
from PIL import Image
image = "./content/input.jpg"
region = "us-east-1"
model_id = "us.stability.stable-image-control-sketch-v1:0"
url = f"https://bedrock-runtime.{region}.amazonaws.com/model/{model_id}/invoke"
api_key = os.getenv("AWS_BEARER_TOKEN_BEDROCK") # https://docs.aws.amazon.com/bedrock/latest/userguide/getting-started-api-keys.html
headers = {
"Content-Type":"application/json",
"Authorization":f"Bearer {api_key}"
}
try:
with open(image, "rb") as image_file:
image_base64 = base64.b64encode(image_file.read()).decode('utf-8')
params = {
"image": image_base64,
"prompt": "a house with background of mountains and river flowing nearby"
}
response = requests.request("POST", url, json=params, headers=headers)
response.raise_for_status()
model_response = json.loads(response.text)
base64_image_data = model_response["images"][0]
if not base64_image_data:
raise ValueError("No image data found in model response.")
image_data = base64.b64decode(base64_image_data)
image = Image.open(io.BytesIO(image_data))
image.save("image.png")
print("Successfully saved image.")
except Exception as e:
print(e)
```
------
#### [ Python ]
```
import boto3
import base64
import io
import json
from PIL import Image
image = "./content/input.jpg"
region = "us-east-1"
model_id = "us.stability.stable-image-control-sketch-v1:0"
bedrock = boto3.client("bedrock-runtime", region_name=region)
try:
with open(image, "rb") as image_file:
image_base64 = base64.b64encode(image_file.read()).decode('utf-8')
params = {
"image": image_base64,
"prompt": "a house with background of mountains and river flowing nearby"
}
request = json.dumps(params)
response = bedrock.invoke_model(modelId=model_id, body=request)
model_response = json.loads(response["body"].read())
base64_image_data = model_response["images"][0]
if not base64_image_data:
raise ValueError("No image data found in model response.")
image_data = base64.b64decode(base64_image_data)
image = Image.open(io.BytesIO(image_data))
image.save("image.png")
print("Successfully saved image.")
except Exception as e:
print(e)
```
------
Die folgende Tabelle zeigt die Eingabe- und Ausgabebilder des Aufrufs einer Steuerungsskizze mit dem folgenden Prompt: *ein Haus mit Bergen im Hintergrund und einem Fluss, der in der Nähe fließt*.
| Input | Ausgabe |
| --- | --- |
| ![\[alt text not found\]](http://docs.aws.amazon.com/de_de/bedrock/latest/userguide/images/stable-image-services/input-control-sketch.jpg) | ![\[alt text not found\]](http://docs.aws.amazon.com/de_de/bedrock/latest/userguide/images/stable-image-services/output-control-sketch.jpg) |
| | |
### Steuerungsstruktur
Mithilfe der Steuerungsstruktur können Sie Bilder generieren und dabei die Struktur eines Eingabebildes beibehalten. Dies ist besonders hilfreich für Szenarien der erweiterten Inhaltserstellung, wie beispielsweise die Neuerstellung von Szenen oder das Rendern von Zeichen aus Modellen.
Die Steuerungsstruktur verfügt über die folgenden erforderlichen Parameter:
+ **prompt** – Was im Ausgabebild angezeigt werden soll. Ein starker, aussagekräftiger Prompt, der Elemente, Farben und Motive klar definiert, führt zu besseren Ergebnissen. Um die Gewichtung eines bestimmten Wortes zu steuern, verwenden Sie das Format (word:weight), wobei „word“ das Wort darstellt, dessen Gewichtung Sie steuern möchten, und „weight“ ein Wert ist. Bei den Werten „0“ und „1,0“ wurde das Wort weniger betont und bei einem Wert zwischen „1,1“ und „2“ wurde es hervorgehoben. Zum Beispiel: Der Himmel war klar (blue:0.3) und (green:1.8) würde einen Himmel vermitteln, der blau und grün, jedoch eher grün als blau ist. Mindestens 0 und maximal 10 000 Zeichen.
+ **image** – (Zeichenfolge) Das Base64-Bild der Skizze. Jede Seite des Bilds muss mindestens 64 Pixel groß sein. Die Gesamtpixelzahl darf 9 437 184 Pixel nicht überschreiten. Das Seitenverhältnis des Bilds muss zwischen 1:2,5 und 2,5:1 liegen. Unterstützte Formate: JPEG, PNG, WebP.
Die folgenden Parameter sind optional:
+ **control\$1strength** – (Zahl) Gibt an, inwiefern das Bild die Generierung beeinflusst bzw. steuert. Wird als Gleitkommazahl zwischen „0“ und „1“ dargestellt, wobei „0“ den geringsten und „1“ den maximalen Einfluss darstellt. Standard: 0,7
+ **negative\$1prompt** – (Zeichenfolge) Ein kurzer Text, der beschreibt, was im Ausgabebild nicht angezeigt werden soll. Dies ist ein erweitertes Feature. Maximal 10000 Zeichen.
+ **seed** – (Zahl) Ein bestimmter Wert, der als Richtwert für die „Zufälligkeit“ der Generierung dient. (Lassen Sie diesen Parameter weg oder übergeben Sie „0“, um einen zufälligen Seed-Wert zu verwenden.) Der Bereich liegt zwischen 0 und 4294967294. Standard: 0
+ **output\$1format** – (Zeichenfolge) Gibt den Inhaltstyp des generierten Bilds vor. Aufzählung: jpeg, png, webp. Standard: png
+ **style\$1preset** – Richtet das Bildmodell auf einen bestimmten Stil aus. Aufzählung: 3d-model, analog-film, anime, cinematic, comic-book, digital-art, enhance, fantasy-art, isometric, line-art, low-poly, modeling-compound, neon-punk, origami, photographic, pixel-art, tile-texture.
------
#### [ API ]
```
import base64
import json
import requests
import io
import os
from PIL import Image
image = "./content/input.jpg"
region = "us-east-1"
model_id = "us.stability.stable-image-control-structure-v1:0"
url = f"https://bedrock-runtime.{region}.amazonaws.com/model/{model_id}/invoke"
api_key = os.getenv("AWS_BEARER_TOKEN_BEDROCK") # https://docs.aws.amazon.com/bedrock/latest/userguide/getting-started-api-keys.html
headers = {
"Content-Type":"application/json",
"Authorization":f"Bearer {api_key}"
}
try:
with open(image, "rb") as image_file:
image_base64 = base64.b64encode(image_file.read()).decode('utf-8')
params = {
"image": image_base64,
"prompt": "surreal structure with motion generated sparks lighting the scene"
}
response = requests.request("POST", url, json=params, headers=headers)
response.raise_for_status()
model_response = json.loads(response.text)
base64_image_data = model_response["images"][0]
if not base64_image_data:
raise ValueError("No image data found in model response.")
image_data = base64.b64decode(base64_image_data)
image = Image.open(io.BytesIO(image_data))
image.save("image.png")
print("Successfully saved image.")
except Exception as e:
print(e)
```
------
#### [ Python ]
```
import boto3
import base64
import io
import json
from PIL import Image
image = "./content/input.jpg"
region = "us-east-1"
model_id = "us.stability.stable-image-control-structure-v1:0"
bedrock = boto3.client("bedrock-runtime", region_name=region)
try:
with open(image, "rb") as image_file:
image_base64 = base64.b64encode(image_file.read()).decode('utf-8')
params = {
"image": image_base64,
"prompt": "surreal structure with motion generated sparks lighting the scene"
}
request = json.dumps(params)
response = bedrock.invoke_model(modelId=model_id, body=request)
model_response = json.loads(response["body"].read())
base64_image_data = model_response["images"][0]
if not base64_image_data:
raise ValueError("No image data found in model response.")
image_data = base64.b64decode(base64_image_data)
image = Image.open(io.BytesIO(image_data))
image.save("image.png")
print("Successfully saved image.")
except Exception as e:
print(e)
```
------
*Die folgende Tabelle zeigt die Eingabe- und Ausgabebilder eines „Steuerungsstruktur“-Vorgangs mit dem folgenden Prompt: Surreale Struktur mit durch Bewegung erzeugten Funken, die die Szene beleuchten*.
| Input | Ausgabe |
| --- | --- |
| ![\[alt text not found\]](http://docs.aws.amazon.com/de_de/bedrock/latest/userguide/images/stable-image-services/input-control-structure.jpg) | ![\[alt text not found\]](http://docs.aws.amazon.com/de_de/bedrock/latest/userguide/images/stable-image-services/output-control-structure.jpg) |
### Styleguide
Mit dem Styleguide können Sie Stilelemente aus einem Eingabebild extrahieren und diese als Vorlage für die Erstellung eines Ausgabebildes auf Basis des Prompts verwenden. Das Ergebnis ist ein neues Bild im selben Stil wie das Eingabebild.
Der Styleguide verfügt über die folgenden erforderlichen Parameter:
+ **prompt** – Was im Ausgabebild angezeigt werden soll. Ein starker, aussagekräftiger Prompt, der Elemente, Farben und Motive klar definiert, führt zu besseren Ergebnissen. Um die Gewichtung eines bestimmten Wortes zu steuern, verwenden Sie das Format (word:weight), wobei „word“ das Wort darstellt, dessen Gewichtung Sie steuern möchten, und „weight“ ein Wert ist. Bei den Werten „0“ und „1,0“ wurde das Wort weniger betont und bei einem Wert zwischen „1,1“ und „2“ wurde es hervorgehoben. Zum Beispiel: Der Himmel war klar (blue:0.3) und (green:1.8) würde einen Himmel vermitteln, der blau und grün, jedoch eher grün als blau ist. Mindestens 0 und maximal 10 000 Zeichen.
+ **image** – (Zeichenfolge) Das Base64-Bild der Skizze. Jede Seite des Bilds muss mindestens 64 Pixel groß sein. Die Gesamtpixelzahl darf 9 437 184 Pixel nicht überschreiten. Das Seitenverhältnis des Bilds muss zwischen 1:2,5 und 2,5:1 liegen. Unterstützte Formate: JPEG, PNG, WebP.
Die folgenden Parameter sind optional:
+ **aspect\$1ratio** – (Zeichenfolge) Steuert das Seitenverhältnis des generierten Bilds. Dieser Parameter ist nur für text-to-image Anfragen gültig. Standard: 1:1 Aufzählung: 16:9, 1:1, 21:9, 2:3, 3:2, 4:5, 5:4, 9:16, 9:21. Standard: 1:1
+ **negative\$1prompt** – (Zeichenfolge) Ein kurzer Text, der beschreibt, was im Ausgabebild nicht angezeigt werden soll. Dies ist ein erweitertes Feature. Maximal 10000 Zeichen.
+ **seed** – (Zahl) Ein bestimmter Wert, der als Richtwert für die „Zufälligkeit“ der Generierung dient. (Lassen Sie diesen Parameter weg oder übergeben Sie „0“, um einen zufälligen Seed-Wert zu verwenden.) Der Bereich liegt zwischen 0 und 4294967294. Standard: 0
+ **output\$1format** – (Zeichenfolge) Gibt den Inhaltstyp des generierten Bilds vor. Aufzählung: jpeg, png, webp. Standard: png
+ **fidelity** – (Zahl) Gibt an, wie sehr der Stil des Ausgabebilds dem Stil des Eingabebildes ähnelt. Der Bereich liegt zwischen 0 und 1. Standard: 0,5
+ **style\$1preset** – Richtet das Bildmodell auf einen bestimmten Stil aus. Aufzählung: 3d-model, analog-film, anime, cinematic, comic-book, digital-art, enhance, fantasy-art, isometric, line-art, low-poly, modeling-compound, neon-punk, origami, photographic, pixel-art, tile-texture.
------
#### [ API ]
```
import base64
import json
import requests
import io
import os
from PIL import Image
image = "./content/input.jpg"
region = "us-east-1"
model_id = "us.stability.stable-image-style-guide-v1:0"
url = f"https://bedrock-runtime.{region}.amazonaws.com/model/{model_id}/invoke"
api_key = os.getenv("AWS_BEARER_TOKEN_BEDROCK") # https://docs.aws.amazon.com/bedrock/latest/userguide/getting-started-api-keys.html
headers = {
"Content-Type":"application/json",
"Authorization":f"Bearer {api_key}"
}
try:
with open(image, "rb") as image_file:
image_base64 = base64.b64encode(image_file.read()).decode('utf-8')
params = {
"image": image_base64,
"prompt": "wide shot of modern metropolis"
}
response = requests.request("POST", url, json=params, headers=headers)
response.raise_for_status()
model_response = json.loads(response.text)
base64_image_data = model_response["images"][0]
if not base64_image_data:
raise ValueError("No image data found in model response.")
image_data = base64.b64decode(base64_image_data)
image = Image.open(io.BytesIO(image_data))
image.save("image.png")
print("Successfully saved image.")
except Exception as e:
print(e)
```
------
#### [ Python ]
```
import boto3
import base64
import io
import json
from PIL import Image
image = "./content/input.jpg"
region = "us-east-1"
model_id = "us.stability.stable-image-style-guide-v1:0"
bedrock = boto3.client("bedrock-runtime", region_name=region)
try:
with open(image, "rb") as image_file:
image_base64 = base64.b64encode(image_file.read()).decode('utf-8')
params = {
"image": image_base64,
"prompt": "wide shot of modern metropolis"
}
request = json.dumps(params)
response = bedrock.invoke_model(modelId=model_id, body=request)
model_response = json.loads(response["body"].read())
base64_image_data = model_response["images"][0]
if not base64_image_data:
raise ValueError("No image data found in model response.")
image_data = base64.b64decode(base64_image_data)
image = Image.open(io.BytesIO(image_data))
image.save("image.png")
print("Successfully saved image.")
except Exception as e:
print(e)
```
------
*Die folgende Tabelle zeigt die Eingabe- und Ausgabebilder des Styleguide-Aufrufs mit dem folgenden Prompt: Weitwinkelaufnahme einer modernen Metropole*.
| Input | Ausgabe |
| --- | --- |
| ![\[alt text not found\]](http://docs.aws.amazon.com/de_de/bedrock/latest/userguide/images/stable-image-services/input-style-guide.jpg) | ![\[alt text not found\]](http://docs.aws.amazon.com/de_de/bedrock/latest/userguide/images/stable-image-services/output-style-guide.jpg) |
### Stilübertragung
Mit der Stilübertragung können Sie visuelle Merkmale aus Referenzstilbildern auf Zielbilder anwenden. Während der Styleguide-Service Stilelemente aus einem Eingabebild extrahiert und diese als Vorlage für die Erstellung eines Ausgabebildes auf Basis des Prompts verwendet, werden mit der Stilübertragung insbesondere vorhandene Inhalte unter Beibehaltung der ursprünglichen Komposition transformiert. Dieses Tool hilft bei der Erstellung konsistenter Inhalte für mehrere Ressourcen.
„Stilübertragung“ verfügt über die folgenden erforderlichen Parameter:
+ **init\$1image** – (Zeichenfolge) Ein Base64-Bild, das den Betreff enthält, den Sie neugestalten möchten. Jede Seite des Bilds muss mindestens 64 Pixel groß sein. Die Gesamtpixelzahl darf 9 437 184 Pixel nicht überschreiten. Das Seitenverhältnis des Bilds muss zwischen 1:2,5 und 2,5:1 liegen. Unterstützte Formate: JPEG, PNG, WebP.
+ **style\$1image** – (Zeichenfolge) Ein Base64-Bild mit dem Motiv, das Sie neugestalten möchten. Jede Seite des Bilds muss mindestens 64 Pixel groß sein. Die Gesamtpixelzahl darf 9 437 184 Pixel nicht überschreiten. Das Seitenverhältnis des Bilds muss zwischen 1:2,5 und 2,5:1 liegen. Unterstützte Formate: JPEG, PNG, WebP.
Die folgenden Parameter sind optional:
+ **prompt** – (Zeichenfolge) Was im Ausgabebild angezeigt werden soll. Ein starker, aussagekräftiger Prompt, der Elemente, Farben und Motive klar definiert, führt zu besseren Ergebnissen. Um die Gewichtung eines bestimmten Wortes zu steuern, verwenden Sie das Format (word:weight), wobei „word“ das Wort darstellt, dessen Gewichtung Sie steuern möchten, und „weight“ ein Wert ist. Bei den Werten „0“ und „1,0“ wurde das Wort weniger betont und bei einem Wert zwischen „1,1“ und „2“ wurde es hervorgehoben. Zum Beispiel: Der Himmel war klar (blue:0.3) und (green:1.8) würde einen Himmel vermitteln, der blau und grün, jedoch eher grün als blau ist.
+ **negative\$1prompt** – (Zeichenfolge) Ein kurzer Text, der beschreibt, was im Ausgabebild nicht angezeigt werden soll. Dies ist ein erweitertes Feature. Maximal 10000 Zeichen.
+ **seed** – (Zahl) Ein bestimmter Wert, der als Richtwert für die „Zufälligkeit“ der Generierung dient. (Lassen Sie diesen Parameter weg oder übergeben Sie „0“, um einen zufälligen Seed-Wert zu verwenden.) Der Bereich liegt zwischen 0 und 4294967294. Standard: 0
+ **output\$1format** – (Zeichenfolge) Gibt den Inhaltstyp des generierten Bilds vor. Aufzählung: jpeg, png, webp. Standard: png
+ **composition\$1fidelity** – (Zahl) Gibt an, wie stark der Stil des Ausgabebildes dem Stil des Eingabebildes ähnelt. Der Bereich liegt zwischen 0 und 1. Standard: 0,9
+ **style\$1strength** – (Zahl) Dieser Parameter wird manchmal auch als Rauschunterdrückung bezeichnet und steuert, wie viel Einfluss der Parameter „style\$1image“ auf das generierte Bild hat. Der Wert 0 würde ein Bild ergeben, das mit der Eingabe identisch ist. Der Wert 1 würde bedeuten, dass überhaupt kein Bild übergeben wurde. Der Bereich liegt zwischen 0 und 1. Standard: 1
+ **change\$1strength** – (Zahl) Gibt an, wie stark das ursprüngliche Bild geändert werden soll. Der Bereich liegt zwischen 0,1 und 1. Standard: 0,9
------
#### [ API ]
```
import base64
import json
import requests
import io
import os
from PIL import Image
image = "./content/input.jpg"
style_image = "./content/style.jpg"
region = "us-east-1"
model_id = "us.stability.stable-style-transfer-v1:0"
url = f"https://bedrock-runtime.{region}.amazonaws.com/model/{model_id}/invoke"
api_key = os.getenv("AWS_BEARER_TOKEN_BEDROCK") # https://docs.aws.amazon.com/bedrock/latest/userguide/getting-started-api-keys.html
headers = {
"Content-Type":"application/json",
"Authorization":f"Bearer {api_key}"
}
try:
with open(image, "rb") as image_file:
image_base64 = base64.b64encode(image_file.read()).decode('utf-8')
with open(style_image, "rb") as style_image_file:
style_image_base64 = base64.b64encode(style_image_file.read()).decode('utf-8')
params = {
"init_image": image_base64,
"style_image": style_image_base64,
"prompt": "statue"
}
response = requests.request("POST", url, json=params, headers=headers)
response.raise_for_status()
model_response = json.loads(response.text)
base64_image_data = model_response["images"][0]
if not base64_image_data:
raise ValueError("No image data found in model response.")
image_data = base64.b64decode(base64_image_data)
image = Image.open(io.BytesIO(image_data))
image.save("image.png")
print("Successfully saved image.")
except Exception as e:
print(e)
```
------
#### [ Python ]
```
import boto3
import base64
import io
import json
from PIL import Image
image = "./content/cat_statue_512x512.jpg"
style_image = "./content/glowbot_style.jpg"
region = "us-east-1"
model_id = "us.stability.stable-style-transfer-v1:0"
bedrock = boto3.client("bedrock-runtime", region_name=region)
try:
with open(image, "rb") as image_file:
image_base64 = base64.b64encode(image_file.read()).decode('utf-8')
with open(style_image, "rb") as style_image_file:
style_image_base64 = base64.b64encode(style_image_file.read()).decode('utf-8')
params = {
"init_image": image_base64,
"style_image": style_image_base64,
"prompt": "statue"
}
request = json.dumps(params)
response = bedrock.invoke_model(modelId=model_id, body=request)
model_response = json.loads(response["body"].read())
base64_image_data = model_response["images"][0]
if not base64_image_data:
raise ValueError("No image data found in model response.")
image_data = base64.b64decode(base64_image_data)
image = Image.open(io.BytesIO(image_data))
image.save("image.png")
print("Successfully saved image.")
except Exception as e:
print(e)
```
------
Die folgende Tabelle zeigt die Eingabe- und Ausgabebilder eines Stilübertragungsaufrufs.
| Input | Style | Ausgabe |
| --- | --- | --- |
| ![\[alt text not found\]](http://docs.aws.amazon.com/de_de/bedrock/latest/userguide/images/stable-image-services/input-style-transfer.jpg) | ![\[alt text not found\]](http://docs.aws.amazon.com/de_de/bedrock/latest/userguide/images/stable-image-services/style-style-transfer.jpg) | ![\[alt text not found\]](http://docs.aws.amazon.com/de_de/bedrock/latest/userguide/images/stable-image-services/output-style-transfer.jpg) |
# Modelle von TwelveLabs
In diesem Abschnitt werden die Anforderungsparameter und Antwortfelder für Modelle von TwelveLabs beschrieben. Verwenden Sie diese Informationen, um Inferenzaufrufen an TwelveLabs-Modelle zu senden. Das TwelveLabs Pegasus 1.2 Modell unterstützt [InvokeModel](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModel.html)und [InvokeModelWithResponseStream](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModelWithResponseStream.html)(Streaming-) Operationen. Die TwelveLabs Marengo Embed 3.0 Modelle TwelveLabs Marengo Embed 2.7 und unterstützen [StartAsyncInvoke](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_StartAsyncInvoke.html)Operationen. Dieser Abschnitt enthält auch Codebeispiele, die zeigen, wie TwelveLabs-Modelle aufgerufen werden. Sie benötigen die Modell-ID für das Modell, um ein Modell in einer Inferenzoperation verwenden zu können. Informationen zum Abrufen der Modell-ID finden Sie unter [Unterstützte Basismodelle in Amazon Bedrock](models-supported.md).
TwelveLabs ist ein führender Anbieter multimodaler KI-Modelle, der sich auf das Verständnis und die Analyse von Videos spezialisiert hat. Ihre fortschrittlichen Modelle ermöglichen mithilfe von state-of-the-art Computervision und natürlicher Sprachverarbeitung ausgefeilte Funktionen für die Videosuche, -analyse und -generierung.
Amazon Bedrock bietet drei TwelveLabs Modelle an:
+ TwelveLabs Pegasus 1.2bietet ein umfassendes Verständnis und eine umfassende Analyse von Videos.
+ TwelveLabs Marengo Embed 2.7generiert hochwertige Einbettungen für Video-, Text-, Audio- und Bildinhalte.
+ TwelveLabs Marengo Embed 3.0ist das neueste Einbettungsmodell mit verbesserter Leistung und erweiterten Funktionen.
Diese Modelle helfen Ihnen bei der Entwicklung von Anwendungen, die Videodaten in großem Maßstab verarbeiten, analysieren und Erkenntnisse daraus ableiten.
**TwelveLabs Pegasus 1.2**
Ein multimodales Modell, das umfassende Funktionen zum Verständnis und zur Analyse von Videos bietet, einschließlich Inhaltserkennung, Szenenerkennung und kontextuellem Verständnis. Das Modell kann Videoinhalte analysieren und Textbeschreibungen, Einblicke und Antworten auf Fragen zum Video generieren.
**TwelveLabs Marengo Embed 2.7**
Ein multimodales Einbettungsmodell, das hochwertige Vektordarstellungen von Video-, Text-, Audio- und Bildinhalten für die Ähnlichkeitssuche, Clustering und andere Machine-Learning-Aufgaben generiert. Das Modell unterstützt mehrere Eingabemodalitäten und bietet spezielle Einbettungen, die für verschiedene Anwendungsfälle optimiert sind.
**TwelveLabs Marengo Embed 3.0**
Ein verbessertes multimodales Einbettungsmodell, das die Funktionen von Marengo 2.7 um die Unterstützung der verschachtelten Text- und Bildeingabemodalität erweitert. Dieses Modell generiert hochwertige Vektordarstellungen von Video-, Text-, Audio-, Bild- und verschachtelten Text-Bild-Inhalten für die Ähnlichkeitssuche, Clustering und andere Aufgaben des maschinellen Lernens.
**Topics**
+ [TwelveLabs Pegasus 1.2](model-parameters-pegasus.md)
+ [TwelveLabs Marengo Embed 2.7](model-parameters-marengo.md)
+ [TwelveLabs Marengo Embed 3.0](model-parameters-marengo-3.md)
# TwelveLabs Pegasus 1.2
Das Modell TwelveLabs Pegasus 1.2 bietet umfassende Funktionen zum Verständnis und zur Analyse von Videos. Es kann Videoinhalte analysieren und Textbeschreibungen, Einblicke und Antworten auf Fragen zum Video generieren.
Verwenden Sie diese Informationen, um Inferenzaufrufe an TwelveLabs Modelle mit den InvokeModel, InvokeModelWithResponseStream (Streaming-) Operationen durchzuführen.
+ Anbieter: – TwelveLabs
+ Kategorien – Videoverständnis, Inhaltsanalyse
+ Model ID: – `twelvelabs.pegasus-1-2-v1:0`
+ Eingabemodalität – Video
+ Ausgabemodalität – Text
+ Maximale Videogröße – Video mit einer Länge von 1 Stunde (< 2 GB Dateigröße)
## Anforderungsparameter von TwelveLabs Pegasus 1.2
In der folgenden Tabelle werden die Eingabeparameter für das Modell TwelveLabs Pegasus 1.2 beschrieben:
**Anforderungsparameter von TwelveLabs Pegasus 1.2**
| Feld | Typ | Erforderlich | Beschreibung |
| --- | --- | --- | --- |
| inputPrompt | Zeichenfolge | Ja | Prompt zur Analyse des Videos Max.: 2 000 Token |
| temperature | double | Nein | Temperatur für das Modell Steuert die Zufälligkeit der Ausgabe Standard: 0,2, Min.: 0, Max.: 1 |
| responseFormat | Objekt | Nein | Ermöglicht Benutzern die Angabe des strukturierten Ausgabeformats Unterstützt derzeit nur json\$1schema |
| mediaSource | object | Ja | Beschreibt die Medienquelle Es muss entweder base64String oder s3Location angegeben werden. |
| mediaSource.base64String | Zeichenfolge | Nein | Base64-codierte Bytezeichenfolge für das Video Maximal: 25 MB. |
| mediaSource.s3Location.uri | Zeichenfolge | Nein | S3-URI, über den das Video heruntergeladen werden konnte Max.: Video mit einer Länge von 1 Stunde (< 2 GB Dateigröße) |
| mediaSource.s3Location.bucketOwner | Zeichenfolge | Nein | Die AWS-Konto-ID des Bucket-Eigentümers |
| maxOutputTokens | Ganzzahl | Nein | Die maximale Anzahl der zu generierenden Token Max.: 4 096 |
## TwelveLabs Pegasus 1.2-Antwortfelder
In der folgenden Tabelle werden die Ausgabefelder für das Modell TwelveLabs Pegasus 1.2 beschrieben:
**TwelveLabs Pegasus 1.2-Antwortfelder**
| Feld | Typ | Description |
| --- | --- | --- |
| message | Zeichenfolge | Ausgabenachricht, die die Analyse des Videos durch das Modell enthält |
| finishReason | Zeichenfolge | Stopp-Grund, der beschreibt, warum die Ausgabe beendet wurde Gültige Werte: stop (die API hat die vollständige Vervollständigungen zurückgegeben, ohne dass irgendwelche Limits erreicht wurden), length (die Generierung hat das max\$1tokens-Limit überschritten) |
## Anforderung und Antwort von TwelveLabs Pegasus 1.2
Die folgenden Beispiele zeigen, wie das Modell TwelveLabs Pegasus 1.2 mit verschiedenen Eingabequellen verwendet wird.
------
#### [ Request ]
Die folgenden Beispiele veranschaulichen Anforderungsformate für das Modell TwelveLabs Pegasus 1.2.
**Verwenden von base64-codiertem Video:**
```
{
"inputPrompt": "tell me about the video",
"mediaSource": {
"base64String": ""
},
"temperature": 0
}
```
**Verwenden von in S3 gespeichertem Video:**
```
{
"inputPrompt": "Tell me about this video",
"mediaSource": {
"s3Location": {
"uri": "s3://path-to-video-object-in-s3",
"bucketOwner": "bucket-owner-account-id"
}
},
"temperature": 0
}
```
**Verwenden des strukturierten Ausgabeformats:**
```
{
"inputPrompt": "Analyze this video and provide a structured summary",
"mediaSource": {
"s3Location": {
"uri": "s3://path-to-video-object-in-s3",
"bucketOwner": "bucket-owner-account-id"
}
},
"temperature": 0.2,
"maxOutputTokens": 2048,
"responseFormat": {
"type": "json_schema",
"json_schema": {
"name": "video_analysis",
"schema": {
"type": "object",
"properties": {
"summary": {"type": "string"},
"key_scenes": {"type": "array", "items": {"type": "string"}},
"duration": {"type": "string"}
},
"required": ["summary", "key_scenes"]
}
}
}
}
```
------
#### [ Response ]
Die folgenden Beispiele veranschaulichen Antwortformate für das Modell TwelveLabs Pegasus 1.2.
**Standardantwort:**
```
{
"message": "This video shows a person walking through a park during sunset. The scene includes trees, a walking path, and golden lighting from the setting sun. The person appears to be enjoying a peaceful evening stroll.",
"finishReason": "stop"
}
```
**Antwort mit strukturierter Ausgabe:**
```
{
"message": "{\"summary\": \"A peaceful evening walk through a park at sunset\", \"key_scenes\": [\"Person entering the park\", \"Walking along tree-lined path\", \"Sunset lighting through trees\", \"Person sitting on bench\"], \"duration\": \"Approximately 2 minutes\"}",
"finishReason": "stop"
}
```
**Antwort, wenn die maximale Anzahl an Token erreicht wurde:**
```
{
"message": "This video contains multiple scenes showing various activities. The first scene shows...",
"finishReason": "length"
}
```
------
# TwelveLabs Marengo Embed 2.7
Das Modell TwelveLabs Marengo Embed 2.7 generiert Einbettungen aus Video-, Text-, Audio- oder Bildeingaben. Diese Einbettungen können für die Ähnlichkeitssuche, Clustering und andere Machine-Learning-Aufgaben verwendet werden.
+ Anbieter – TwelveLabs
+ Model ID: – twelvelabs.marengo-embed-2-7-v1:0
Das Modell TwelveLabs Marengo Embed 2.7 unterstützt die Laufzeitoperationen von Amazon Bedrock in der folgenden Tabelle.
+ Weitere Informationen zu den Anwendungsfällen für verschiedene API-Methoden finden Sie unter [Hier erfahren Sie mehr über Anwendungsfälle für verschiedene ModellinferenzmethodenVerschiedene Inferenzmethoden](inference-methods.md).
+ Weitere Informationen zu den Modelltypen finden Sie unter [So funktioniert Inferenz in Amazon BedrockFunktionsweise der Inferenz](inference-how.md).
+ Eine Modellliste IDs sowie die Modelle und AWS Regionen, die TwelveLabs Marengo Embed 2.7 unterstützt werden, finden Sie in der Tabelle unter[Unterstützte Basismodelle in Amazon Bedrock](models-supported.md).
+ Eine vollständige Liste der Inferenzprofile finden Sie IDs unter[Unterstützte Regionen und Modelle für Inferenzprofile](inference-profiles-support.md). Die ID des Inferenzprofils basiert auf der AWS Region.
****
| API-Operation | Unterstützte Modelltypen | Eingabemodalitäten | Ausgabemodalitäten |
| --- | --- | --- | --- |
| InvokeModel | [Inferenzprofile](inference-profiles-support.md) | Text Image | Einbettung |
| StartAsyncInvoke | [Basismodelle](models-supported.md) | Video Audio Image Text | Einbettung |
**Anmerkung**
Verwenden Sie `InvokeModel`, um Einbettungen für Suchabfragen zu generieren. Verwenden Sie `StartAsyncInvoke`, um Einbettungen für Assets in großem Umfang zu generieren.
Die folgenden Kontingente gelten für die Eingabe:
****
| Eingabemodalität | Maximum |
| --- | --- |
| Text | 77 Token |
| Image | 5 MB |
| Video (S3) | 2 GB |
| Audio (S3) | 2 GB |
**Anmerkung**
Wenn Sie Audio oder Video inline mithilfe der base64-Kodierung definieren, stellen Sie sicher, dass die Nutzdaten des Anforderungstexts das Amazon-Bedrock-Modellaufrufkontingent von 25 MB nicht überschreitet.
**Topics**
+ [Anforderungsparameter von TwelveLabs Marengo Embed 2.7](#model-parameters-marengo-async-request)
+ [TwelveLabs Marengo Embed 2.7-Antwort](#model-parameters-marengo-response)
+ [TwelveLabs Marengo Embed 2.7-Codebeispiele](#model-parameters-marengo-examples)
## Anforderungsparameter von TwelveLabs Marengo Embed 2.7
Wenn Sie eine Anforderung stellen, hängt das Feld, in dem die modellspezifische Eingabe angegeben wird, von der API-Operation ab:
+ [InvokeModel](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModel.html)— In der Anfrage`body`.
+ [StartAsyncInvoke](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_StartAsyncInvoke.html)— Im `modelInput` Feld des Hauptteils der Anfrage.
Das Format der Modelleingabe hängt von der Eingabemodalität ab:
------
#### [ Text ]
```
{
"inputType": "text",
"inputText": "string",
"textTruncate": "string
}
```
------
#### [ Inline image ]
```
{
"inputType": "image",
"mediaSource": {
"base64String": "base64-encoded string"
}
}
```
------
#### [ S3 image ]
```
{
"inputType": "image",
"mediaSource": {
"s3Location": {
"uri": "string",
"bucketOwner": "string"
}
}
}
```
------
#### [ Inline video ]
```
{
"inputType": "video",
"mediaSource": {
"s3Location": {
"base64String": "base64-encoded string"
}
},
"startSec": double,
"lengthSec": double,
"useFixedLengthSec": double,
"embeddingOption": "visual-text" | "visual-image" | "audio"
}
```
------
#### [ S3 video ]
```
{
"inputType": "image",
"mediaSource": {
"s3Location": {
"uri": "string",
"bucketOwner": "string"
}
},
"startSec": double,
"lengthSec": double,
"useFixedLengthSec": double,
"minClipSec": int,
"embeddingOption": ["string"]
}
```
------
#### [ Inline audio ]
```
{
"inputType": "audio",
"mediaSource": {
"base64String": "base64-encoded string"
},
"startSec": double,
"lengthSec": double,
"useFixedLengthSec": double
}
```
------
#### [ S3 audio ]
```
{
"inputType": "audio",
"mediaSource": {
"s3Location": {
"uri": "string",
"bucketOwner": "string"
}
},
"startSec": double,
"lengthSec": double,
"useFixedLengthSec": double
}
```
------
Erweitern Sie die folgenden Abschnitte, um ausführliche Informationen zu den Eingabeparametern zu erhalten:
### inputType
Modalität für die Einbettung
+ **Typ:** Zeichenfolge
+ **Erforderlich**: Ja
+ **Zulässige Werte**: `video` \$1 `text` \$1 `audio` \$1 `image`
### inputText
Text, der eingebettet werden soll
+ **Typ:** Zeichenfolge
+ **Erforderlich:** Ja (für kompatible Eingabetypen)
+ **Kompatible Eingabetypen:** Text
### textTruncate
Gibt an, wie die Plattform Text kürzt
+ **Typ:** Zeichenfolge
+ **Required**: No
+ **Zulässige Werte**:
+ `end` – Kürzt das Textende
+ `none` – Gibt einen Fehler zurück, wenn der Text das Limit überschreitet
+ **Standardwert:** Ende
+ **Kompatible Eingabetypen:** Text
### mediaSource
Enthält Informationen zur Medienquelle
+ **Typ:** Objekt
+ **Erforderlich:** Ja (falls kompatibler Typ)
+ **Kompatible Eingabetypen:** Bild, Video, Audio
Das Format des `mediaSource`-Objekts im Anforderungstext hängt davon ab, ob das Medium als Base64-kodierte Zeichenfolge oder als S3-Speicherort definiert ist.
+ **Base64-kodierte Zeichenfolge**
```
{
"mediaSource": {
"base64String": "base64-encoded string"
}
}
```
+ `base64String` – Die Base64-kodierte Zeichenfolge für das Medium
+ **S3-Standort** — Geben Sie den S3-URI und den Bucket-Besitzer an.
```
{
"s3Location": {
"uri": "string",
"bucketOwner": "string"
}
}
```
+ `uri` – Der S3-URI, der das Medium enthält
+ `bucketOwner`— Die AWS Konto-ID des S3-Bucket-Besitzers.
### embeddingOption
Gibt an, welche Arten von Einbettungen abgerufen werden sollen.
+ **Typ**: Liste
+ **Required**: No
+ **Gültige Werte für Listenmitglieder:**
+ `visual-text` – Visuelle Einbettungen, die für die Textsuche optimiert sind
+ `visual-image` – Visuelle Einbettungen, die für die Bildsuche optimiert sind
+ `audio` – Einbettungen des Audios in das Video
+ **Standardwert:** [„visual-text“, „visual-image“, „audio"]
+ **Kompatible Eingabetypen:** Video, Audio
### startSec
Der Zeitpunkt in Sekunden des Clips, zu dem die Verarbeitung beginnen soll
+ **Type**: Double
+ **Required**: No
+ **Mindestwert** 0
+ **Standardwert:** 0
+ **Kompatible Eingabetypen:** Video, Audio
### lengthSec
Die Zeit in Sekunden, gerechnet ab dem `startSec`-Zeitpunkt, nach dem die Verarbeitung beendet werden soll
+ **Type**: Double
+ **Required**: No
+ **Gültige Werte:** 0 – Dauer des Mediums
+ **Standardwert:** Dauer des Mediums
+ **Kompatible Eingabetypen:** Video, Audio
Beispiel:
+ startSec: 5
+ lengthSec: 20
+ Ergebnis: Der Clip wird von 0:05 bis 0:25 (5 Sekunden \$1 20 Sekunden) verarbeitet.
### useFixedLengthSekunde
Die Dauer jedes Clips, für den das Modell eine Einbettung generieren soll
+ **Type**: Double
+ **Required**: No
+ **Wertparameter:** 2–10. Der Wert muss gleich oder größer als `minClipSec` sein.
+ **Standardwert:** Hängt vom Medientyp ab:
+ **Video:** Dynamisch aufgeteilt durch Erkennung von Schussgrenzen.
+ **Audio:** Gleichmäßig aufgeteilt mit Segmenten, die so nah wie möglich an 10 Sekunden heranreichen.
Beispiele:
+ Ein 50-Sekunden-Clip ist in 5 10-Sekunden-Segmente unterteilt.
+ Ein 16-Sekunden-Clip ist in 2 8-Sekunden-Segmente unterteilt.
+ **Kompatible Eingabetypen:** – Video, Audio
+ **Hinweis:** Der Wert muss gleich oder größer als `minClipSec` sein.
### minClipSec
Legt für jeden Clip einen Mindestwert in Sekunden fest
+ **Typ:** int
+ **Required**: No
+ **Wertparameter:** Wertebereich: 1–5
+ **Standardwert**: 4
+ **Kompatible Eingabetypen:** Video
+ **Hinweis:** Der Wert muss gleich oder kleiner als `useFixedLengthSec` sein.
## TwelveLabs Marengo Embed 2.7-Antwort
Der Speicherort der Ausgabeeinbettungen und der zugehörigen Metadaten hängt von der Aufrufmethode ab:
+ [InvokeModel](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModel.html)— Im Antworttext.
+ [StartAsyncInvoke](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_StartAsyncInvoke.html)— Im S3-Bucket, der in definiert ist`s3OutputDataConfig`, nachdem der asynchrone Aufruf-Job abgeschlossen ist.
Wenn es mehrere Einbettungsvektoren gibt, besteht die Ausgabe aus einer Liste von Objekten, die jeweils einen Vektor und die zugehörigen Metadaten enthalten.
Das Format des Einbettungsvektors der Ausgabe lautet wie folgt:
```
{
"embedding": ["string"],
"embeddingOption": "visual-text" | "visual-image" | "audio",
"startSec": double,
"endsec": double
}
```
Erweitern Sie die folgenden Abschnitte, um ausführliche Informationen zu den Antwortparametern zu erhalten:
### embedding
Darstellung des Einbettungsvektors der Eingabe
+ **Typ**: Liste von Double-Werten
### embeddingOption
Die Art der Einbettungen
+ **Typ:** Zeichenfolge
+ **Mögliche Werte:**
+ `visual-text` – Visuelle Einbettungen, die für die Textsuche optimiert sind
+ `visual-image` – Visuelle Einbettungen, die für die Bildsuche optimiert sind
+ `audio` – Einbettungen des Audios in das Video
+ **Kompatible Eingabetypen:** Video
### startSec
Der Startversatz des Clips
+ **Type**: Double
+ **Kompatible Eingabetypen:** Video, Audio
### endSec
Der Endversatz des Clips in Sekunden
+ **Type**: Double
+ **Kompatible Eingabetypen:** Video, Audio
## TwelveLabs Marengo Embed 2.7-Codebeispiele
In diesem Abschnitt wird gezeigt, wie Sie das Modell TwelveLabs Marengo Embed 2.7 mit verschiedenen Eingabetypen mithilfe von Python verwenden. Die Beispiele zeigen, wie modellspezifische Eingaben definiert und Modellaufrufe ausgeführt werden.
**Anmerkung**
InvokeModel unterstützt nur Text- und Bildeingaben. Verwenden Sie für die Video- und Audioeingabe StartAsyncInvoke.
Stellen Sie Ihren Code in den folgenden Schritten zusammen:
**1. Definieren der modellspezifische Eingabe**
Definieren Sie die modellspezifische Eingabe abhängig von Ihrem Eingabetyp:
------
#### [ Text ]
```
# Create the model-specific input
model_id = "twelvelabs.marengo-embed-2-7-v1:0"
# Replace the us prefix depending on your region
inference_profile_id = "us.twelvelabs.marengo-embed-2-7-v1:0"
model_input = {
"inputType": "text",
"inputText": "man walking a dog"
}
```
------
#### [ Inline image ]
```
# Create the model-specific input
model_id = "twelvelabs.marengo-embed-2-7-v1:0"
# Replace the us prefix depending on your region
inference_profile_id = "us.twelvelabs.marengo-embed-2-7-v1:0"
model_input = {
"inputType": "image",
"mediaSource": {
"base64String": "example-base64-image"
}
}
```
------
#### [ S3 image ]
```
# Create the model-specific input
model_id = "twelvelabs.marengo-embed-2-7-v1:0"
# Replace the us prefix depending on your region
inference_profile_id = "us.twelvelabs.marengo-embed-2-7-v1:0"
model_input = {
"inputType": "image",
"mediaSource": {
"s3Location": {
"uri": "s3://amzn-s3-demo-bucket/my_image.png",
"bucketOwner": "123456789012"
}
}
}
```
------
#### [ Inline video ]
```
# Create the model-specific input
model_id = "twelvelabs.marengo-embed-2-7-v1:0"
# Replace the us prefix depending on your region
inference_profile_id = "us.twelvelabs.marengo-embed-2-7-v1:0"
model_input = {
"inputType": "video",
"mediaSource": {
"base64String": "base_64_encoded_string_of_video"
},
"startSec": 0,
"lengthSec": 13,
"useFixedLengthSec": 5,
"embeddingOption": [
"visual-text",
"audio"
]
}
```
------
#### [ S3 video ]
```
# Create the model-specific input
model_id = "twelvelabs.marengo-embed-2-7-v1:0"
# Replace the us prefix depending on your region
inference_profile_id = "us.twelvelabs.marengo-embed-2-7-v1:0"
model_input = {
"inputType": "video",
"mediaSource": {
"s3Location": {
"uri": "amzn-s3-demo-bucket/my-video.mp4",
"bucketOwner": "123456789012"
}
},
"startSec": 0,
"lengthSec": 13,
"useFixedLengthSec": 5,
"embeddingOption": [
"visual-text",
"audio"
]
}
```
------
#### [ Inline audio ]
```
# Create the model-specific input
model_id = "twelvelabs.marengo-embed-2-7-v1:0"
# Replace the us prefix depending on your region
inference_profile_id = "us.twelvelabs.marengo-embed-2-7-v1:0"
model_input = {
"inputType": "audio",
"mediaSource": {
"base64String": "base_64_encoded_string_of_audio"
},
"startSec": 0,
"lengthSec": 13,
"useFixedLengthSec": 10
}
```
------
#### [ S3 audio ]
```
# Create the model-specific input
model_id = "twelvelabs.marengo-embed-2-7-v1:0"
# Replace the us prefix depending on your region
inference_profile_id = "us.twelvelabs.marengo-embed-2-7-v1:0"
model_input = {
"inputType": "audio",
"mediaSource": {
"s3Location": {
"uri": "s3://amzn-s3-demo-bucket/my-audio.wav",
"bucketOwner": "123456789012"
}
},
"startSec": 0,
"lengthSec": 13,
"useFixedLengthSec": 10
}
```
------
**2. Ausführen des Modellaufrufs mithilfe der Modelleingabe**
Fügen Sie dann den Codeausschnitt hinzu, der der Methode Ihrer Wahl für den Modellaufruf entspricht.
------
#### [ InvokeModel ]
```
# Run model invocation with InvokeModel
import boto3
import json
# Initialize the Bedrock Runtime client
client = boto3.client('bedrock-runtime')
# Make the request
response = client.invoke_model(
modelId=inference_profile_id,
body=json.dumps(model_input)
)
# Print the response body
response_body = json.loads(response['body'].read().decode('utf-8'))
print(response_body)
```
------
#### [ StartAsyncInvoke ]
```
# Run model invocation asynchronously
import boto3
import json
# Initalize the Bedrock Runtime client.
client = boto3.client("bedrock-runtime")
try:
# Start the asynchronous job
invocation = client.start_async_invoke(
modelId=model_id,
modelInput=model_input,
outputDataConfig={
"s3OutputDataConfig": {
"s3Uri": "s3://&example-s3-destination-bucket;"
}
}
)
# Print the response JSON
print("Response:")
print(json.dumps(invocation, indent=2, default=str))
except Exception as e:
# Implement error handling here.
message = e.response["Error"]["Message"]
print(f"Error: {message}")
```
------
# TwelveLabs Marengo Embed 3.0
Das TwelveLabs Marengo Embed 3.0 Modell generiert verbesserte Einbettungen aus Video-, Text-, Audio- oder Bildeingaben. Diese neueste Version bietet verbesserte Leistung und Genauigkeit für Ähnlichkeitssuche, Clustering und andere Aufgaben des maschinellen Lernens.
+ Anbieter – TwelveLabs
+ Model ID: – twelvelabs.marengo-embed-3-0-v1:0
Marengo Embed 3.0 bietet mehrere wichtige Verbesserungen:
+ **Erweiterte Videoverarbeitungskapazität** — Verarbeiten Sie bis zu 4 Stunden Video- und Audioinhalte. Dateien können bis zu 6 GB groß sein, was der doppelten Kapazität früherer Versionen entspricht. Dadurch eignet es sich ideal für die Analyse kompletter Sportveranstaltungen, umfangreicher Trainingsvideos und kompletter Filmproduktionen.
+ **Verbesserte Sportanalyse** — Das Modell bietet erhebliche Verbesserungen. Es ermöglicht ein besseres Verständnis der Spieldynamik, der Spielerbewegungen und der Erkennung von Ereignissen.
+ **Weltweiter mehrsprachiger Support** — Erweiterte Sprachfunktionen von 12 auf 36 Sprachen. Dies ermöglicht es globalen Unternehmen, einheitliche Such- und Abrufsysteme aufzubauen, die in verschiedenen Regionen und Märkten reibungslos funktionieren.
+ **Multimodale Suchgenauigkeit** — Kombinieren Sie Bilder und beschreibenden Text in einer einzigen Einbettungsanfrage. Dadurch wird visuelle Ähnlichkeit mit semantischem Verständnis kombiniert, um genauere und kontextrelevantere Suchergebnisse zu erzielen.
+ **Reduzierte Einbettungsgröße** — Von 1024 auf 512 reduziert, was zur Senkung der Speicherkosten beitragen kann.
Das Modell TwelveLabs Marengo Embed 3.0 unterstützt die Laufzeitoperationen von Amazon Bedrock in der folgenden Tabelle.
+ Weitere Informationen zu den Anwendungsfällen für verschiedene API-Methoden finden Sie unter [Hier erfahren Sie mehr über Anwendungsfälle für verschiedene ModellinferenzmethodenVerschiedene Inferenzmethoden](inference-methods.md).
+ Weitere Informationen zu den Modelltypen finden Sie unter [So funktioniert Inferenz in Amazon BedrockFunktionsweise der Inferenz](inference-how.md).
+ Eine Liste der Modelle IDs und die unterstützten Modelle und AWS Regionen finden Sie in der Tabelle unter[Unterstützte Basismodelle in Amazon Bedrock](models-supported.md). TwelveLabs Marengo Embed 3.0
+ Eine vollständige Liste der Inferenzprofile finden Sie IDs unter[Unterstützte Regionen und Modelle für Inferenzprofile](inference-profiles-support.md). Die ID des Inferenzprofils basiert auf der AWS Region.
****
| API-Operation | Unterstützte Modelltypen | Eingabemodalitäten | Ausgabemodalitäten |
| --- | --- | --- | --- |
| InvokeModel | USA Ost (Nord-Virginia) — [Basismodelle](models-supported.md) und [Inferenzprofile](inference-profiles-support.md) Europa (Irland) — [Inferenzprofile](inference-profiles-support.md) Asien-Pazifik (Seoul) - [Basismodelle](models-supported.md) | Text Image **Hinweis:** Die Verschachtelung von Text und Bild wird ebenfalls unterstützt. | Einbettung |
| StartAsyncInvoke | [Basismodelle](models-supported.md) | Video Audio Image Text **Hinweis:** Die Verschachtelung von Text und Bild wird ebenfalls unterstützt. | Einbettung |
**Anmerkung**
Verwenden Sie `InvokeModel`, um Einbettungen für Suchabfragen zu generieren. Verwenden Sie `StartAsyncInvoke`, um Einbettungen für Assets in großem Umfang zu generieren.
Die folgenden Kontingente gelten für die Eingabe:
****
| Eingabemodalität | Maximum |
| --- | --- |
| Text | 500 Tokens |
| Image | 5 MB pro Bild |
| Video (S3) | 6 GB, Länge 4 Stunden |
| Audio (S3) | 6 GB, Länge 4 Stunden |
**Anmerkung**
Wenn Sie Audio oder Video inline mithilfe der base64-Kodierung definieren, stellen Sie sicher, dass die Nutzdaten des Anforderungstexts das Amazon-Bedrock-Modellaufrufkontingent von 25 MB nicht überschreitet.
**Topics**
+ [Anforderungsparameter von TwelveLabs Marengo Embed 3.0](#model-parameters-marengo-3-async-request)
+ [TwelveLabs Marengo Embed 3.0-Antwort](#model-parameters-marengo-3-response)
+ [TwelveLabs Marengo Embed 3.0-Codebeispiele](#model-parameters-marengo-3-examples)
## Anforderungsparameter von TwelveLabs Marengo Embed 3.0
Wenn Sie eine Anforderung stellen, hängt das Feld, in dem die modellspezifische Eingabe angegeben wird, von der API-Operation ab:
+ [InvokeModel](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModel.html)— In der Anfrage`body`.
+ [StartAsyncInvoke](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_StartAsyncInvoke.html)— Im `modelInput` Feld des Hauptteils der Anfrage.
Das Format der Modelleingabe hängt von der Eingabemodalität ab:
------
#### [ Text ]
```
{
"inputType": "text",
"text": {
"inputText": "string"
}
}
```
------
#### [ Image ]
```
{
"inputType": "image",
"image": {
"mediaSource": {
"base64String": "base64-encoded string", // base64String OR s3Location, exactly one
"s3Location": {
"uri": "s3://amzn-s3-demo-bucket/folder/dog.jpg",
"bucketOwner": "123456789012"
}
}
}
}
```
------
#### [ Text & image ]
```
{
"inputType": "text_image",
"text_image": {
"inputText": "man walking a dog",
"mediaSource": {
"base64String": "base64-encoded string", // base64String OR s3Location, exactly one
"s3Location": {
"uri": "s3://amzn-s3-demo-bucket/folder/dog.jpg",
"bucketOwner": "123456789012"
}
}
}
}
```
------
#### [ Audio ]
```
{
"inputType": "audio",
"audio": {
"mediaSource": {
"base64String": "base64-encoded string", // base64String OR s3Location, exactly one
"s3Location": {
"uri": "s3://amzn-s3-demo-bucket/audio/a.wav",
"bucketOwner": "123456789012"
}
},
"startSec": 0,
"endSec": 6,
"segmentation": {
"method": "fixed",
"fixed": {
"durationSec": 6
}
},
"embeddingOption": [
"audio",
"transcription"
], // optional, default=both
"embeddingScope": [
"clip",
"asset"
] // optional, one or both
}
}
```
------
#### [ Video ]
```
{
"inputType": "video",
"video": {
"mediaSource": {
"base64String": "base64-encoded string", // base64String OR s3Location, exactly one
"s3Location": {
"uri": "s3://amzn-s3-demo-bucket/video/clip.mp4",
"bucketOwner": "123456789012"
}
},
"startSec": 0,
"endSec": 6,
"segmentation": {
"method": "dynamic", // dynamic OR fixed, exactly one
"dynamic": {
"minDurationSec": 4
}
"method": "fixed",
"fixed": {
"durationSec": 6
}
},
"embeddingOption": [
"visual",
"audio",
"transcription"
], // optional, default=all
"embeddingScope": [
"clip",
"asset"
] // optional, one or both
},
"inferenceId": "some inference id"
}
```
------
Erweitern Sie die folgenden Abschnitte, um ausführliche Informationen zu den Eingabeparametern zu erhalten:
### inputType
Modalität für die Einbettung
+ **Typ:** Zeichenfolge
+ **Erforderlich**: Ja
+ **Zulässige Werte**: `text` \$1 `image` \$1 `text_image` \$1 `audio` \$1 `video`
### inputText
Text, der eingebettet werden soll
+ **Typ:** Zeichenfolge
+ **Erforderlich:** Ja (für kompatible Eingabetypen)
+ **Kompatible Eingabetypen:** Text
### mediaSource
Enthält Informationen zur Medienquelle
+ **Typ:** Objekt
+ **Erforderlich:** Ja (falls kompatibler Typ)
+ **Kompatible Eingabetypen:** Bild, Video, Audio
Das Format des `mediaSource`-Objekts im Anforderungstext hängt davon ab, ob das Medium als Base64-kodierte Zeichenfolge oder als S3-Speicherort definiert ist.
+ **Base64-kodierte Zeichenfolge**
```
{
"mediaSource": {
"base64String": "base64-encoded string"
}
}
```
+ `base64String` – Die Base64-kodierte Zeichenfolge für das Medium
+ **S3-Standort** — Geben Sie den S3-URI und den Bucket-Besitzer an.
```
{
"s3Location": {
"uri": "string",
"bucketOwner": "string"
}
}
```
+ `uri` – Der S3-URI, der das Medium enthält
+ `bucketOwner`— Die AWS Konto-ID des S3-Bucket-Besitzers.
### embeddingOption
Gibt an, welche Arten von Einbettungen abgerufen werden sollen.
+ **Typ**: Liste
+ **Required**: No
+ **Gültige Werte für Listenmitglieder:**
+ `visual`— Visuelle Einbettungen aus dem Video.
+ `audio` – Einbettungen des Audios in das Video
+ `transcription`— Einbettungen des transkribierten Textes.
+ **Vorgabewert:**
+ Video: ["visuell“, „Audio“, „Transkription"]
+ Audio: ["Audio“, „Transkription"]
+ **Kompatible Eingabetypen:** Video, Audio
### Geltungsbereich einbetten
Gibt den Bereich der abzurufenden Einbettungen an.
+ **Typ**: Liste
+ **Required**: No
+ **Gültige Werte für Listenmitglieder:**
+ `clip`— Gibt Einbettungen für jeden Clip zurück.
+ `asset`— Gibt Einbettungen für das gesamte Asset zurück.
+ **Kompatible Eingabetypen:** Video, Audio
### startSec
Der Zeitpunkt in Sekunden des Clips, zu dem die Verarbeitung beginnen soll
+ **Type**: Double
+ **Required**: No
+ **Mindestwert** 0
+ **Standardwert**: 0
+ **Kompatible Eingabetypen:** Video, Audio
### endSec
Der Zeitpunkt in Sekunden, zu dem die Verarbeitung enden soll.
+ **Type**: Double
+ **Required**: No
+ **Mindestwert:** StartSec \$1 Segmentlänge
+ **Höchstwert:** Dauer des Mediums
+ **Standardwert:** Dauer des Mediums
+ **Kompatible Eingabetypen:** Video, Audio
### Segmentierung
Definiert, wie die Medien für die Generierung der Einbettung in Segmente unterteilt werden.
+ **Typ:** Objekt
+ **Required**: No
+ **Kompatible Eingabetypen:** Video, Audio
Das Segmentierungsobjekt enthält ein `method` Feld und methodenspezifische Parameter:
+ `method`— Die zu verwendende Segmentierungsmethode. Zulässige Werte: `dynamic` \$1 `fixed`
+ `dynamic`— Nutzt bei Videos die Erkennung von Aufnahmegrenzen, um Inhalte dynamisch zu unterteilen. Enthält:
+ `minDurationSec`— Mindestdauer für jedes Segment in Sekunden. Typ: Ganzzahl. Bereich: 1-5. Standard: 4.
+ `fixed`— Unterteilt den Inhalt in Segmente gleicher Dauer. Enthält:
+ `durationSec`— Dauer jedes Segments in Sekunden. Typ: Ganzzahl. Bereich: 1-10. Standard: 6.
**Standardverhalten:**
+ Video: Verwendet dynamische Segmentierung mit Erkennung von Schussgrenzen.
+ Audio: Verwendet eine feste Segmentierung. Der Inhalt wird so gleichmäßig wie möglich mit Segmenten von fast 10 Sekunden aufgeteilt.
### Inferenz-ID
Eindeutiger Bezeichner für die Inferenzanforderung.
+ **Typ:** Zeichenfolge
+ **Required**: No
## TwelveLabs Marengo Embed 3.0-Antwort
Der Speicherort der Ausgabeeinbettungen und der zugehörigen Metadaten hängt von der Aufrufmethode ab:
+ InvokeModel — Im Antworttext.
+ StartAsyncInvoke — In dem in definierten S3-Bucket`s3OutputDataConfig`, nachdem der asynchrone Aufruf-Job abgeschlossen wurde.
Wenn es mehrere Einbettungsvektoren gibt, besteht die Ausgabe aus einer Liste von Objekten, die jeweils einen Vektor und die zugehörigen Metadaten enthalten.
Das Format des Einbettungsvektors der Ausgabe lautet wie folgt:
```
{
"data": {
"embedding": [
0.111, 0.234, ...
],
"embeddingOption": ["visual", "audio", "transcription" (for video input) | "audio", "transcription" (for audio input)],
"embeddingScope": ["asset" | "clip"],
"startSec": 0,
"endSec": 4.2
}
}
```
Die Einbettungen werden als Array von Floats zurückgegeben.
Wo Sie diese Antwort sehen, hängt von der verwendeten API-Methode ab:
+ InvokeModel — Erscheint im Antworttext.
+ StartAsyncInvoke — Erscheint an dem S3-Standort, den Sie in der Anfrage angegeben haben. Die Antwort gibt eine zurück`invocationArn`. Sie können dies verwenden, um Metadaten über den asynchronen Aufruf abzurufen. Dazu gehören der Status und der S3-Speicherort, an den die Ergebnisse geschrieben werden.
Erweitern Sie die folgenden Abschnitte, um ausführliche Informationen zu den Antwortparametern zu erhalten:
### embedding
Darstellung des Einbettungsvektors der Eingabe
+ **Typ**: Liste von Double-Werten
### embeddingOption
Die Art der Einbettungen
+ **Typ:** Zeichenfolge
+ **Mögliche Werte:**
+ visuell — Visuelle Einbettungen aus dem Video.
+ Audio — Einbettungen des Audios in das Video.
+ Transkription — Einbettungen des transkribierten Textes.
+ **Kompatible Eingabetypen:** Video, Audio
### Umfang einbetten
Gibt den Bereich der abzurufenden Einbettungen an.
+ **Typ:** Zeichenfolge
Sie können einen oder mehrere der folgenden Werte angeben:
+ Clip: Gibt Einbettungen für jeden Clip zurück.
+ Asset: Gibt Einbettungen für das gesamte Asset zurück.
### startSec
Der Startversatz des Clips
+ **Type**: Double
+ **Kompatible Eingabetypen:** Video, Audio
### endSec
Der Endversatz des Clips. Gilt nicht für Text-, Bild- und Text\$1Image-Einbettungen.
+ **Type**: Double
+ **Kompatible Eingabetypen:** Video, Audio
## TwelveLabs Marengo Embed 3.0-Codebeispiele
In diesem Abschnitt wird gezeigt, wie Sie das Modell TwelveLabs Marengo Embed 3.0 mit verschiedenen Eingabetypen mithilfe von Python verwenden. Die Beispiele zeigen, wie modellspezifische Eingaben definiert und Modellaufrufe ausgeführt werden.
**Anmerkung**
InvokeModel unterstützt Text, Bild und Text mit verschachtelter Bildeingabe. Verwenden Sie für die Video- und Audioeingabe. StartAsyncInvoke
Stellen Sie Ihren Code in den folgenden Schritten zusammen:
**1. Definieren der modellspezifische Eingabe**
Definieren Sie die modellspezifische Eingabe abhängig von Ihrem Eingabetyp:
------
#### [ Text ]
```
# Create the model-specific input
model_id = "twelvelabs.marengo-embed-3-0-v1:0"
# Replace the us prefix depending on your region
inference_profile_id = "us.twelvelabs.marengo-embed-3-0-v1:0"
model_input = {
"inputType": "text",
"text": {
"inputText": "man walking a dog"
}
}
```
------
#### [ Image ]
```
# Create the model-specific input
model_id = "twelvelabs.marengo-embed-3-0-v1:0"
# Replace the us prefix depending on your region
inference_profile_id = "us.twelvelabs.marengo-embed-3-0-v1:0"
model_input = {
"inputType": "image",
"image": {
"mediaSource": {
"s3Location": {
"uri": "s3://amzn-s3-demo-bucket/my_image.png",
"bucketOwner": "123456789012"
}
}
}
}
```
------
#### [ Text & image ]
```
# Create the model-specific input
model_id = "twelvelabs.marengo-embed-3-0-v1:0"
# Replace the us prefix depending on your region
inference_profile_id = "us.twelvelabs.marengo-embed-3-0-v1:0"
model_input = {
"inputType": "text_image",
"text_image": {
"inputText": "man walking a dog",
"mediaSource": {
"s3Location": {
"uri": "s3://amzn-s3-demo-bucket/my_image.jpg",
"bucketOwner": "123456789012"
}
}
}
}
```
------
#### [ Audio ]
```
# Create the model-specific input
model_id = "twelvelabs.marengo-embed-3-0-v1:0"
# Replace the us prefix depending on your region
inference_profile_id = "us.twelvelabs.marengo-embed-3-0-v1:0"
model_input = {
"inputType": "audio",
"audio": {
"mediaSource": {
"s3Location": {
"uri": "s3://amzn-s3-demo-bucket/my-audio.wav",
"bucketOwner": "123456789012"
}
},
"startSec": 0,
"endSec": 5,
"segmentation": {
"method": "fixed",
"fixed": {
"durationSec": 5
}
},
"embeddingScope": ["clip", "asset"],
"embeddingOption": ["audio"]
}
}
```
------
#### [ Video ]
```
# Create the model-specific input
model_id = "twelvelabs.marengo-embed-3-0-v1:0"
# Replace the us prefix depending on your region
inference_profile_id = "us.twelvelabs.marengo-embed-3-0-v1:0"
model_input = {
"inputType": "video",
"video": {
"mediaSource": {
"s3Location": {
"uri": "s3://amzn-s3-demo-bucket/my-video.mp4",
"bucketOwner": "123456789012"
}
},
"startSec": 10,
"endSec": 20,
"segmentation": {
"method": "fixed",
"fixed": {
"durationSec": 5
}
},
"embeddingOption": [
"visual",
"audio"
],
"embeddingScope": [
"clip",
"asset"
]
}
}
```
------
**2. Ausführen des Modellaufrufs mithilfe der Modelleingabe**
Fügen Sie dann den Codeausschnitt hinzu, der der Methode Ihrer Wahl für den Modellaufruf entspricht.
------
#### [ InvokeModel ]
```
# Run model invocation with InvokeModel
import boto3
import json
# Initialize the Bedrock Runtime client
client = boto3.client('bedrock-runtime')
# Make the request
response = client.invoke_model(
modelId=inference_profile_id,
body=json.dumps(model_input)
)
# Print the response body
response_body = json.loads(response['body'].read().decode('utf-8'))
print(response_body)
```
------
#### [ StartAsyncInvoke ]
```
# Run model invocation asynchronously
import boto3
import json
# Initalize the Bedrock Runtime client.
client = boto3.client("bedrock-runtime")
try:
# Start the asynchronous job
invocation = client.start_async_invoke(
modelId=model_id,
modelInput=model_input,
outputDataConfig={
"s3OutputDataConfig": {
"s3Uri": "s3://amzn-s3-demo-bucket"
}
}
)
# Print the response JSON
print("Response:")
print(json.dumps(invocation, indent=2, default=str))
except Exception as e:
# Implement error handling here.
message = e.response["Error"]["Message"]
print(f"Error: {message}")
```
------
# Modelle von Writer AI Palmyra
In diesem Abschnitt werden die Anforderungsparameter und Antwortfelder für Modelle von Writer AI beschrieben. Verwenden Sie diese Informationen, um mit den (Streaming-) Operationen [InvokeModel](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModel.html) und [InvokeModelWithResponseStream](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModelWithResponseStream.html) Inferenzaufrufe an Modelle von Writer AI durchzuführen. Dieser Abschnitt enthält auch Python-Codebeispiele, die zeigen, wie Modelle von Writer AI aufgerufen werden. Sie benötigen die Modell-ID für das Modell, um ein Modell in einer Inferenzoperation verwenden zu können. Informationen zum Abrufen der Modell-ID finden Sie unter [Unterstützte Basismodelle in Amazon Bedrock](models-supported.md). Einige Modelle funktionieren auch mit der [Converse-API](conversation-inference.md). Informationen darüber, ob die Converse-API ein bestimmtes Modell von Writer AI unterstützt, finden Sie unter [Unterstützte Modelle und Modellfeatures](conversation-inference-supported-models-features.md). Weitere Codebeispiele finden Sie unter [Codebeispiele für Amazon Bedrock mit AWS SDKs](service_code_examples.md).
Basismodelle in Amazon Bedrock unterstützen Eingabe- und Ausgabemodalitäten, die von Modell zu Modell variieren. Informationen zu den Modalitäten, die von Modellen von Writer AI unterstützt werden, finden Sie unter [Unterstützte Basismodelle in Amazon Bedrock](models-supported.md). Informationen darüber, welche Amazon-Bedrock-Features die Modelle von Writer AI unterstützen, finden Sie unter [Unterstützte Basismodelle in Amazon Bedrock](models-supported.md). Informationen darüber, in welchen AWS-Regionen diese Modelle von Writer AI verfügbar sind, finden Sie unter [Unterstützte Basismodelle in Amazon Bedrock](models-supported.md).
Wenn Sie Inferenzaufrufe mit Modellen von Writer AI tätigen, schließen Sie einen Prompt für das Modell ein. Allgemeine Informationen zum Erstellen von Prompts für die Modelle, die von Amazon Bedrock unterstützt werden, finden Sie unter [Prompt-Engineering-Konzepte](prompt-engineering-guidelines.md). Für Writer AI spezifische Informationen zu Prompts finden Sie im [Handbuch zu Prompt-Engineering von Writer AI]().
**Writer Palmyra X4**
Writer Palmyra X4, das bei Stanford HELM an erster Stelle steht, erzielt überragende Leistungen bei komplexen Aufgaben und agentenbasierten Workflows. Es kombiniert ein Kontextfenster von 128 000 Token mit einer Reihe von Funktionen auf Unternehmensniveau, darunter erweitertes Reasoning, Tool-Aufruf, LLM-Delegierung, integriertes RAG, Codegenerierung, strukturierte Ausgaben, Multimodalität und mehrsprachige Unterstützung. Mithilfe unternehmensspezifischer Tools, die die Handlungsfähigkeit des Modells erweitern, können Entwickler mit Palmyra X4 Apps und Agenten erstellen, die das System aktualisieren, Transaktionen durchführen, E-Mails senden, Workflows auslösen und vieles mehr.
**Writer Palmyra X5**
Mit einem Kontextfenster von einer Million Token markiert Writer Palmyra X5 das Ende der Kontextbeschränkungen für die App- und Agentenentwicklung. Das neueste Modell von Writer bietet dank erweiterter Speicher- und Rechenleistung eine überragende Leistung bei langen Kontextinferenzen, sodass Entwickler komplexere, mehrstufige agentenbasierte Workflows schneller erstellen können. Wie Palmyra X4 umfasst auch Palmyra X5 eine Reihe von unternehmenstauglichen Funktionen, darunter erweitertes Reasoning, Tool-Aufruf, LLM-Delegierung, integriertes RAG, Codegenerierung, strukturierte Ausgaben, Multimodalität und mehrsprachige Unterstützung.
**Topics**
+ [Writer Palmyra X4](model-parameters-palmyra-x4.md)
+ [Writer Palmyra X5](model-parameters-palmyra-x5.md)
# Writer Palmyra X4
Writer Palmyra X4 ist ein Modell mit einem Kontextfenster von bis zu 128 000 Token. Dieses Modell zeichnet sich durch die Verarbeitung und das Verständnis komplexer Aufgaben aus und eignet sich daher ideal für Workflow-Automatisierung, Codierungsaufgaben und Datenanalyse.
+ Anbieter – Writer
+ Kategorien – Textgenerierung, Codegenerierung, Rich-Text-Formatierung
+ Letzte Version – V1
+ Veröffentlichungsdatum – 28. April 2025
+ Model ID: – `writer.palmyra-x4-v1:0`
+ Modalität – Text
+ Max. Token – Eingabe: 122 880 Token, Ausgabe: 8 192 Token
+ Sprache – Englisch, Spanisch, Französisch, Deutsch, Chinesisch und mehrere andere Sprachen
+ Bereitstellungstyp – Serverless
## Textfeld für die Palmyra-X4-Aufrufanforderung
Wenn Sie mit einem Writer-Modell einen [InvokeModel](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModel.html)- oder [InvokeModelWithResponseStream](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModelWithResponseStream.html)-Aufruf ausführen, füllen Sie das `body`-Feld mit einem JSON-Objekt aus, das dem unten stehenden entspricht. Geben Sie die Eingabeaufforderung in das Feld `text` im Objekt `text_prompts` ein.
```
{
"modelId": "writer.palmyra-x4-v1:0",
"contentType": "application/json",
"accept": "application/json",
"body": "{\"messages\":[{\"role\":\"user\",\"content\":{\"text\":\"Explain quantum computing in simple terms\"}}]}"
}
```
Die folgende Tabelle zeigt die minimalen, maximalen und standardmäßigen Werte für die numerischen Parameter.
****
| Parameter | Typ | Standard | Bereich/Validierung | Beschreibung |
| --- | --- | --- | --- | --- |
| messages | Array | Erforderlich | 1-∞ Elemente | Nachrichten im Chatverlauf |
| temperature | float | 1,0 | 0,0 ≤ x ≤ 2,0 | Sampling-Temperatur |
| top\$1p | float | 1,0 | 0,0 < Wert ≤ 1,0 | Nukleus-Sampling-Schwellenwert |
| max\$1tokens | int | 16 | 1 ≤ x ≤ 8 192 | Höchstzahl der zu generierenden Token |
| min\$1tokens | int | 0 | 0 ≤ x ≤ max\$1token | Mindestanzahl an Token vor dem Beenden |
| stop | Array | [] | ≤4 Einträge | Sequenzen beenden |
| Seed | int | Null | Beliebige Ganzzahl | Random Seed (Zufällige Seed) |
| presence\$1penalty | float | 0.0 | -2,0 ≤ x ≤ 2,0 | Neue Token-Präsenzstrafe |
| frequency\$1penalty | float | 0.0 | -2,0 ≤ x ≤ 2,0 | Token-Frequenzstrafe |
## Textfeld für die Palmyra-X4-Aufrufantwort
Die JSON-Antwort für Writer Palmyra X4 verwendet das folgende Format:
```
{
"id": "chatcmpl-a689a6e150b048ca8814890d3d904d41",
"object": "chat.completion",
"created": 1745854231,
"model": "writer.palmyra-x4-v1:0",
"choices": [
{
"index": 0,
"message": {
"role": "assistant",
"reasoning_content": null,
"content": "Quantum computing harnesses quantum mechanics to process information in extraordinarily powerful ways. Unlike classical bits, which are 0 or 1, quantum bits (qubits) can exist in multiple states simultaneously through superposition. Qubits also entangle, allowing them to be interconnected in such a way that the state of one (whether it's 0 or 1) can depend on the state of another, no matter the distance between them. This combination of superposition and entanglement enables quantum computers to solve complex problems much faster than classical computers, particularly in areas like cryptography, optimization, and simulations of molecular structures. However, quantum computing is still in its early stages, facing challenges in stability and scalability.",
"tool_calls": []
},
"logprobs": null,
"finish_reason": "stop",
"stop_reason": null
}
],
"usage": {
"prompt_tokens": 43,
"total_tokens": 186,
"completion_tokens": 143,
"prompt_tokens_details": null
},
"prompt_logprobs": null
}
```
## Writer Palmyra X4Beispiel-Code für
Beispielcode für Writer Palmyra X4:
```
import boto3
import json
from botocore.exceptions import ClientError
client = boto3.client("bedrock-runtime", region_name="us-west-2")
model_id = "writer.palmyra-x4-v1:0"
# Format the request payload using the model's native structure.
native_request = {
"temperature": 1,
"messages": [
{
"role": "user",
"content": "Explain quantum computing in simple terms.",
}
],
}
# Convert the native request to JSON.
request = json.dumps(native_request)
try:
# Invoke the model with the request.
response = client.invoke_model(modelId=model_id, body=request)
except (ClientError, Exception) as e:
print(f"ERROR: Can't invoke '{model_id}'. Reason: {e}")
exit(1)
# Decode the response body.
model_response = json.loads(response["body"].read())
# Extract and print the response text.
response_text = model_response["content"][0]["text"]
print(response_text)
```
# Writer Palmyra X5
Writer Palmyra X5 umfasst eine Reihe von unternehmenstauglichen Funktionen, darunter erweitertes Reasoning, Tool-Aufruf, LLM-Delegierung, integriertes RAG, Codegenerierung, strukturierte Ausgaben, Multimodalität und mehrsprachige Unterstützung.
Das Modell Writer Palmyra X5 verfügt über die folgenden Steuerelemente:
+ Anbieter – Writer
+ Kategorien – Textgenerierung, Codegenerierung, Rich-Text-Formatierung
+ Letzte Version – V1
+ Veröffentlichungsdatum – 28. April 2025
+ Model ID: – `writer.palmyra-x5-v1:0`
+ Modalität – Text
+ Max. Token – Eingabe: 1 040 000 Token, Ausgabe: 8 192 Token
+ Sprache – Englisch, Spanisch, Französisch, Deutsch, Chinesisch und mehrere andere Sprachen
+ Bereitstellungstyp – Serverless
## Textfeld für die Palmyra-X5-Aufrufanforderung
Wenn Sie mit einem Writer-Modell einen [InvokeModel](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModel.html)- oder [InvokeModelWithResponseStream](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModelWithResponseStream.html)-Aufruf ausführen, füllen Sie das `body`-Feld mit einem JSON-Objekt aus, das dem unten stehenden entspricht. Geben Sie die Eingabeaufforderung in das Feld `text` im Objekt `text_prompts` ein.
```
{
"modelId": "writer.palmyra-x5-v1:0",
"contentType": "application/json",
"accept": "application/json",
"body": "{\"messages\":[{\"role\":\"user\",\"content\":{\"text\":\"Explain quantum computing in simple terms\"}}]}"
}
```
Die folgende Tabelle zeigt die minimalen, maximalen und standardmäßigen Werte für die numerischen Parameter.
****
| Parameter | Typ | Standard | Bereich/Validierung | Beschreibung |
| --- | --- | --- | --- | --- |
| messages | Array | Erforderlich | 1-∞ Elemente | Nachrichten im Chatverlauf |
| temperature | float | 1,0 | 0,0 ≤ x ≤ 2,0 | Sampling-Temperatur |
| top\$1p | float | 1,0 | 0,0 < x ≤ 1,0 | Nukleus-Sampling-Schwellenwert |
| max\$1tokens | int | 16 | 1 ≤ x ≤ 8 192 | Höchstzahl der zu generierenden Token |
| min\$1tokens | int | 0 | 0 ≤ x ≤ max\$1token | Mindestanzahl an Token vor dem Beenden |
| stop | Array | [] | ≤4 Einträge | Sequenzen beenden |
| Seed | int | Null | Beliebige Ganzzahl | Random Seed (Zufällige Seed) |
| presence\$1penalty | float | 0.0 | -2,0 ≤ x ≤ 2,0 | Neue Token-Präsenzstrafe |
| frequency\$1penalty | float | 0.0 | -2,0 ≤ x ≤ 2,0 | Token-Frequenzstrafe |
## Textfeld für die Palmyra-X5-Aufrufantwort
Die JSON-Antwort für Writer Palmyra X5 verwendet das folgende Format:
```
{
"id": "chatcmpl-a689a6e150b048ca8814890d3d904d41",
"object": "chat.completion",
"created": 1745854231,
"model": "writer.palmyra-x5-v1:0",
"choices": [
{
"index": 0,
"message": {
"role": "assistant",
"reasoning_content": null,
"content": "Quantum computing harnesses quantum mechanics to process information in extraordinarily powerful ways. Unlike classical bits, which are 0 or 1, quantum bits (qubits) can exist in multiple states simultaneously through superposition. Qubits also entangle, allowing them to be interconnected in such a way that the state of one (whether it's 0 or 1) can depend on the state of another, no matter the distance between them. This combination of superposition and entanglement enables quantum computers to solve complex problems much faster than classical computers, particularly in areas like cryptography, optimization, and simulations of molecular structures. However, quantum computing is still in its early stages, facing challenges in stability and scalability.",
"tool_calls": []
},
"logprobs": null,
"finish_reason": "stop",
"stop_reason": null
}
],
"usage": {
"prompt_tokens": 43,
"total_tokens": 186,
"completion_tokens": 143,
"prompt_tokens_details": null
},
"prompt_logprobs": null
}
```