\n\nAssistant:",
"temperature": float,
"top_p": float,
"top_k": int,
"max_tokens_to_sample": int,
"stop_sequences": [string]
}
```
I seguenti sono parametri obbligatori.
+ **prompt**: (obbligatorio) il prompt che desideri venga completato da Claude. Per una corretta generazione di risposte, è necessario formattare il prompt utilizzando un’alternanza dei turni di conversazione `\n\nHuman:` e `\n\nAssistant:`. Ad esempio:
```
"\n\nHuman: {userQuestion}\n\nAssistant:"
```
Per ulteriori informazioni, consulta [Convalida dei prompt](https://docs.anthropic.com/claude/reference/prompt-validation) nella documentazione di Anthropic Claude.
+ **max\$1tokens\$1to\$1sample** (obbligatorio): numero massimo di token da generare prima dell’arresto. Consigliamo un limite di 4.000 token per prestazioni ottimali.
Tieni presente che i modelli Anthropic Claude potrebbero arrestare la generazione di token prima che sia raggiunto il valore `max_tokens_to_sample`. In modelli Anthropic Claude diversi i valori massimi per questo parametro sono differenti. Per ulteriori informazioni, consulta [Confronto dei modelli](https://docs.anthropic.com/claude/docs/models-overview#model-comparison) nella documentazione di Anthropic Claude.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/bedrock/latest/userguide/model-parameters-anthropic-claude-text-completion.html)
I seguenti sono parametri opzionali.
+ **stop\$1sequences** (facoltativo): le sequenze che causano l’arresto della generazione da parte del modello.
I modelli Anthropic Claude si arrestano su `"\n\nHuman:"` e in futuro potrebbero includere ulteriori sequenze di arresto integrate. Utilizza il parametro di inferenza `stop_sequences` per includere stringhe aggiuntive che segnaleranno al modello di arrestare la generazione di testo.
+ **temperature** (facoltativo): quantità di randomizzazione inserita nella risposta. Utilizza un valore più vicino a 0 per le attività analitiche/a scelta multipla e un valore più vicino a 1 per le attività creative e generative.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/bedrock/latest/userguide/model-parameters-anthropic-claude-text-completion.html)
+ **top\$1p** (facoltativo): utilizza il metodo “nucleus sampling”.
Nel metodo “nucleus sampling”, Anthropic Claude calcola la distribuzione cumulativa di tutte le opzioni per ogni token successivo in ordine di probabilità decrescente e la interrompe quando raggiunge un particolare valore specificato da `top_p`. Devi modificare un solo valore tra `temperature` o `top_p`, non entrambi.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/bedrock/latest/userguide/model-parameters-anthropic-claude-text-completion.html)
+ **top\$1k** (facoltativo): campionamento eseguito solo dalle opzioni top K per ogni token successivo.
Utilizza `top_k` per rimuovere le risposte long tail a bassa probabilità.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/bedrock/latest/userguide/model-parameters-anthropic-claude-text-completion.html)
------
#### [ Response ]
Il modello Anthropic Claude restituisce i seguenti campi per effettuare chiamate di inferenza per il completamento di testo.
```
{
"completion": string,
"stop_reason": string,
"stop": string
}
```
+ **completion**: il completamento risultante fino all’esclusione delle sequenze di arresto.
+ **stop\$1reason**: il motivo per cui il modello ha smesso di generare la risposta.
+ **"stop\$1sequence"**: il modello ha raggiunto una sequenza di arresto, fornita dall’utente con il parametro di inferenza `stop_sequences` o integrata nel modello.
+ **"max\$1tokens"**: il modello ha superato il valore `max_tokens_to_sample` o il numero massimo di token del modello.
+ **stop**: se specifichi il parametro di inferenza `stop_sequences`, `stop` contiene la sequenza di arresto che ha segnalato al modello di arrestare la generazione di testo. Ad esempio, `holes` nella risposta seguente.
```
{
"completion": " Here is a simple explanation of black ",
"stop_reason": "stop_sequence",
"stop": "holes"
}
```
Se non specifichi `stop_sequences`, il valore predefinito per `stop` è vuoto.
------
## esempio di codice
Questi esempi mostrano come chiamare il modello *Anthropic Claude V2* con un throughput on demand. Per utilizzare Anthropic Claude versione 2.1, modifica il valore di `modelId` in `anthropic.claude-v2:1`.
```
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'))
```
L'esempio seguente mostra come generare testo in streaming con Python utilizzando il prompt *write an essay for living on mars in 1000 words* (scrivi un saggio di 1000 parole su come poter vivere di Marte) e il modello Anthropic Claude V2:
```
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()))
```
# API Messages di Anthropic Claude
Questa sezione fornisce parametri di inferenza ed esempi di codice per l’utilizzo dell’API Messages di Anthropic Claude.
**Topics**
+ [Panoramica dell’API Messages di Anthropic Claude](#model-parameters-anthropic-claude-messages-overview)
+ [Utilizzo degli strumenti](model-parameters-anthropic-claude-messages-tool-use.md)
+ [Pensiero esteso](claude-messages-extended-thinking.md)
+ [Pensiero adattivo](claude-messages-adaptive-thinking.md)
+ [Crittografia Thinking](claude-messages-thinking-encryption.md)
+ [Differenze di pensiero tra le versioni del modello](claude-messages-thinking-differences.md)
+ [Compattazione](claude-messages-compaction.md)
+ [Ottieni risultati JSON convalidati dai modelli](claude-messages-structured-outputs.md)
+ [Richiesta e risposta](model-parameters-anthropic-claude-messages-request-response.md)
+ [Esempi di codice](api-inference-examples-claude-messages-code-examples.md)
+ [Modelli supportati](claude-messages-supported-models.md)
## Panoramica dell’API Messages di Anthropic Claude
Puoi utilizzare l’API Messages per creare chatbot o applicazioni di assistente virtuale. L’API gestisce gli scambi conversazionali tra l’utente e un modello Anthropic Claude (assistente).
**Nota**
Questo argomento mostra come utilizzare l'API dei Anthropic Claude messaggi con le operazioni di inferenza di base ([InvokeModel](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModel.html)or [InvokeModelWithResponseStream](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModelWithResponseStream.html)). Tuttavia, ti consigliamo di utilizzare l’API Converse per implementare i messaggi nell’applicazione. L’API Converse fornisce un set unificato di parametri che funzionano su tutti i modelli che supportano i messaggi. Per ulteriori informazioni, consulta [Avvio di una conversazione con le operazioni dell’API Converse](conversation-inference.md).
Le restrizioni si applicano alle seguenti operazioni:`InvokeModel`, `InvokeModelWithResponseStream``Converse`, e`ConverseStream`. Per i dettagli, consulta [Restrizioni API](inference-api-restrictions.md).
I modelli Claude sono addestrati da Anthropic in modo da operare su turni di conversazione alternati tra utente e assistente. Quando crei un nuovo messaggio, i turni di conversazione precedenti vengono specificati con il parametro messages. Il modello genera quindi il messaggio successivo nella conversazione.
Ogni messaggio di input deve essere un oggetto con un ruolo e un contenuto. È possibile specificare un singolo messaggio con il ruolo di utente oppure includere più messaggi con i ruoli di utente e assistente.
Se stai utilizzando la tecnica di precompilazione della risposta da Claude (inserendo l’inizio della risposta di Claude utilizzando un messaggio finale con ruolo di assistente), Claude risponde riprendendo da dove avevi interrotto. Con questa tecnica, Claude restituisce comunque una risposta con il ruolo di assistente.
Se il messaggio finale utilizza il ruolo di assistente, il contenuto della risposta riprende immediatamente dal contenuto di tale messaggio. Puoi utilizzarlo per vincolare parte della risposta del modello.
Esempio con un singolo messaggio utente:
```
[{"role": "user", "content": "Hello, Claude"}]
```
Esempio con più turni di conversazione:
```
[
{"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?"},
]
```
Esempio con una risposta parzialmente compilata da Claude:
```
[
{"role": "user", "content": "Please describe yourself using only JSON"},
{"role": "assistant", "content": "Here is my JSON description:\n{"},
]
```
Il contenuto di ogni messaggio di input può essere una singola stringa o un array di blocchi di contenuto, in cui ogni blocco ha un tipo specifico. Utilizzare una stringa è una scorciatoia per un array di un solo blocco di contenuto di tipo “text”. I seguenti messaggi di input sono equivalenti:
```
{"role": "user", "content": "Hello, Claude"}
```
```
{"role": "user", "content": [{"type": "text", "text": "Hello, Claude"}]}
```
Per informazioni sulla creazione di prompt per i modelli Anthropic Claude, consulta [Panoramica dell’ingegneria dei prompt](https://docs.anthropic.com/claude/docs/intro-to-prompting) nella documentazione di Anthropic Claude. Se disponi già di prompt di [Text Completions](model-parameters-anthropic-claude-text-completion.md) che vuoi migrare all’API Messages, consulta [Lavorare con l’API Messages](https://docs.anthropic.com/claude/reference/migrating-from-text-completions-to-messages).
**Importante**
Il periodo di timeout per le chiamate di inferenza ad Anthropic Claude 3.7 Sonnet e Claude 4 è 60 minuti. Per impostazione predefinita, i client AWS SDK scadono dopo 1 minuto. Ti consigliamo di aumentare il periodo di timeout di lettura del tuo client AWS SDK ad almeno 60 minuti. Ad esempio, per l’ AWS SDK per Python botocore, modifica il valore del campo `read_timeout` in [botocore.config](https://botocore.amazonaws.com/v1/documentation/api/latest/reference/config.html#) ad almeno 3.600.
### Prompt di sistema
Puoi anche includere un prompt di sistema nella richiesta. Un prompt di sistema ti permette di fornire contesto e istruzioni ad Anthropic Claude, ad esempio specificare un obiettivo o un ruolo particolare. Specifica un prompt di sistema nel campo `system`, come mostrato nell’esempio seguente.
```
"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."
```
Per ulteriori informazioni, consulta [Dare un ruolo a Claude con un system prompt](https://docs.anthropic.com/en/docs/system-prompts) nella documentazione di Anthropic.
### Prompt multimodali
Un prompt multimodale combina più modalità (immagini e testo) in un unico prompt. Le modalità vengono specificate nel campo di input `content`. L’esempio seguente mostra come si potrebbe chiedere ad Anthropic Claude di descrivere il contenuto di un’immagine fornita. Per il codice di esempio, consulta [Esempi di codice multimodale](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?"
}
]
}
]
}
```
Ogni immagine che includi in una richiesta viene conteggiata ai fini dell’utilizzo dei token. Per ulteriori informazioni, consulta [Calcola i costi delle immagini](https://docs.anthropic.com/claude/docs/vision#image-costs) nella documentazione di Anthropic.
# Utilizzo degli strumenti
**avvertimento**
Come indicato, molte delle funzioni che seguono sono disponibili in versione beta. Queste funzionalità sono rese disponibili all'utente come «Servizio Beta», come definito nei Termini AWS di servizio. È soggetto al Contratto AWS e ai Termini di AWS servizio dell'utente e al modello di EULA applicabile.
Con i modelli Anthropic Claude, è possibile specificare uno strumento che il modello può utilizzare per rispondere a un messaggio. Ad esempio, è possibile specificare uno strumento che riproduca il brano più popolare su una stazione radio. Se l’utente trasmette il messaggio *Qual è il brano più popolare su WZPZ?*, il modello determina che lo strumento specificato può aiutare a rispondere alla domanda. Nella sua risposta, il modello richiede l’esecuzione dello strumento per suo conto. Quindi esegui lo strumento e passa il risultato dello strumento al modello, che a sua volta genera una risposta per il messaggio originale. Per ulteriori informazioni, consulta [Utilizzo dello strumento (chiamata della funzione)](https://docs.anthropic.com/en/docs/tool-use) nella documentazione Anthropic Claude.
**Suggerimento**
È consigliabile utilizzare l’API Converse per integrare l’utilizzo dello strumento nella propria applicazione. Per ulteriori informazioni, consulta [Utilizzo di uno strumento per completare una risposta al modello Amazon Bedrock](tool-use.md).
**Importante**
Claude Sonnet 4.5 ora conserva la formattazione intenzionale nei parametri delle stringhe di chiamata dello strumento. In precedenza, le nuove righe finali nei parametri delle stringhe venivano talvolta rimosse erroneamente. Questa correzione garantisce che gli strumenti che richiedono una formattazione precisa (come gli editor di testo) ricevano i parametri esattamente come previsto. Si tratta di un behind-the-scenes miglioramento che non richiede modifiche all'API. Tuttavia, gli strumenti con parametri di stringa possono ora ricevere valori con nuove righe finali che in precedenza erano state rimosse.
**Nota**
Claude Sonnet 4.5 include ottimizzazioni automatiche per migliorare le prestazioni del modello. Queste ottimizzazioni possono aggiungere piccole quantità di token alle richieste, ma questi token aggiunti dal sistema non vengono fatturati.
Puoi specificare gli strumenti che vuoi rendere disponibili per un modello nel campo `tools`. L’esempio seguente è per uno strumento che riproduce i brani più popolari su una stazione radio.
```
[
{
"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"
]
}
}
]
```
Quando il modello necessita di uno strumento per generare una risposta a un messaggio, restituisce le informazioni sullo strumento richiesto e l’input allo strumento nel campo `content` del messaggio. Imposta inoltre il motivo dell’arresto della risposta a `tool_use`.
```
{
"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"
}
```
Nel codice, chiami lo strumento per conto degli strumenti. Quindi passa lo strumento result (`tool_result`) in un messaggio utente al modello.
```
{
"role": "user",
"content": [
{
"type": "tool_result",
"tool_use_id": "toolu_bdrk_01SnXQc6YVWD8Dom5jz7KhHy",
"content": "Elemental Hotel"
}
]
}
```
Nella sua risposta, il modello utilizza il risultato dello strumento per generare una risposta per il messaggio originale.
```
{
"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"
}
```
## Streaming granulare degli strumenti
Lo streaming granulare degli strumenti è una funzionalità del modello Anthropic Claude disponibile con Claude Sonnet 4.5, Claude Haiku 4.5, Claude Sonnet 4 e Claude Opus 4. Con lo streaming granulare degli strumenti, gli sviluppatori Claude possono trasmettere in streaming i parametri di utilizzo degli strumenti senza buffering o convalida JSON, riducendo la latenza necessaria per iniziare a ricevere parametri di grandi dimensioni.
**Nota**
Quando si utilizza lo streaming granulare degli strumenti, è possibile ricevere input JSON non validi o parziali. Assicurati di tenere conto di questi casi edge nel tuo codice.
Per utilizzare questa funzionalità, è sufficiente aggiungere l’intestazione `fine-grained-tool-streaming-2025-05-14` a una richiesta di utilizzo dello strumento.
Ecco un esempio di come specificare l’intestazione di streaming granulare dello strumento:
```
{
"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 questo esempio, lo streaming granulare dello strumento consente a Claude di trasmettere le righe di una lunga poesia nella chiamata allo strumento `make_file` senza buffering per verificare se il parametro `lines_of_text` è JSON valido. Ciò significa che è possibile visualizzare il flusso di parametri non appena arriva, senza dover attendere che l’intero parametro venga memorizzato nel buffer e convalidato.
Con lo streaming granulare dello strumento, i blocchi di utilizzo dello strumento iniziano a trasmettere più velocemente, sono spesso più lunghi e contengono meno interruzioni di parole. Ciò è dovuto alle differenze nel comportamento della suddivisione in blocchi.
Ad esempio, senza streaming granulare (ritardo di 15 secondi):
```
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'
...
```
Con streaming granulare (ritardo di 3 secondi):
```
Chunk 1: '{"query": "TypeScript 5.0 5.1 5.2 5.3'
Chunk 2: ' new features comparison'
```
**Nota**
Poiché lo streaming granulare invia i parametri senza buffering o convalida JSON, non è garantito che lo streaming risultante venga completato in una stringa JSON valida. In particolare, se viene raggiunto il motivo dell’arresto `max_tokens`, lo streaming potrebbe terminare a metà di un parametro e risultare incompleto. In genere è necessario scrivere un supporto specifico da gestire quando `max_tokens` viene raggiunto.
## Utilizzo del computer (Beta)
L’utilizzo del computer è una funzionalità del modello Anthropic Claude (in versione beta) disponibile con Claude 3.5 Sonnet v2, Claude Sonnet 4.5, Claude Haiku 4.5, Claude 3.7 Sonnet, Claude Sonnet 4 e Claude Opus 4. Con l’utilizzo del computer, Claude può aiutarti ad automatizzare le attività tramite azioni GUI di base.
**avvertimento**
La funzionalità di utilizzo del computer è resa disponibile all'utente come «Servizio beta», come definito nei Termini di AWS servizio. È soggetta al Contratto AWS e ai Termini di AWS servizio dell'utente e al modello di EULA applicabile. Tieni presente che l’API per l’utilizzo del computer comporta rischi unici che sono diversi dalle funzionalità API standard o dalle interfacce di chat. Questi rischi aumentano quando si utilizza l’API per l’utilizzo del compute per interagire con Internet. Per ridurre al minimo i rischi, prendi delle precauzioni come:
Esegui la funzionalità di utilizzo del computer in una macchina virtuale o in un container dedicato con privilegi minimi per prevenire attacchi diretti al sistema o incidenti.
Per prevenire il furto di informazioni, evita di concedere all’API di utilizzo del computer l’accesso ad account o dati sensibili.
Limitazione dell'uso dell'accesso a APIs Internet da parte del computer ai domini richiesti per ridurre l'esposizione a contenuti dannosi.
Per garantire un’adeguata supervisione, mantieni un intervento di tipo HITL per le attività sensibili (come prendere decisioni che potrebbero avere conseguenze significative nel mondo reale) e per qualsiasi attività che richieda un consenso esplicito (come accettare i cookie, eseguire transazioni finanziarie o accettare i termini di servizio).
Qualsiasi contenuto reso disponibile a Claude per la visualizzazione o l’accesso può interferire con le istruzioni, causando errori o l’esecuzione di azioni indesiderate da parte di Claude. Adottare le dovute precauzioni, ad esempio isolare Claude dalle superfici sensibili, è essenziale, anche per evitare i rischi legati all’iniezione di prompt tempestiva. Prima di abilitare o richiedere le autorizzazioni necessarie per attivare le funzionalità di utilizzo del computer nei tuoi prodotti, informa gli utenti finali di eventuali rischi pertinenti e ottieni il loro consenso, se appropriato.
L’API per l’utilizzo del computer mette a disposizione diversi strumenti predefiniti di utilizzo del computer. Puoi quindi creare un prompt con la tua richiesta, ad esempio “invia un’e-mail a Ben con le note della mia ultima riunione” e uno screenshot (quando richiesto). La risposta contiene un elenco di azioni `tool_use` in formato JSON (ad esempio, scroll\$1down, left\$1button\$1press, screenshot). Il codice esegue le azioni del computer e fornisce a Claude schermate che mostrano gli output (quando richiesto).
Dalla versione Claude 3.5 v2, il parametro tools è stato aggiornato per accettare tipi di strumenti polimorfici; è stata aggiunta una proprietà `tool.type` per distinguerli. `type` è opzionale; se omesso, si presume che lo strumento sia uno strumento personalizzato (in precedenza era l’unico tipo di strumento supportato). Per accedere all’utilizzo del computer, è necessario utilizzare il parametro `anthropic_beta`, con un enum corrispondente, il cui valore dipende dalla versione del modello in uso. Per ulteriori informazioni, consulta la tabella seguente.
Solo le richieste effettuate con questo parametro ed enum possono utilizzare gli strumenti di utilizzo del computer. È possibile specificare quanto segue: `"anthropic_beta": ["computer-use-2025-01-24"]`.
| Modello | Intestazione Beta |
| --- | --- |
| 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 |
Per ulteriori informazioni, consulta [Utilizzo del computer (beta)](https://docs.anthropic.com/en/docs/build-with-claude/computer-use) nella documentazione di Anthropic.
Di seguito è riportato un esempio di risposta che presuppone che la richiesta contenga uno screenshot del desktop con l’icona di Firefox.
```
{
"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
}
}
```
## Strumenti Anthropic definiti
Anthropic fornisce una serie di strumenti per consentire a determinati modelli Claude di utilizzare efficacemente i computer. Quando si specifica uno strumento Anthropic definito, i campi `description` e `tool_schema` non sono necessari o consentiti. Gli strumenti definiti Anthropic sono definiti da Anthropic, ma è necessario valutare esplicitamente i risultati dello strumento e restituire `tool_results` a Claude. Come con qualsiasi strumento, il modello non esegue automaticamente lo strumento. Ogni strumento Anthropic definito ha versioni ottimizzate per modelli Claude 3.5 Sonnet (nuovi) e Claude 3.7 Sonnet specifici:
| Modello | Strumento | Note |
| --- | --- | --- |
| 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"
} | Aggiornamento allo strumento `str_replace_editor` esistente |
| Claude 3.7 Sonnet | {
"type": "computer_20250124",
"name": "computer"
} | Include nuove azioni per un controllo più preciso |
| Claude 3.7 Sonnet | {
"type": "text_editor_20250124",
"name": "str_replace_editor"
} | Stesse funzionalità della versione 20241022 |
| Claude 3.5 Sonnet v2 | {
"type": "bash_20250124",
"name": "bash"
} | Stesse funzionalità della versione 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"
} |
Il campo `type` identifica lo strumento e i suoi parametri a fini di convalida, il campo `name` è il nome dello strumento esposto al modello.
Per richiedere l’utilizzo di uno degli strumenti da parte del modello, è possibile fare riferimento esplicito al relativo campo `name`. Il campo `name` deve essere univoco all’interno dell’elenco degli strumenti; non è possibile definire uno strumento con lo stesso `name` come uno strumento Anthropic definito nella stessa chiamata API.
## Cancellazione automatica delle chiamate allo strumento (Beta)
**avvertimento**
La cancellazione automatica delle chiamate agli strumenti è disponibile come «Servizio Beta», come definito nei Termini di AWS servizio.
**Nota**
Questa funzionalità è attualmente supportata su Claude Sonnet 4/4.5, Claude Haiku 4.5 e Claude Opus 4/4.1/4.5.
La cancellazione automatica delle chiamate agli strumenti è una funzionalità del modello Anthropic Claude (in versione beta). Con questa funzionalità, Claude può cancellare automaticamente i vecchi risultati di utilizzo degli strumenti man mano che si avvicinano i limiti dei token, consentendo una gestione più efficiente del contesto in scenari di utilizzo di utensili a più turni. Per utilizzare la funzionalità di cancellazione delle chiamate agli strumenti, devi aggiungere `context-management-2025-06-27` all’elenco delle intestazioni beta il parametro di richiesta anthropic\$1beta. Dovrete inoltre specificare l'uso `clear_tool_uses_20250919` e scegliere tra le seguenti opzioni di configurazione.
Questi sono i controlli disponibili per la strategia di gestione del contesto `clear_tool_uses_20250919`. Sono tutti opzionali o hanno dei valori predefiniti:
| **Opzione di configurazione** | **Descrizione** |
| --- | --- |
| `trigger` impostazione predefinita: 100.000 token di input | Definisce quando si attiva la strategia di modifica del contesto. Una volta che il prompt supera questa soglia, inizierà la cancellazione. Puoi specificare questo valore in input\$1tokens o tool\$1uses. |
| `keep` impostazione predefinita: 3 utilizzi dello strumento | Definisce quante use/result coppie di utensili recenti conservare dopo la cancellazione. L’API rimuove per prime le interazioni con gli strumenti più vecchie, preservando quelle più recenti. Utile quando il modello ha bisogno di accedere alle interazioni recenti con gli strumenti per continuare la conversazione in modo efficace. |
| `clear_at_least` (facoltativo) | Assicura che venga eliminato un numero minimo di token ogni volta che la strategia si attiva. Se l’API non riesce a cancellare almeno l’importo specificato, la strategia non verrà applicata. Ciò è utile per determinare se vale la pena interrompere la cache dei prompt per la cancellazione del contesto. |
| `exclude_tools` (facoltativo) | Elenco dei nomi degli strumenti i cui usi e risultati non devono mai essere cancellati. Utile per preservare un contesto importante. |
| `clear_tool_inputs` (False per impostazione predefinita, opzionale). | Controlla se i parametri di chiamata dello strumento vengono cancellati insieme ai risultati dello strumento. Per impostazione predefinita, vengono cancellati solo i risultati degli strumenti mantenendo visibili le chiamate agli strumenti originali di Claude, in modo che Claude possa vedere quali operazioni sono state eseguite anche dopo la rimozione dei risultati. |
**Nota**
La cancellazione degli strumenti invaliderà la cache se i prefissi contengono gli strumenti.
------
#### [ 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": [...],
}
}
```
------
**Nota**
Attualmente Bedrock non supporta la gestione del `clear_tool_uses_20250919` contesto sull' CountTokens API.
## Strumento di memoria (Beta)
**avvertimento**
Memory Tool è disponibile come «Servizio Beta» come definito nei Termini di AWS servizio.
Claude Sonnet 4.5 include un nuovo strumento di memoria che offre ai clienti un modo per gestire la memoria tra le conversazioni. Con questa funzionalità, i clienti possono consentire a Claude di recuperare informazioni al di fuori della finestra contestuale fornendo l’accesso a una directory locale. Questa funzionalità sarà disponibile come funzionalità beta. Per utilizzare questa funzionalità, è necessario utilizzare l’intestazione `context-management-2025-06-27` beta.
Definizione dello strumento:
```
{
"type": "memory_20250818",
"name": "memory"
}
```
Richiesta di esempio:
```
{
"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?"}]
}
]
}
```
Risposta di esempio:
```
{
"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": []
}
}
```
## Considerazioni sui costi per l’uso dello strumento
I prezzi delle richieste di utilizzo degli strumenti sono basati sui seguenti fattori:
1. Il numero totale di token di input inviati al modello (incluso nel parametro tools).
1. Il numero di token di output generati.
Gli strumenti hanno lo stesso prezzo di tutte le altre richieste API Claude, ma includono token aggiuntivi per richiesta. I token aggiuntivi derivanti dall’utilizzo degli strumenti provengono:
+ Dal parametro `tools` nelle richieste dell’API. Ad esempio, nomi, descrizioni e schemi degli strumenti.
+ Eventuali blocchi di contenuto `tool_use` nelle richieste e nelle risposte API.
+ Eventuali blocchi di contenuto `tool_result` nelle richieste API.
Quando si utilizzano gli strumenti, i modelli Anthropic includono automaticamente uno speciale prompt di sistema che consente l’utilizzo dello strumento. Il numero di token per l’utilizzo dello strumento richiesti per ogni modello è elencato nella tabella seguente. Questa tabella esclude i token aggiuntivi descritti in precedenza. Tieni presente che questa tabella presuppone che venga fornito almeno uno strumento. Se non vengono forniti strumenti, allora la scelta dello strumento “none” utilizza 0 token aggiuntivi nel prompt di sistema.
| Modello | Scelta dello strumento | Numero di token del prompt del sistema di utilizzo dello strumento |
| --- | --- | --- |
| 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 o 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 o tool | 313 |
| Claude 3.5 Sonnet | auto o none | 294 |
| Claude 3.5 Sonnet | any o tool | 261 |
| Claude 3 Opus | auto o none | 530 |
| Claude 3 Opus | any o tool | 281 |
| Claude 3 Sonnet | auto o none | 159 |
| Claude 3 Sonnet | any o tool | 235 |
| Claude 3 Haiku | auto o none | 264 |
| Claude 3 Haiku | any o tool | 340 |
## Strumento di ricerca degli strumenti (beta)
Tool Search Tool Claude consente di lavorare con centinaia o addirittura migliaia di strumenti senza caricare in anticipo tutte le loro definizioni nella finestra contestuale. Invece di dichiarare immediatamente tutti gli strumenti, è possibile contrassegnarli con`defer_loading: true`, e Claude trovare e caricare solo gli strumenti necessari attraverso il meccanismo di ricerca degli strumenti.
Per accedere a questa funzionalità è necessario utilizzare l'`tool-search-tool-2025-10-19`intestazione beta. Tieni presente che questa funzionalità è attualmente disponibile solo tramite [InvokeModel](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModel.html)e [InvokeModelWithResponseStream](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModelWithResponseStream.html) APIs.
Definizione dello strumento:
```
{
"type": "tool_search_tool_regex",
"name": "tool_search_tool_regex"
}
```
Esempio di richiesta:
```
{
"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?"
}]
}
```
Esempio di risposta
```
{
"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"
}
```
Esempio di 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
}
```
**Strumenti di ricerca personalizzati**
È possibile implementare strumenti di ricerca di strumenti personalizzati (ad esempio, utilizzando gli incorporamenti) definendo uno strumento che restituisca `tool_reference` i blocchi. Lo strumento personalizzato deve avere `defer_loading: false` mentre altri strumenti dovrebbero avere`defer_loading: true`. Quando definite il vostro strumento di ricerca strumenti, questo dovrebbe restituire un risultato contenente blocchi di `tool_reference` contenuto che rimandano agli strumenti che desiderate Claude utilizzare.
Il formato di risposta ai risultati di Tool Search Tool previsto dal cliente:
```
{
"type": "tool_result",
"tool_use_id": "toolu_01ABC123",
"content": [{
"type": "tool_reference",
"tool_name": "get_weather"
},
{
"type": "tool_reference",
"tool_name": "weather_forecast"
}
]
}
```
`tool_name`Deve corrispondere a uno strumento definito nella richiesta con. `defer_loading: true` Claude avrà quindi accesso agli schemi completi di quegli strumenti.
**Strumenti di ricerca personalizzati - Esempio dettagliato**
È possibile implementare strumenti di ricerca di strumenti personalizzati (ad esempio, utilizzando incorporamenti o ricerca semantica) definendo uno strumento che `tool_reference` restituisca blocchi. Ciò consente sofisticati meccanismi di scoperta degli strumenti oltre alla corrispondenza con espressioni regolari.
Esempio di richiesta con TST personalizzato:
```
{
"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?"
}]
}
```
Clauderisposta (chiamata al TST personalizzato):
```
{
"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"
}
```
**risultato dell'utensile fornito dal cliente**
Dopo aver eseguito la ricerca semantica nella libreria degli strumenti, il cliente restituisce i riferimenti agli strumenti corrispondenti:
```
{
"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"
}]
}
}]
}
```
Claudeil follow-up (utilizzando lo strumento scoperto)
```
{
"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"
}
```
**Gestione degli errori**
+ L'impostazione `defer_loading: true` per tutti gli strumenti (incluso lo strumento di ricerca degli strumenti) genererà un errore 400.
+ Il passaggio di una definizione di utensile `tool_reference` senza una definizione di utensile corrispondente genererà un errore 400
## Esempi di utilizzo degli strumenti (beta)
Claude Opus4.5 supporta esempi forniti dall'utente nelle definizioni degli strumenti per aumentare le prestazioni Claude di utilizzo degli strumenti. È possibile fornire esempi come chiamate di funzioni complete, formattate esattamente come sarebbero i veri output LLM, senza bisogno di traduzione in un altro formato. Per utilizzare questa funzionalità è necessario passare l'intestazione beta. `tool-examples-2025-10-29`
Esempio di definizione dello strumento:
```
{
"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"
}
]
}
```
**Regole di convalida**
+ Conformità allo schema: ogni esempio in `input_examples` deve essere valido in base allo strumento. `input_schema`
+ I campi obbligatori devono essere presenti in almeno un esempio.
+ I tipi di campo devono corrispondere allo schema.
+ I valori Enum devono appartenere al set consentito.
+ Se la convalida fallisce, restituisci un errore 400 con dettagli sull'esempio di convalida non riuscita.
+ Requisiti dell'array: `input_examples` deve essere un array (può essere vuoto).
+ `[]`L'array vuoto è valido ed equivale a omettere il campo.
+ Un singolo esempio deve essere ancora racchiuso in un array: `[{...}]`
+ Limite di lunghezza: iniziate con un limite di 20 esempi per definizione di utensile.
Esempi di errore:
```
// 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"
}
```
# Pensiero esteso
Il pensiero esteso offre capacità di ragionamento Claude avanzate per compiti complessi, garantendo al contempo diversi livelli di trasparenza nel processo di step-by-step pensiero prima di fornire la risposta definitiva. Ogni volta che si abilita la modalità pensiero di Claude, è necessario impostare un budget per il numero massimo di token che Claude può utilizzare per il processo di ragionamento interno.
I modelli supportati sono i seguenti:
| Modello | ID modello |
| --- | --- |
| 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` |
**Nota**
Il comportamento delle API differisce tra i modelli Claude 3.7 e Claude 4. Per ulteriori informazioni, consulta [Differenze di pensiero tra le versioni del modello](claude-messages-thinking-differences.md).
**Topics**
+ [Best practice e considerazioni sul pensiero esteso](#claude-messages-extended-thinking-bps)
+ [Funzionamento del pensiero esteso](#claude-messages-how-extended-thinking-works)
+ [Come utilizzare il pensiero esteso](#claude-messages-use-extended-thinking)
+ [Pensiero esteso con uso di strumenti](#claude-messages-extended-thinking-tool-use)
+ [Thinking block clearing (beta)](#claude-messages-thinking-block-clearing)
+ [Pensiero esteso con caching dei prompt](#claude-messages-extended-thinking-prompt-caching)
+ [Informazioni sul comportamento del caching dei blocchi di pensiero](#claude-messages-extended-thinking-caching-behavior)
+ [Numero massimo di token e dimensione della finestra contestuale nell’ambito del pensiero esteso](#claude-messages-extended-thinking-max-tokens)
+ [Considerazioni sul costo dei token di pensiero esteso](#claude-messages-extended-thinking-cost)
## Best practice e considerazioni sul pensiero esteso
Linee guida per l'utilizzo
+ **Selezione dei compiti**: usa il pensiero esteso per attività particolarmente complesse che traggono vantaggio da step-by-step ragionamenti come matematica, programmazione e analisi.
+ **Gestione del contesto**: non è necessario rimuovere i blocchi di pensiero precedenti. L’API Anthropic ignora automaticamente i blocchi di pensiero dei turni precedenti che non vengono inclusi nel calcolo dell’utilizzo del contesto.
+ **Progettazione dei prompt**: consulta [suggerimenti per il pensiero esteso](https://docs.anthropic.com/en/docs/build-with-claude/prompt-engineering/extended-thinking-tips) di Anthropic se desideri ottimizzare le capacità di pensiero di Claude.
Considerazioni sulle prestazioni
+ **Tempi di risposta**: preparati a tempi di risposta potenzialmente più lunghi a causa dell’elaborazione aggiuntiva richiesta per il processo di ragionamento. Tieni presente che la generazione di blocchi di pensiero potrebbe aumentare il tempo di risposta complessivo.
+ **Requisiti di streaming**: lo streaming è necessario quando `max_tokens` è maggiore di 21.333. Durante lo streaming, preparati a gestire entrambi i blocchi contenuto `thinking` e `text` non appena arrivano.
Compatibilità delle funzionalità
+ La funzionalità di pensiero non è compatibile con le modifiche `temperature`, `top_p` o `top_k` né con l’[uso forzato dello strumento](https://docs.anthropic.com/en/docs/agents-and-tools/tool-use/implement-tool-use#forcing-tool-use).
+ Non è possibile precompilare le risposte quando il pensiero è abilitato.
+ Le modifiche al budget di pensiero invalidano i prefissi dei prompt memorizzati nella cache che includono messaggi. Tuttavia, i prompt di sistema e le definizioni degli strumenti memorizzati nella cache continuano a funzionare quando i parametri del pensiero cambiano.
Utilizzo dei budget di pensiero
+ **Ottimizzazioni del budget**: il budget minimo è pari a 1.024 token. Anthropic consiglia di iniziare dal valore minimo e di aumentare il budget di pensiero in modo incrementale per trovare l’intervallo ottimale per il proprio caso d’uso. Un numero maggiore di token potrebbe consentire un ragionamento più completo e sfumato, ma potrebbe anche comportare un rendimento decrescente a seconda dell’attività. Il budget di pensiero è un obiettivo piuttosto che un limite rigoroso: l’utilizzo effettivo dei token può variare in base all’attività.
+ **Impostazioni minime e ottimali**: il budget minimo è pari a 1.024 token. Si consiglia di iniziare dal valore minimo e di aumentare il budget di pensiero in modo incrementale per trovare l’intervallo ottimale in modo che Claude sia in grado di offrire le prestazioni migliori per il caso d’uso specifico. Un numero maggiore di token potrebbe consentire l’elaborazione di un ragionamento più completo e sfumato, ma potrebbe anche comportare un rendimento decrescente a seconda dell’attività. Il budget di pensiero è un obiettivo piuttosto che un limite rigoroso: l’utilizzo effettivo dei token può variare in base all’attività.
+ **Sperimentazione**: il modello potrebbe funzionare in modo diverso a seconda delle impostazioni differenti per il budget di pensiero massimo. L’aumento del budget di pensiero massimo può indurre il modello a pensare meglio o più intensamente, a scapito di una maggiore latenza. Per le attività critiche, prendi in considerazione la possibilità di testare diverse impostazioni di budget per trovare l’equilibrio ottimale tra qualità e prestazioni.
+ **Budget elevati**: per budget di pensiero superiori a 32.000, si consiglia di utilizzare l’elaborazione in batch per evitare problemi di rete. Le richieste che spingono il modello a superare i 32.000 token causano richieste di lunga durata che potrebbero provocare timeout di sistema e limiti alle connessioni aperte. Tieni presente che i limiti `max_tokens` variano in base ai modelli Claude. Per ulteriori informazioni, consulta [Numero massimo di token e dimensione della finestra contestuale nell’ambito del pensiero esteso](#claude-messages-extended-thinking-max-tokens).
+ **Monitoraggio dell’utilizzo dei token**: monitora l’utilizzo dei token di pensiero per ottimizzare costi e prestazioni.
## Funzionamento del pensiero esteso
Quando la funzionalità di pensiero esteso è attivata, Claude crea blocchi di contenuto `thinking` in cui produce il suo ragionamento interno. Claude incorpora le informazioni derivanti da questo ragionamento prima di formulare una risposta finale. La risposta dell’API includerà blocchi di contenuto `thinking`, seguiti da blocchi di contenuto `text`.
Ecco un esempio del formato di risposta predefinito:
```
{
"content": [
{
"type": "thinking",
"thinking": "Let me analyze this step by step...",
"signature": "WaUjzkypQ2mUEVM36O2TxuC06KN8xyfbJwyem2dw3URve/op91XWHOEBLLqIOMfFG/UvLEczmEsUjavL...."
},
{
"type": "text",
"text": "Based on my analysis..."
}
]
}
```
Per ulteriori informazioni sul formato di risposta del pensiero esteso, consulta [Richiesta e risposta](model-parameters-anthropic-claude-messages-request-response.md) dell’API Messages di Anthropic.
## Come utilizzare il pensiero esteso
Per attivare il pensiero esteso, aggiungi un oggetto `thinking`, con il parametro `thinking` impostato su enabled e il parametro `budget_tokens` impostato su un budget di token specificato per il pensiero esteso.
Il parametro `budget_tokens` determina il numero massimo di token che Claude può utilizzare per il processo di ragionamento interno. Nel modelli Claude 4, questo limite si applica ai token di pensiero completo e non all’output riepilogato. Budget maggiori possono migliorare la qualità della risposta, consentendo un’analisi più approfondita per problemi complessi, anche se Claude può non utilizzare l’intero budget allocato, soprattutto per intervalli superiori a 32.000.
Il valore di `budget_tokens` deve essere impostato su un valore inferiore a `max_tokens`. Tuttavia, quando si utilizza [Pensiero interlacciato (beta)](#claude-messages-extended-thinking-tool-use-interleaved) con gli strumenti, è possibile superare questo limite perché il limite di token diventa l’intera finestra di contesto (200.000 token).
### Pensiero riepilogativo
Con la funzionalità di pensiero esteso abilitata, l’API Messages per i modelli Claude 4 restituisce un riepilogo del processo di pensiero completo di Claude. Il pensiero riepilogativo offre tutti i vantaggi in termini di intelligenza del pensiero esteso, prevenendone al contempo l’uso improprio.
Di seguito sono riportate alcune considerazioni importanti per il pensiero riepilogativo:
+ Vengono addebitati i token di pensiero completo generati dalla richiesta originale, non i token per il riepilogo.
+ Il numero dei token di output fatturati non corrisponde al numero di token visualizzati nella risposta.
+ Il prompt fornito al modello di riepilogo è soggetto a modifiche.
+ Le prime righe dell’output di pensiero sono più dettagliate e forniscono un ragionamento minuzioso particolarmente utile per scopi di progettazione dei prompt.
**Nota**
Claude 3.7 Sonnet restituisce comunque l’output del pensiero completo.
Per accedere all’output del pensiero completo nei modelli Claude 4, contatta il team del tuo account.
### Pensiero in streaming
Puoi trasmettere in streaming risposte di pensiero estese tramite eventi inviati dal server. Quando lo streaming è abilitato per il pensiero esteso, ricevi contenuti di pensiero tramite eventi `thinking_delta`. Non è garantito che gli eventi trasmessi in streaming vengano restituiti a una velocità costante. Potrebbero infatti verificarsi ritardi tra gli eventi. Per ulteriori informazioni sullo streaming tramite l’API Messages, consulta [Streaming dei messaggi](https://docs.anthropic.com/en/docs/build-with-claude/streaming).
Ecco come gestire lo streaming con Thinking utilizzando: **InvokeModelWithResponseStream**
```
{
"anthropic_version": "bedrock-2023-05-31",
"max_tokens": 10000,
"thinking": {
"type": "enabled",
"budget_tokens": 4000
},
"messages": [
{
"role": "user",
"content": "What is 27 * 453?"
}
]
}
```
Risposta:
```
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"}
```
**Informazioni sul comportamento dello streaming nell’ambito del pensiero**
Quando utilizzi lo streaming con thinking abilitato, potresti notare che il testo a volte arriva in blocchi più grandi alternati a messaggi di testo più piccoli. token-by-token Si tratta di un comportamento previsto, soprattutto per quanto riguarda i contenuti di pensiero. Per ottenere prestazioni ottimali, il sistema di streaming deve elaborare i contenuti in batch, che può comportare questo modello di distribuzione.
## Pensiero esteso con uso di strumenti
Il pensiero esteso può essere utilizzato insieme a [Utilizzo degli strumenti](model-parameters-anthropic-claude-messages-tool-use.md), permettendo a Claude di ragionare tramite la selezione degli strumenti e l’elaborazione dei risultati. Quando utilizzi il pensiero esteso con gli strumenti, tieni presente le limitazioni seguenti:
+ **Limitazione della scelta degli strumenti**: l’uso degli strumenti con il pensiero supporta solo `tool_choice: any`. Non è supporta la fornitura di uno strumento specifico, di `auto` o di altri valori.
+ **Conservazione dei blocchi di pensiero**: quando si utilizza lo strumento, è necessario restituire i blocchi di pensiero all’API per l’ultimo messaggio dell’assistente. Includi il blocco completo non modificato nell’API per mantenere la continuità del ragionamento.
Ecco come funziona la gestione delle finestre contestuali con gli strumenti:
```
{
"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?"
}
]
}
```
La prima risposta è la seguente:
```
{
"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"
}
}
]
}
```
La continuazione della conversazione con l’uso degli strumenti genererà un’altra risposta. Si noti che vengono passati sia `thinking_block` sia `tool_use_block`. Se il passaggio non avviene, si verifica un errore.
```
{
"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"
}
]
}
]
}
```
La risposta dell’API ora include solo testo
```
{
"content": [
{
"type": "text",
"text": "Currently in Paris, the temperature is 88°F (31°C)"
}
]
}
```
### Conservazione dei blocchi di pensiero
Quando si utilizza lo strumento, è necessario restituire i blocchi di pensiero all’API e includere nuovamente il blocco completo non modificato nell’API. Ciò è fondamentale per mantenere il flusso di ragionamento del modello e l’integrità della conversazione.
**Suggerimento**
Sebbene sia possibile omettere i blocchi `thinking` dai turni del ruolo `assistant` precedenti, si consiglia di restituire sempre tutti i blocchi di pensiero all’API per qualsiasi conversazione multi-turno. L’API eseguirà queste operazioni:
Filtro automatico dei blocchi di pensiero forniti
Uso dei blocchi di pensiero pertinenti necessari per preservare il ragionamento del modello
Fatturazione dei soli token di input per i blocchi mostrati a Claude
Quando Claude invoca gli strumenti, sospende la creazione di una risposta in attesa di informazioni esterne. Quando i risultati dello strumento vengono restituiti, Claude continua a creare la risposta esistente. Ciò richiede la conservazione dei blocchi di pensiero durante l’uso dello strumento per i seguenti motivi:
+ **Continuità del ragionamento**: il pensiero blocca il step-by-step ragionamento Claude di Capture che ha portato alla richiesta di strumenti. Quando si pubblicano i risultati dello strumento, l’inclusione del pensiero originale assicura che Claude sia in grado di continuare il ragionamento dal punto in cui l’aveva interrotto.
+ **Mantenimento del contesto**: sebbene i risultati degli strumenti siano visualizzati come messaggi utente nella struttura dell’API, in realtà fanno parte di un flusso di ragionamento continuo. La conservazione dei blocchi di pensiero consente di mantenere questo flusso concettuale tra più chiamate API.
**Importante**
Quando si forniscono blocchi di pensiero, l’intera sequenza di blocchi consecutivi deve corrispondere agli output generati dal modello durante la richiesta originale e non è possibile riorganizzare né modificare la sequenza dei blocchi.
### Pensiero interlacciato (beta)
**avvertimento**
Interleaved thinking è reso disponibile all'utente come «Servizio Beta», come definito nei Termini di servizio. AWS È soggetto al Contratto e ai Termini di AWS servizio dell'utente AWS e al modello di EULA applicabile.
I modelli Claude 4 supportano il pensiero interlacciato, una funzionalità che consente a Claude di pensare tra le chiamate agli strumenti e di eseguire ragionamenti più sofisticati dopo aver ricevuto i risultati dello strumento. Ciò consente interazioni di agenti più complesse in cui Claude può:
+ Valutare i risultati di una chiamata allo strumento prima di decidere l’operazione successiva
+ Concatenare più chiamate allo strumento con passaggi di ragionamento intermedi
+ Prendere decisioni più sfumate sulla base di risultati intermedi
Per abilitare il pensiero interlacciato, aggiungi l’intestazione beta `interleaved-thinking-2025-05-14` alla richiesta API.
**Nota**
Con il pensiero interlacciato, il valore di `budget_tokens` può superare quello del parametro `max_tokens`, in quanto rappresenta il budget totale di tutti i blocchi di pensiero all’interno di un turno dell’assistente.
## Thinking block clearing (beta)
**avvertimento**
Thinking block clearing è reso disponibile come «Servizio Beta» come definito nei Termini di AWS servizio.
**Nota**
Questa funzionalità è attualmente supportata su Claude Sonnet 4/4.5, Claude Haiku 4.5 e Claude Opus 4/4.1/4.5.
Thinking block clearing è una funzionalità del modello Anthropic Claude (in versione beta). Con questa funzione, Claude può eliminare automaticamente i blocchi di pensiero più vecchi dei turni precedenti. Per utilizzare Thinking block clearing, devi aggiungere `context-management-2025-06-27` all'elenco delle intestazioni beta il parametro di richiesta anthropic\$1beta. Dovrete inoltre specificare l'uso `clear_thinking_20251015` e scegliere tra le seguenti opzioni di configurazione.
Questi sono i controlli disponibili per la strategia di gestione del contesto `clear_thinking_20251015`. Sono tutti opzionali o hanno dei valori predefiniti:
| **Opzione di configurazione** | **Descrizione** |
| --- | --- |
| `keep` impostazione predefinita: 1 turno di pensiero | Definisce il numero di turni recenti dell'assistente con blocchi di pensiero da conservare. Usa `{"type": "thinking_turns", "value": N}` dove N deve essere > 0 per mantenere gli ultimi N turni o `{"type": "all"}` per mantenere tutti i blocchi di pensiero. |
------
#### [ 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": [...]
}
}
```
------
## Pensiero esteso con caching dei prompt
L’uso del [caching dei prompt](https://docs.aws.amazon.com/bedrock/latest/userguide/prompt-caching.html) con il pensiero si presta a diverse importanti considerazioni:
**Rimozione del contesto dei blocchi di pensiero**
+ I blocchi di pensiero dei turni precedenti vengono rimossi dal contesto e ciò può influire sui punti di interruzione della cache.
+ Se si continuano conversazioni con l’uso di strumenti, i blocchi di pensiero vengono memorizzati nella cache e sono considerati token di input quando vengono letti dalla cache. Ciò crea un compromesso in base al quale i blocchi di pensiero non occupano visivamente lo spazio della finestra contestuale, ma vengono comunque conteggiati ai fini dell’utilizzo dei token di input quando sono memorizzati nella cache.
+ Se la funzionalità di pensiero viene disabilitata, le richieste avranno esito negativo qualora si passi il contenuto di pensiero nel turno corrente di utilizzo dello strumento. In altri contesti, i contenuti di pensiero passati all’API vengono semplicemente ignorati.
**Modelli di invalidazione della cache**
+ Le modifiche ai parametri di pensiero, ad esempio l’abilitazione, la disabilitazione o la modifica dell’allocazione del budget, invalidano i punti di interruzione della cache dei messaggi.
+ [Pensiero interlacciato (beta)](#claude-messages-extended-thinking-tool-use-interleaved) amplifica l’invalidazione della cache, poiché blocchi di pensiero possono verificarsi tra più chiamate allo strumento.
+ I prompt e gli strumenti di sistema rimangono memorizzati nella cache nonostante le modifiche apportate ai parametri di pensiero o la rimozione dei blocchi.
**Nota**
Sebbene i blocchi di pensiero vengano rimossi per il caching e i calcoli del contesto, devono essere preservati quando si continuano le conversazioni con l’uso degli strumenti, in particolare con il pensiero interlacciato.
## Informazioni sul comportamento del caching dei blocchi di pensiero
Quando si utilizza il pensiero esteso con gli strumenti, i blocchi di pensiero mostrano un comportamento di caching specifico che influisce sul conteggio dei token. La sequenza seguente illustra questo funzionamento.
1. Il caching si verifica solo quando si effettua una richiesta successiva che includa i risultati dello strumento.
1. Quando viene effettuata la richiesta successiva, la cronologia delle conversazioni precedenti (inclusi i blocchi di pensiero) può essere memorizzata nella cache.
1. Quando sono letti dalla cache, i blocchi memorizzati nella cache contano come token di input nei parametri di utilizzo.
1. Quando viene incluso un blocco non-tool-result utente, tutti i blocchi di pensiero precedenti vengono ignorati e rimossi dal contesto.
Ecco un esempio dettagliato di flusso:
Richiesta 1
```
User: "What's the weather in Paris?"
```
Risposta 1
```
[thinking_block 1] + [tool_use block 1]
```
Richiesta 2
```
User: "What's the weather in Paris?",
Assistant: [thinking_block_1] + [tool_use block 1],
User: [tool_result_1, cache=True]
```
Risposta 2
```
[thinking_block 2] + [text block 2]
```
La richiesta 2 scrive nella cache il contenuto della richiesta (non della risposta). La cache include il messaggio utente originale, il primo blocco di pensiero, il blocco di utilizzo dello strumento e il risultato dello strumento.
Richiesta 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]
```
Poiché è stato incluso un blocco non-tool-result utente, tutti i blocchi di pensiero precedenti vengono ignorati. Questa richiesta viene elaborata in modo analogo alla richiesta seguente:
Richiesta 3 alternativa
```
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]
```
Questo comportamento è coerente sia che si utilizzi il pensiero regolare che il pensiero interlacciato.
## Numero massimo di token e dimensione della finestra contestuale nell’ambito del pensiero esteso
Nei modelli Claude meno recenti (precedenti a Claude 3.7 Sonnet), se la somma dei token di prompt e di max\$1tokens superava la finestra contestuale del modello, il sistema regolava automaticamente il valore max\$1tokens per adeguarlo al limite previsto per il contesto. In tal modo era possibile impostare un valore max\$1tokens elevato e il sistema lo riduceva automaticamente in base alle esigenze. Nei modelli Claude 3.7 e 4, il valore `max_tokens`, che include il budget di pensiero quando la funzionalità è abilitata, viene applicato come limite rigoroso. Il sistema ora restituisce un errore di convalida se la somma dei token di prompt e di max\$1tokens supera la dimensione della finestra contestuale.
### Finestra contestuale nell’ambito del pensiero esteso
Quando si calcola l’utilizzo della finestra contestuale con la funzionalità di pensiero abilitata, è necessario considerare gli aspetti seguenti:
+ I blocchi di pensiero dei turni precedenti vengono rimossi e non vengono conteggiati ai fini della finestra contestuale.
+ Il pensiero del turno attuale conta ai fini del limite `max_tokens` per il turno specifico.
La finestra contestuale effettiva viene calcolata come: finestra contestuale = (token di input correnti - token di pensiero precedenti) \$1 (token di pensiero \$1 token di pensiero criptati \$1 token di output di testo).
### Gestione dei token nell’ambito del pensiero esteso e dell’uso degli strumenti
Quando si utilizza il pensiero esteso con gli strumenti, i blocchi di pensiero devono essere preservati in modo esplicito e restituiti con i risultati dello strumento. Il calcolo efficace della finestra contestuale per il pensiero esteso con l’uso degli strumenti diventa il seguente:
`context window = (current input tokens + previous thinking tokens + tool use tokens) + (thinking tokens + encrypted thinking tokens + text output tokens)`
### Gestione dei token nell’ambito del pensiero esteso
In base alla finestra contestuale e al comportamento di `max_tokens` con i modelli Claude 3.7 e 4 con pensiero esteso, potrebbe essere necessario eseguire una di queste azioni:
+ Monitorare e gestire più attivamente l’uso dei token.
+ Modificare i valori `max_tokens` in base al cambiamento della lunghezza dei prompt.
+ Tenere presente che i blocchi di pensiero precedenti non si accumulano nella finestra contestuale. Questa modifica è stata apportata per fornire un comportamento più prevedibile e trasparente, soprattutto perché i limiti massimi dei token sono aumentati in modo significativo.
## Considerazioni sul costo dei token di pensiero esteso
Il processo di pensiero prevede costi per gli elementi seguenti:
+ Token utilizzati durante il processo di pensiero (token di output)
+ I blocchi di pensiero dell’ultimo turno dell’assistente vengono inclusi nelle richieste successive (token di input)
+ Token standard di output di testo
**Suggerimento**
Quando la funzionalità di pensiero esteso è abilitata, viene automaticamente incluso un prompt di sistema specializzato con 28 o 29 token per supportare la funzionalità stessa.
Il parametro `budget_tokens` determina il numero massimo di token che Claude può utilizzare per il processo di ragionamento interno. Budget maggiori possono migliorare la qualità della risposta, consentendo un’analisi più approfondita per problemi complessi, anche se Claude può non utilizzare l’intero budget allocato, soprattutto per intervalli superiori a 32.000.
Con il pensiero interlacciato, il valore di `budget_tokens` può superare quello del parametro `max_tokens`, in quanto rappresenta il budget totale di tutti i blocchi di pensiero all’interno di un turno dell’assistente.
Quando si utilizza un pensiero riepilogativo, tenere presente le seguenti informazioni:
+ **Token di input**: token nella richiesta originale
+ **Token di output (fatturati)**: token di pensiero originali che Claude ha generato internamente
+ **Token di output (visibili)**: token di pensiero riepilogati visibili nella risposta
+ **Nessun costo**: token utilizzati per generare il riepilogo
+ Il campo `summary_status` può indicare se i limiti del token hanno influito sul riepilogo
+ Il numero dei token di output fatturati non corrisponde al numero di token visibili nella risposta e viene fatturato il processo di pensiero completo e non il riepilogo visualizzato.
# Pensiero adattivo
Il pensiero adattivo è il metodo consigliato da utilizzare [Pensiero esteso](claude-messages-extended-thinking.md) con Claude Opus 4.6. Invece di impostare manualmente un budget basato su Thinking Token, Adaptive Thinking consente di decidere Claude dinamicamente quando e quanto pensare in base alla complessità di ogni richiesta. Il pensiero adattivo offre prestazioni migliori in modo affidabile rispetto al pensiero esteso con un approccio fisso`budget_tokens`, e consigliamo di passare al pensiero adattivo per ottenere le risposte più intelligenti della versione 4.6. Claude Opus Non è richiesto alcun header beta.
I modelli supportati sono i seguenti:
| Modello | ID modello |
| --- | --- |
| Claude Opus4.6 | `anthropic.claude-opus-4-6-v1` |
| Claude Sonnet 4.6 | `anthropic.claude-sonnet-4-6` |
**Nota**
`thinking.type: "enabled"`e `budget_tokens` sono obsoleti nella versione Claude Opus 4.6 e verranno rimossi in una versione futura del modello. Utilizzare invece `thinking.type: "adaptive"` con il parametro effort.
I modelli precedenti (Claude Opus4.5Claude Sonnet 4.5, ecc.) non supportano il pensiero adattivo e richiedono `thinking.type: "enabled"` con`budget_tokens`.
## Come funziona il pensiero adattivo
In modalità adattiva, Claude valuta la complessità di ogni richiesta e decide se e quanto pensare. Al livello di sforzo predefinito (`high`), Claude penserà quasi sempre. A livelli di sforzo inferiori, Claude può evitare di pensare a problemi più semplici.
Il pensiero adattivo abilita anche automaticamente. [Pensiero interlacciato (beta)](claude-messages-extended-thinking.md#claude-messages-extended-thinking-tool-use-interleaved) Ciò significa Claude poter pensare tra un intervento e l'altro, il che lo rende particolarmente efficace per i flussi di lavoro agentici.
Imposta su `thinking.type` `"adaptive"` nella tua richiesta API:
------
#### [ 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);
```
------
## Pensiero adattivo con il parametro effort
Puoi combinare il pensiero adattivo con il parametro dello sforzo per determinare la portata del pensieroClaude. Il livello di impegno funge da guida morbida per l'allocazione Claude del pensiero:
| Livello di impegno | Comportamento di pensiero |
| --- | --- |
| max | Claudepensa sempre senza limiti alla profondità del pensiero. Claude Opussolo 4.6: le richieste utilizzate max su altri modelli restituiranno un errore. |
| high (predefinito) | Claudepensa sempre. Fornisce un ragionamento approfondito su compiti complessi. |
| medium | Claudeusa un pensiero moderato. Può saltare il pensiero per domande molto semplici. |
| low | Claudeminimizza il pensiero. Evita di pensare a compiti semplici in cui la velocità conta di più. |
## Caching dei prompt
Richieste consecutive che utilizzano `adaptive` thinking preserve prompt cache breakpoints. Tuttavia, il passaggio tra le modalità `adaptive` e`enabled`/`disabled`thinking interrompe i punti di interruzione della cache per i messaggi. Le istruzioni di sistema e le definizioni degli strumenti rimangono memorizzate nella cache indipendentemente dai cambiamenti di modalità.
## Ottimizzazione del comportamento di pensiero
Se Claude pensi più o meno spesso di quanto desideri, puoi aggiungere una guida al prompt del sistema:
```
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.
```
**avvertimento**
ClaudeOrientarsi a pensare meno spesso può ridurre la qualità delle attività che traggono vantaggio dal ragionamento. Misura l'impatto sui tuoi carichi di lavoro specifici prima di implementare l'ottimizzazione tempestiva per la produzione. Valuta innanzitutto la possibilità di eseguire test con livelli di sforzo inferiori.
# Crittografia Thinking
Il contenuto completo di Thinking viene crittografato e restituito nel campo della firma. Questo campo viene utilizzato per verificare che i blocchi di Thinking siano stati generati da Claude quando sono stati restituiti all’API. Durante lo streaming delle risposte, la firma viene aggiunta tramite `signature_delta` all’interno di un evento `content_block_delta` appena prima dell’evento `content_block_stop`.
**Nota**
È strettamente necessario restituire blocchi di Thinking solo durante l’utilizzo di strumenti che prevedono un pensiero esteso. Altrimenti, puoi omettere i blocchi di Thinking presenti nei turni precedenti oppure lasciare che l’API li rimuova automaticamente, quando li restituisci.
Se restituisci i blocchi di Thinking, ti consigliamo di restituirli tutti così come li hai ricevuti, per motivi di coerenza e per evitare potenziali problemi.
## Redazione di Thinking in Claude 3.7 Sonnet
**Nota**
Le seguenti informazioni si applicano specificamente a Claude 3.7 Sonnet. 4 modelli di Claude gestiscono il Thinking in modo diverso e non generano blocchi di Thinking redatti.
In Claude 3.7 Sonnet, vale quanto segue:
+ Occasionalmente, il ragionamento interno di Claude verrà segnalato dai nostri sistemi di sicurezza. Quando si verifica questa situazione, una parte o l’intero blocco Thinking viene crittografato e restituito come blocco redacted\$1thinking. I blocchi redacted\$1thinking vengono decrittografati quando vengono restituiti all’API, consentendo a Claude di continuare la risposta senza perdere il contesto.
+ I blocchi `thinking` e `redacted_thinking` vengono restituiti prima dei blocchi di testo nella risposta.
Quando crei applicazioni rivolte ai clienti che utilizzano il Thinking esteso con Claude 3.7 Sonnet, considera quanto segue:
+ Tieni presente che i blocchi di Thinking redatti contengono contenuto crittografato che non è leggibile da persone.
+ Potresti fornire una spiegazione semplice come: “Alcuni ragionamenti interni di Claude sono stati crittografati automaticamente per motivi di sicurezza. Ciò non influisce sulla qualità delle risposte”.
+ Se mostri blocchi di Thinking agli utenti, puoi filtrare i blocchi redatti preservando i normali blocchi di Thinking.
+ Sii trasparente sul fatto che l’utilizzo di funzionalità di Thinking esteso può occasionalmente comportare la crittografia di alcuni ragionamenti.
+ Implementa una gestione degli errori appropriata per gestire correttamente il Thinking redatto senza compromettere l’interfaccia utente.
Ecco un esempio che mostra blocchi di Thinking normali e redatti:
```
{
"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..."
}
]
}
```
**Suggerimento**
La visualizzazione di blocchi di Thinking redatti nei risultati è un comportamento previsto. Il modello può ancora utilizzare questo ragionamento redatto per orientare le proprie risposte, mantenendo al contempo i guardrail di sicurezza.
Se hai bisogno di testare la gestione del Thinking redatto nella tua applicazione, puoi usare questa speciale stringa di test come prompt: `ANTHROPIC_MAGIC_STRING_TRIGGER_REDACTED_THINKING_46C9A13E193C177646C7398A98432ECCCE4C1253D5E2D82641AC0E52CC2876CB`
Quando passi i blocchi `thinking` e `redacted_thinking` all’API in una conversazione a più turni, devi includere il blocco completo e non modificato nell’ultima richiesta dell’assistente. Ciò è fondamentale per mantenere il flusso di ragionamento del modello. Consigliamo di restituire sempre tutti i blocchi di Thinking all’API. Per ulteriori dettagli, consulta [Pensiero esteso con uso di strumentiConservazione dei blocchi di pensiero](claude-messages-extended-thinking.md#claude-messages-extended-thinking-tool-use-thinking-blocks).
L'esempio seguente utilizza l'**InvokeModelWithResponseStream**API per dimostrare la struttura di richiesta e risposta quando si utilizzano i thinking token con redazioni.
Quando lo streaming è abilitato, riceverai contenuti di Thinking dagli eventi thinking\$1delta. Ecco come gestire lo streaming con il Thinking:
**Richiesta**
```
{
"anthropic_version": "bedrock-2023-05-31",
"max_tokens": 24000,
"thinking": {
"type": "enabled",
"budget_tokens": 16000
},
"messages": [
{
"role": "user",
"content": "What is 27 * 453?"
}
]
}
```
**Risposta**
```
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"}
```
# Differenze di pensiero tra le versioni del modello
L’API Messaggi gestisce il modo di pensare in modo diverso tra i modelli Claude 3.7 Sonnet e Claude 4, principalmente nel comportamento di redazione e riepilogo. Nella seguente tabella sono riepilogate le varie differenze.
| Funzionalità | Claude 3.7 Sonnet | Modelli Claude 4 |
| --- | --- | --- |
| Risultato del pensiero | Restituisce l’intero risultato del pensiero | Restituisce il pensiero riepilogativo |
| Gestione della redazione | Utilizza blocchi `redacted_thinking` | Rimuove e crittografa il pensiero completo, restituito in un campo `signature` |
| Pensiero interlacciato | Non supportata | Supportato con un’intestazione beta |
# Compattazione
**Suggerimento**
La compattazione lato server è consigliata per la gestione del contesto nelle conversazioni di lunga durata e nei flussi di lavoro agentici, poiché gestisce automaticamente la gestione del contesto con un lavoro di integrazione minimo.
**Nota**
La compattazione è attualmente in versione beta. Includi l'intestazione beta `compact-2026-01-12` nelle tue richieste API per utilizzare questa funzionalità. La compattazione non è attualmente supportata dall'ConverseAPI, tuttavia è supportata con. [InvokeModel](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModel.html)
La compattazione estende la lunghezza effettiva del contesto per conversazioni e attività di lunga durata riassumendo automaticamente il contesto precedente quando ci si avvicina al limite della finestra di contesto. È ideale per:
+ Conversazioni basate su chat a turni in cui si desidera che gli utenti utilizzino una chat per un lungo periodo di tempo
+ Prompt orientati alle attività che richiedono molto lavoro di follow-up (spesso l'uso di strumenti) e che possono superare la finestra contestuale di 200.000
La compattazione è supportata sui seguenti modelli:
| Modello | ID modello |
| --- | --- |
| Claude Sonnet 4.6 | `anthropic.claude-sonnet-4-6` |
| Claude Opus 4.6 | `anthropic.claude-opus-4-6-v1` |
**Nota**
Il livello superiore `input_tokens` e `output_tokens` quello `usage` sul campo non includono l'utilizzo delle iterazioni di compattazione e riflettono la somma di tutte le iterazioni non di compattazione. Per calcolare il totale dei token consumati e fatturati per una richiesta, sommate tutte le voci dell'array. `usage.iterations`
Se in precedenza facevi affidamento su `usage.input_tokens` e `usage.output_tokens` per il monitoraggio o il controllo dei costi, dovrai aggiornare la logica di tracciamento per aggregarla quando la compattazione è abilitata. `usage.iterations` L'`iterations`array è presente solo quando viene attivata una nuova compattazione durante la richiesta. La riapplicazione di un `compaction` blocco precedente non comporta costi di compattazione aggiuntivi e in tal caso i campi di utilizzo di primo livello rimangono accurati.
## Come funziona la compattazione
Quando la compattazione è abilitata, riassume Claude automaticamente la conversazione quando si avvicina alla soglia del token configurata. L'API:
1. Rileva quando i token di input superano la soglia di attivazione specificata.
1. Genera un riepilogo della conversazione corrente.
1. Crea un `compaction` blocco contenente il riepilogo.
1. Continua la risposta con il contesto compatto.
Nelle richieste successive, aggiungi la risposta ai tuoi messaggi. L'API elimina automaticamente tutti i blocchi di messaggi precedenti al `compaction` blocco, continuando la conversazione dal riepilogo.
## Utilizzo di base
Abilita la compattazione aggiungendo la `compact_20260112` strategia `context_management.edits` nella tua richiesta API Messages.
------
#### [ 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
| Parametro | Tipo | Predefinita | Description |
| --- | --- | --- | --- |
| type | stringa | Richiesto | Deve essere "compact\$120260112" |
| trigger | oggetto | 150.000 token | Quando attivare la compattazione. Devono essere almeno 50.000 gettoni. |
| pause\$1after\$1compaction | booleano | false | Se mettere in pausa dopo aver generato il riepilogo della compattazione |
| instructions | stringa | null | Richiesta di riepilogo personalizzata. Sostituisce completamente il prompt predefinito quando fornito. |
## Configurazione del trigger
Configura quando si attiva la compattazione utilizzando il `trigger` parametro:
```
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"])
```
## Istruzioni di riepilogo personalizzate
Per impostazione predefinita, la compattazione utilizza la seguente richiesta di riepilogo:
```
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.
```
È possibile fornire istruzioni personalizzate tramite il `instructions` parametro per sostituire completamente questo prompt. Le istruzioni personalizzate non integrano quelle predefinite, ma le sostituiscono completamente:
```
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"])
```
## Pausa dopo la compattazione
Consente `pause_after_compaction` di mettere in pausa l'API dopo aver generato il riepilogo della compattazione. Ciò consente di aggiungere blocchi di contenuto aggiuntivi (ad esempio la conservazione dei messaggi recenti o di messaggi specifici orientati alle istruzioni) prima che l'API continui con la risposta.
Se abilitata, l'API restituisce un messaggio con il motivo dell'`compaction`interruzione dopo aver generato il blocco di compattazione:
```
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"])
```
## Lavorare con blocchi di compattazione
Quando viene attivata la compattazione, l'API restituisce un `compaction` blocco all'inizio della risposta dell'assistente.
Una conversazione di lunga durata può comportare compattazioni multiple. L'ultimo blocco di compattazione riflette lo stato finale del prompt e sostituisce il contenuto precedente con il riepilogo generato.
```
{
"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
Quando trasmetti risposte in streaming con la compattazione abilitata, riceverai un `content_block_start` evento all'inizio della compattazione. Lo streaming del blocco di compattazione è diverso dai blocchi di testo. Riceverai un `content_block_start` evento, seguito da un singolo `content_block_delta` con il contenuto di riepilogo completo (senza streaming intermedio) e poi da un evento. `content_block_stop`
## Caching dei prompt
Puoi aggiungere un `cache_control` breakpoint sui blocchi di compattazione, che memorizza nella cache l'intero prompt del sistema insieme al contenuto riepilogato. Il contenuto compattato originale viene ignorato. Tieni presente che quando viene attivata la compattazione, può causare la perdita della cache nella richiesta successiva.
```
{
"role": "assistant",
"content": [
{
"type": "compaction",
"content": "[summary text]",
"cache_control": {"type": "ephemeral"}
},
{
"type": "text",
"text": "Based on our conversation..."
}
]
}
```
## Comprendere l'utilizzo
La compattazione richiede una fase di campionamento aggiuntiva, che contribuisce ai limiti tariffari e alla fatturazione. L'API restituisce informazioni dettagliate sull'utilizzo nella risposta:
```
{
"usage": {
"input_tokens": 45000,
"output_tokens": 1234,
"iterations": [
{
"type": "compaction",
"input_tokens": 180000,
"output_tokens": 3500
},
{
"type": "message",
"input_tokens": 23000,
"output_tokens": 1000
}
]
}
}
```
L'`iterations`array mostra l'utilizzo per ogni iterazione di campionamento. Quando si verifica la compattazione, vedrai un'`compaction`iterazione seguita dall'iterazione principale. `message` Il numero di token dell'iterazione finale riflette la dimensione effettiva del contesto dopo la compattazione.
# Ottieni risultati JSON convalidati dai modelli
È possibile utilizzare output strutturati conClaude Sonnet 4.5,Claude Haiku 4.5, Claude Opus 4.5 e. Claude Opus 4.6 Per ulteriori informazioni, consulta [Ottieni risultati JSON convalidati dai modelli](structured-output.md).
# Richiesta e risposta
Il corpo della richiesta viene passato nel `body` campo di una richiesta a [InvokeModel](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModel.html)o [InvokeModelWithResponseStream](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModelWithResponseStream.html).
**Nota**
Le restrizioni si applicano alle seguenti operazioni: `InvokeModel``InvokeModelWithResponseStream`,`Converse`, e`ConverseStream`. Per i dettagli, consulta [Restrizioni API](inference-api-restrictions.md).
**avvertimento**
Claude Sonnet 4.5e Claude Haiku 4.5 supporta la specificazione del `top_p` parametro `temperature` o, ma non di entrambi. Questa condizione non si applica ai modelli precedenti.
------
#### [ Request ]
Anthropic Claude include i parametri di inferenza seguenti per effettuare una chiamata di inferenza ai messaggi.
```
{
"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]
}
```
I seguenti parametri sono obbligatori.
+ **anthropic\$1version** (obbligatorio): versione di Anthropic. Il valore deve essere `bedrock-2023-05-31`.
+ **max\$1Tokens** (obbligatorio): numero massimo di token da generare prima dell’interruzione.
Tenere presente che i modelli Anthropic Claude potrebbero interrompere la generazione di token prima di raggiungere il valore di `max_tokens`. In modelli Anthropic Claude diversi i valori massimi per questo parametro sono differenti. Per ulteriori informazioni, consulta [Confronto dei modelli](https://docs.anthropic.com/claude/docs/models-overview#model-comparison).
+ **messages** (obbligatorio): messaggi di input.
+ **role**: ruolo del turno di conversazione. I valori validi sono `user` e `assistant`.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/bedrock/latest/userguide/model-parameters-anthropic-claude-messages-request-response.html)
+ **content** (obbligatorio): contenuto del turno di conversazione, come array di oggetti. Ogni oggetto contiene un campo **type**, in cui è possibile specificare uno dei seguenti valori:
+ `text`: se si specifica questo tipo, è necessario includere un campo di testo e indicare il prompt di testo come valore. Se un altro oggetto dell’array è un’immagine, questo prompt di testo si applica alle immagini.
+ `image`: se si specifica questo tipo, è necessario includere un campo **source** mappato a un oggetto con i seguenti campi:
+ **type** (obbligatorio): tipo di codifica dell’immagine. È possibile specificare `base64`.
+ **media\$1type** (obbligatorio): tipo di immagine. È possibile specificare i seguenti formati di immagine:
+ `image/jpeg`
+ `image/png`
+ `image/webp`
+ `image/gif`
+ **data** (obbligatorio): byte dell’immagine con codifica base64 per l’immagine. La dimensione massima è 3,75 MB. L’altezza e la larghezza massime di un’immagine corrispondono a 8.000 pixel.
I seguenti parametri sono facoltativi.
+ **system** (facoltativo): prompt di sistema per la richiesta.
Un prompt di sistema è un modo per fornire contesto e istruzioni ad Anthropic Claude, ad esempio specificando un obiettivo o un ruolo particolare. Per ulteriori informazioni, consulta [Dare un ruolo a Claude con un system prompt](https://docs.anthropic.com/en/docs/system-prompts) nella documentazione di Anthropic.
**Nota**
È possibile utilizzare i prompt di sistema con Anthropic Claude versione 2.1 o successiva.
+ **anthropic\$1beta** (facoltativo): il parametro anthropic\$1beta è un elenco di stringhe di intestazioni beta utilizzate per indicare l’accettazione a un particolare set di funzionalità beta.
**Nota**
La variante con lunghezza contestuale di 1 milione di token Claude Sonnet 4 è disponibile in alcune AWS regioni come «Servizio beta», come definito nei Termini di AWS servizio. È soggetto al Contratto AWS e ai Termini di AWS servizio dell'utente e al modello di EULA applicabile. Per ulteriori informazioni sui prezzi per le richieste contestuali più lunghe, consulta la pagina [Prezzi di Amazon Bedrock](https://aws.amazon.com/bedrock/pricing/). Si applicano quote di servizio separate (per ulteriori informazioni, vedere **Service** Quotas in Console di gestione AWS).
Altre intestazioni beta disponibili sono le seguenti:
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/bedrock/latest/userguide/model-parameters-anthropic-claude-messages-request-response.html)
+ **stop\$1sequences** (facoltativo): sequenze di testo personalizzate che inducono il modello a interrompere la generazione. I modelli Anthropic Claude in genere interrompono la generazione quando hanno completato naturalmente il proprio turno e in questo caso il valore della campo di risposta `stop_reason` è `end_turn`. Se si desidera che il modello interrompa la generazione quando incontra stringhe di testo personalizzate, usare il parametro `stop_sequences`. Se il modello incontra una delle stringhe di testo personalizzate, il valore del campo di risposta `stop_reason` è `stop_sequence` e il valore di `stop_sequence` contiene la sequenza di arresto corrispondente.
Il numero massimo di voci è 8191.
+ **temperature** (facoltativo): quantità di randomizzazione inserita nella risposta.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/bedrock/latest/userguide/model-parameters-anthropic-claude-messages-request-response.html)
+ **top\$1p** (facoltativo): utilizza il metodo “nucleus sampling”.
Nel metodo “nucleus sampling”, Anthropic Claude calcola la distribuzione cumulativa di tutte le opzioni per ogni token successivo in ordine di probabilità decrescente e la interrompe quando raggiunge un particolare valore specificato da `top_p`. Quando si regolano i parametri di campionamento, modificare `temperature` oppure `top_p`. Non modificare entrambi i parametri contemporaneamente.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/bedrock/latest/userguide/model-parameters-anthropic-claude-messages-request-response.html)
+ **top\$1k** (facoltativo): campionamento eseguito solo dalle opzioni top K per ogni token successivo.
Utilizza `top_k` per rimuovere le risposte long tail a bassa probabilità.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/bedrock/latest/userguide/model-parameters-anthropic-claude-messages-request-response.html)
+ **tools** (facoltativo): definizioni di strumenti che il modello può utilizzare.
**Nota**
Richiede un modello Anthropic Claude 3.
Se si include `tools` nella richiesta, il modello può restituire blocchi di contenuto `tool_use` che rappresentano l’utilizzo di tali strumenti da parte del modello. È quindi possibile eseguire tali strumenti utilizzando l’input dello strumento generato dal modello e quindi, facoltativamente, restituire i risultati al modello utilizzando blocchi di contenuto `tool_result`.
È possibile passare i seguenti tipi di strumenti:
**Personalizzato**
Definizione di uno strumento personalizzato.
+ **type** (facoltativo): tipo di strumento. Se definito, utilizzare il valore `custom`.
+ **name**: nome dello strumento.
+ **descrizione** (facoltativa, ma fortemente consigliata): descrizione dello strumento.
+ **input\$1schema**: schema JSON per lo strumento.
**Computer**
Definizione del computer utilizzato con l’API per l’utilizzo del computer.
+ **type**: il valore deve essere `computer_20241022`.
+ **name**: il valore deve essere `computer`.
+ **display\$1height\$1px** (obbligatorio): altezza del display controllato dal modello, in pixel.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/bedrock/latest/userguide/model-parameters-anthropic-claude-messages-request-response.html)
+ **display\$1width\$1px** (obbligatorio): larghezza del display controllato dal modello, in pixel.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/bedrock/latest/userguide/model-parameters-anthropic-claude-messages-request-response.html)
+ **display\$1number** (facoltativo): numero di display da controllare (rilevante solo per gli ambienti X11). Se specificato, allo strumento verrà fornito un numero di display nella definizione dello strumento.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/bedrock/latest/userguide/model-parameters-anthropic-claude-messages-request-response.html)
**bash**
Definizione dello strumento bash utilizzato con l’API per l’utilizzo del computer.
+ **type** (facoltativo): il valore deve essere `bash_20241022`.
+ **name**: il valore deve essere lo strumento `bash`.
**editor di testo**
Definizione dello strumento editor di testo utilizzato con l’API per l’utilizzo del computer.
+ **type** (facoltativo): il valore deve essere `text_editor_20241022`.
+ **name**: il valore deve essere lo strumento `str_replace_editor`.
+ **tool\$1choice** (facoltativo): specifica la modalità di utilizzo degli strumenti forniti da parte del modello. Il modello può utilizzare uno strumento specifico, qualsiasi strumento disponibile o decidere in modo autonomo.
**Nota**
Richiede un modello Anthropic Claude 3.
+ **tipo**: tipo dello strumento scelto. I valori possibili sono `any` (qualsiasi strumento disponibile), `auto` (decide il modello) e `tool` (strumento specificato).
+ **name** (facoltativo): nome dello strumento da utilizzare. Obbligatorio se si specifica `tool` nel campo `type`.
------
#### [ Response ]
I modelli Anthropic Claude restituiscono i campi seguenti per una chiamata di inferenza ai messaggi.
```
{
"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
}
}
```
Risposte di esempio con nuovi valori stop\$1reason:
```
// 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**: identificatore univoco per la risposta. Il formato e la lunghezza dell’ID potrebbero cambiare nel tempo.
+ **model**: ID modello Anthropic Claude che ha effettuato la richiesta.
+ **stop\$1reason**: motivo per cui Anthropic Claude ha interrotto la generazione della risposta.
+ **end\$1turn**: il modello ha raggiunto un punto d interruzione naturale.
+ **max\$1tokens**: il testo generato ha superato il valore del campo di input `max_tokens` o ha superato il numero massimo di token supportati dal modello.
+ **stop\$1sequence**: il modello ha generato una delle sequenze di arresto specificate nel campo di input `stop_sequences`.
+ **refusal**: Claude si rifiuta di generare una risposta per motivi di sicurezza.
+ **tool\$1use**: Claude sta chiamando uno strumento e si aspetta che l’utente lo esegua.
+ **model\$1context\$1window\$1exceeded**: il modello ha interrotto la generazione perché ha raggiunto il limite della finestra contestuale.
+ Nuovo in Claude Sonnet 4.5
+ **stop\$1sequence**: sequenza di arresto che ha terminato la generazione.
+ **type**: tipo della risposta. Il valore è sempre `message`.
+ **role**: ruolo conversazionale del messaggio generato. Il valore è sempre `assistant`.
+ **content**: contenuto generato dal modello. Restituito in forma di array. Esistono tre tipi di contenuto, *text*, *tool\$1use* e *image*.
+ *text*: risposta in formato testo.
+ **type**: tipo del contenuto. Il valore è `text`.
+ **text**: se il valore di `type` è di tipo testo, contiene il testo del contenuto.
+ *tool use*: richiesta da parte del modello di utilizzare uno strumento.
+ **type**: tipo del contenuto. Il valore è `tool_use`.
+ **id**: ID dello strumento di cui il modello richiede l’utilizzo.
+ **name**: nome dello strumento richiesto.
+ **input**: parametri di input da passare allo strumento.
+ *Image*: richiesta da parte del modello di utilizzare uno strumento.
+ **type**: tipo del contenuto. Il valore è `image`.
+ **source**: contiene l’immagine. Per ulteriori informazioni, consulta [Prompt multimodali](model-parameters-anthropic-claude-messages.md#model-parameters-anthropic-claude-messages-multimodal-prompts).
+ **usage**: container per il numero di token forniti nella richiesta e per quello di token generati dal modello nella risposta.
+ **input\$1tokens**: numero di token di input nella richiesta.
+ **output\$1tokens**: numero di token generati dal modello nella risposta.
+ **stop\$1sequence**: il modello ha generato una delle sequenze di arresto specificate nel campo di input `stop_sequences`.
------
## Parametro di sforzo (beta)
Il `effort` parametro è un'alternativa a Thinking Token Budgets for Claude Opus 4.5. Questo parametro indica con Claude quanta generosità dovrebbe spendere i token per ottenere i migliori risultati, adattando l'utilizzo dei token in base al pensiero, alle chiamate agli strumenti e alla comunicazione con l'utente. Può essere usato con o senza la modalità di pensiero estesa.
Il parametro di sforzo può essere impostato su:
+ `high`(impostazione predefinita): Claude spende tutti i token necessari per ottenere il miglior risultato
+ `medium`— Utilizzo bilanciato dei token
+ `low`— Utilizzo conservativo dei token
Per utilizzare questa funzionalità è necessario superare l'intestazione `effort-2025-11-24` beta.
Esempio di richiesta:
```
{
"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"
}]
}
```
# Esempi di codice
Gli esempi di codice seguenti mostrano come utilizzare l’API Messages.
**Topics**
+ [Esempio di codice di messaggio](#api-inference-examples-claude-messages-code-example)
+ [Esempi di codice multimodale](#api-inference-examples-claude-multimodal-code-example)
## Esempio di codice di messaggio
Questo esempio mostra come inviare un messaggio di solo turno utente e un messaggio di turno utente con risposta assistente precompilata a un modello Anthropic Claude 3 Sonnet.
```
# 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()
```
## Esempi di codice multimodale
Gli esempi seguenti mostrano come passare un’immagine e il testo di un prompt in un messaggio multimodale a un modello Anthropic Claude 3 Sonnet.
**Topics**
+ [Richiesta multimodale con InvokeModel](#api-inference-examples-claude-multimodal-code-example-invoke-model)
+ [Streaming di prompt multimodale con InvokeModelWithResponseStream](#api-inference-examples-claude-multimodal-code-example-streaming)
### Richiesta multimodale con InvokeModel
L'esempio seguente mostra come inviare un prompt multimodale a with. 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()
```
### Streaming di prompt multimodale con InvokeModelWithResponseStream
L'esempio seguente mostra come trasmettere in streaming la risposta da un prompt multimodale inviato a with. Anthropic Claude 3 Sonnet [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()
```
# Modelli supportati
Puoi utilizzare l’API Messages con i seguenti modelli Anthropic Claude.
+ 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
# Modelli AI21 Labs
Questa sezione descrive i parametri di richiesta e i campi di risposta per i modelli AI21 Labs. Utilizza queste informazioni per effettuare chiamate di inferenza ai modelli AI21 Labs con le operazioni [InvokeModel](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModel.html) e [InvokeModelWithResponseStream](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModelWithResponseStream.html) (streaming). Questa sezione include anche esempi di codice Python che mostrano come chiamare i modelli AI21 Labs. Per utilizzare un modello in un’operazione di inferenza, è necessario l’ID modello per il modello. Per ottenere l’ID modello, consulta [Modelli di fondazione supportati in Amazon Bedrock](models-supported.md). Alcuni modelli funzionano anche con l’[API Converse](conversation-inference.md). Per verificare se l’API Converse supporta un modello AI21 Labs specifico, consulta [Modelli e funzionalità del modello supportati](conversation-inference-supported-models-features.md). Per ulteriori esempi di codice, consulta [Esempi di codice per l'utilizzo di Amazon Bedrock AWS SDKs](service_code_examples.md).
I modelli di fondazione in Amazon Bedrock supportano modalità di input e output, che variano da modello a modello. Per verificare le modalità supportate dai modelli AI21 Labs, consulta [Modelli di fondazione supportati in Amazon Bedrock](models-supported.md). Per verificare quali funzionalità di Amazon Bedrock sono supportate dai modelli AI21 Labs, consulta [Modelli di fondazione supportati in Amazon Bedrock](models-supported.md). Per verificare in quali Regioni AWS i modelli AI21 Labs sono disponibili, consulta [Modelli di fondazione supportati in Amazon Bedrock](models-supported.md).
Quando effettui chiamate di inferenza con modelli AI21 Labs, includi un prompt per il modello. Per informazioni generali sulla creazione di prompt per i modelli supportati da Amazon Bedrock, consulta [Concetti di progettazione dei prompt](prompt-engineering-guidelines.md). Per informazioni sui prompt specifiche di AI21 Labs, consulta la [Guida alla progettazione dei prompt di AI21 Labs](https://docs.ai21.com/docs/prompt-engineering).
**Topics**
+ [Modelli AI21 Labs Jurassic-2](model-parameters-jurassic2.md)
+ [Modelli AI21 Labs Jamba](model-parameters-jamba.md)
# Modelli AI21 Labs Jurassic-2
In questa sezione vengono forniti i parametri di inferenza e un esempio di codice per l’utilizzo dei modelli AI21 Labs AI21 Labs Jurassic-2.
**Topics**
+ [Parametri di inferenza](#model-parameters-jurassic2-request-response)
+ [esempio di codice](#api-inference-examples-a2i-jurassic)
## Parametri di inferenza
I modelli AI21 Labs Jurassic-2 supportano i seguenti parametri di inferenza.
**Topics**
+ [Casualità e diversità](#model-parameters-jurassic2-random)
+ [Lunghezza](#model-parameters-jurassic2-length)
+ [Ripetizioni](#model-parameters-jurassic2-reps)
+ [Campo del corpo della richiesta per l’invocazione del modello](#model-parameters-jurassic2-request-body)
+ [Campo del corpo della risposta per l’invocazione del modello](#model-parameters-jurassic2-response-body)
### Casualità e diversità
I modelli AI21 Labs Jurassic-2 supportano i seguenti parametri per controllare la casualità e la diversità nella risposta.
+ **Temperatura** (`temperature`): utilizza un valore più basso per ridurre la randomizzazione nella risposta.
+ **Top P** (`topP`): utilizza un valore più basso per ignorare le opzioni meno probabili.
### Lunghezza
I modelli AI21 Labs Jurassic-2 supportano i seguenti parametri per controllare la lunghezza della risposta generata.
+ **Lunghezza di completamento massima** (`maxTokens`): specifica il numero massimo di token da utilizzare nella risposta generata.
+ **Sequenze di arresto** (`stopSequences`): configura le sequenze di arresto che il modello riconosce e dopo le quali smette di generare ulteriori token. Premi il tasto Invio per inserire un carattere di nuova riga in una sequenza di arresto. Utilizza il tasto Tab per completare l’inserimento di una sequenza di arresto.
### Ripetizioni
I modelli AI21 Labs Jurassic-2 supportano i seguenti parametri per controllare le ripetizioni nella risposta generata.
+ **Penalità di presenza** (`presencePenalty`): utilizza un valore più alto per ridurre la probabilità di generare nuovi token che compaiono già almeno una volta nel prompt o nel completamento.
+ **Penalità di conteggio** (`countPenalty`): utilizza un valore più alto per ridurre la probabilità di generare nuovi token che compaiono già almeno una volta nel prompt o nel completamento. Proporzionale al numero di ricorrenze.
+ **Penalità di frequenza** (`frequencyPenalty`): utilizza un valore più alto per ridurre la probabilità di generare nuovi token che compaiono già almeno una volta nel prompt o nel completamento. Il valore è proporzionale alla frequenza di ricorrenza dei token (normalizzata in base alla lunghezza del testo).
+ **Penalizza token speciali**: riduce la probabilità di ripetere caratteri speciali. I valori predefiniti sono `true`.
+ **Spazi** (`applyToWhitespaces`): un valore `true` applica la penalità agli spazi bianchi e alle nuove righe.
+ **Punteggiatura** (`applyToPunctuation`): un valore `true` applica la penalità alla punteggiatura.
+ **Numeri** (`applyToNumbers`): un valore `true` applica la penalità ai numeri.
+ **Stop word** (`applyToStopwords`): un valore `true` applica la penalità alle stop word.
+ **Emoji** (`applyToEmojis`): un valore `true` esclude gli emoji dalla penalità.
### Campo del corpo della richiesta per l’invocazione del modello
Quando esegui una chiamata [InvokeModel](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModel.html) o [InvokeModelWithResponseStream](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModelWithResponseStream.html) utilizzando un modello AI21 Labs, inserisci nel campo `body` un oggetto JSON conforme a quello seguente. Inserisci il prompt nel campo `prompt`.
```
{
"prompt": string,
"temperature": float,
"topP": float,
"maxTokens": int,
"stopSequences": [string],
"countPenalty": {
"scale": float
},
"presencePenalty": {
"scale": float
},
"frequencyPenalty": {
"scale": float
}
}
```
Per penalizzare i token speciali, aggiungi i campi a uno qualsiasi degli oggetti di penalità. Ad esempio, puoi modificare il campo `countPenalty` come segue.
```
"countPenalty": {
"scale": float,
"applyToWhitespaces": boolean,
"applyToPunctuations": boolean,
"applyToNumbers": boolean,
"applyToStopwords": boolean,
"applyToEmojis": boolean
}
```
La tabella che segue mostra i valori minimo, massimo e predefinito per i parametri numerici.
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/bedrock/latest/userguide/model-parameters-jurassic2.html)
### Campo del corpo della risposta per l’invocazione del modello
Per informazioni sul formato del campo `body` nella risposta, consulta [https://docs.ai21.com/reference/j2-complete-api-ref](https://docs.ai21.com/reference/j2-complete-api-ref).
**Nota**
Amazon Bedrock restituisce l’identificatore di risposta (`id`) come valore intero.
## esempio di codice
Questo esempio mostra come chiamare il modello *A2I AI21 Labs Jurassic-2 Mid*.
```
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'))
```
# Modelli AI21 Labs Jamba
Questa sezione fornisce parametri di inferenza e un esempio di codice per l’utilizzo dei modelli Jamba di AI21 Labs.
**Topics**
+ [Campi obbligatori](#model-parameters-jamba-required-fields)
+ [Parametri di inferenza](#model-parameters-jamba-request-response)
+ [Campo del corpo della richiesta per l'invocazione del modello](#model-parameters-jamba-request-body)
+ [Campo del corpo della risposta per l'invocazione del modello](#model-parameters-jamba-response-body)
+ [esempio di codice](#api-inference-examples-a2i-jamba)
+ [Esempio di codice per Jamba 1.5 Large](#api-inference-examples-a2i-jamba15-large)
## Campi obbligatori
I modelli Jamba di AI21 Labs supportano i seguenti campi obbligatori:
+ **Messaggi** (`messages`): i messaggi precedenti di questa chat, dal meno recente (indice 0) al più recente. Deve avere almeno un messaggio di un utente o un assistente nell’elenco. Include sia gli input dell’utente che le risposte del sistema. La dimensione totale massima per l’elenco è di circa 256.000 token. Ciascun messaggio include i seguenti membri:
+ **Ruolo** (`role`): il ruolo dell’autore del messaggio. Uno dei seguenti valori:
+ **Utente** (`user`): input fornito dall’utente. Tutte le istruzioni fornite qui che sono in conflitto con quelle fornite nel prompt `system` hanno precedenza sulle istruzioni del prompt `system`.
+ **Assistente** (`assistant`): risposta generata dal modello.
+ **Sistema** (`system`): istruzioni iniziali fornite al sistema per indicazioni generali sul tono e sulla voce del messaggio generato. Un messaggio di sistema iniziale è facoltativo, ma consigliato per fornire indicazioni sul tono della chat. Ad esempio, “Sei un chatbot utile con un background in scienze della terra e un affascinante accento francese”.
+ **Contenuto** (`content`): contenuto del messaggio.
## Parametri di inferenza
I modelli Jamba di AI21 Labs supportano i seguenti parametri di inferenza.
**Topics**
+ [Casualità e diversità](#model-parameters-jamba-random)
+ [Lunghezza](#model-parameters-jamba-length)
+ [Ripetizioni](#model-parameters-jamba-reps)
### Casualità e diversità
I modelli Jamba di AI21 Labs supportano i seguenti parametri per controllare la casualità e la diversità nella risposta.
+ **Temperatura** (`temperature`): quantità di variazione da fornire in ciascuna risposta. L’impostazione di questo valore su 0 garantisce sempre la stessa risposta alla stessa domanda. L’impostazione di un valore più alto incoraggia una maggiore variazione. Modifica la distribuzione da cui vengono campionati i token. Impostazione predefinita: 1.0, intervallo: 0,0 - 2,0
+ **Top P** (`top_p`): limita il pool di token successivi in ogni fase al primo N percentile di token possibili, dove 1.0 indica il pool di tutti i token possibili e 0,01 indica il pool dei soli token successivi più probabili.
### Lunghezza
I modelli Lambda di AI21 Labs supportano i seguenti parametri per controllare la lunghezza della risposta generata.
+ **Lunghezza massima di completamento** (`max_tokens`): numero massimo di token consentiti per ogni messaggio di risposta generato. In genere, il modo migliore per limitare la lunghezza dell’output consiste nell’inserire un limite di lunghezza nel prompt di sistema (ad esempio, “limita le risposte a tre frasi”). Impostazione predefinita: 4.096, intervallo: 0 - 4.096.
+ **Sequenze di arresto** (`stop`): termina il messaggio quando il modello genera una di queste stringhe. La sequenza di arresto non è inclusa nel messaggio generato. Ogni sequenza può avere una lunghezza massima di 64 KB e contenere nuove righe come caratteri \$1n.
Esempi:
+ Singola stringa di arresto con una parola e un punto: “scimmie.”
+ Stringhe di arresto multiple e una nuova riga: ["gatto", "cane", " .", "\$1\$1\$1\$1", "\$1n"]
+ **Numero di risposte** (`n`): numero di risposte della chat da generare. Note: n deve essere 1 per le risposte in streaming. Se n è impostato su un valore maggiore di 1, l’impostazione di `temperature=0` ha sempre esito negativo perché tutte le risposte saranno garantite come duplicati. Impostazione predefinita: 1, intervallo: 1-16
### Ripetizioni
I modelli Jamba di AI21 Labs supportano i seguenti parametri per controllare le ripetizioni nella risposta generata.
+ **Penalità di frequenza** (`frequency_penalty`): riduce la frequenza delle parole ripetute all’interno di un singolo messaggio di risposta aumentando questo numero. Tale penalità aumenta gradualmente quanto più spesso compare una parola durante la generazione della risposta. L’impostazione su 2.0 produce una stringa con poche parole ripetute, se non addirittura nessuna.
+ **Penalità di presenza** (`presence_penalty`): riduce la frequenza delle parole ripetute all’interno di un singolo messaggio aumentando questo numero. A differenza della penalità di frequenza, la penalità di presenza è la stessa, indipendentemente dal numero di volte in cui appare una parola.
## Campo del corpo della richiesta per l'invocazione del modello
Quando esegui una chiamata [InvokeModel](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModel.html) o [InvokeModelWithResponseStream](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModelWithResponseStream.html) utilizzando un modello AI21 Labs, inserisci nel campo `body` un oggetto JSON conforme a quello seguente. Inserisci il prompt nel campo `prompt`.
```
{
"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
}
```
## Campo del corpo della risposta per l'invocazione del modello
Per informazioni sul formato del campo `body` nella risposta, consulta [https://docs.ai21.com/reference/jamba-instruct-api\$1response-details](https://docs.ai21.com/reference/jamba-instruct-api#response-details).
## esempio di codice
Questo esempio mostra come chiamare il modello *AI21 Labs Jamba-Instruct*.
**`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))
```
## Esempio di codice per Jamba 1.5 Large
Questo esempio mostra come chiamare il modello *AI21 Labs Jamba 1.5 Large*.
**`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
}
```
# Modelli Cohere
Questa sezione descrive i parametri di richiesta e i campi di risposta per i modelli Cohere. Utilizza queste informazioni per effettuare chiamate di inferenza ai modelli Cohere con le operazioni [InvokeModel](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModel.html) e [InvokeModelWithResponseStream](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModelWithResponseStream.html) (streaming). Questa sezione include anche esempi di codice Python che mostrano come chiamare i modelli Cohere. Per utilizzare un modello in un’operazione di inferenza, è necessario l’ID modello per il modello. Per ottenere l’ID modello, consulta [Modelli di fondazione supportati in Amazon Bedrock](models-supported.md). Alcuni modelli funzionano anche con l’[API Converse](conversation-inference.md). Per verificare se l’API Converse supporta un modello Cohere specifico, consulta [Modelli e funzionalità del modello supportati](conversation-inference-supported-models-features.md). Per ulteriori esempi di codice, consulta [Esempi di codice per l'utilizzo di Amazon Bedrock AWS SDKs](service_code_examples.md).
I modelli di fondazione in Amazon Bedrock supportano modalità di input e output, che variano da modello a modello. Per verificare le modalità supportate dai modelli Cohere, consulta [Modelli di fondazione supportati in Amazon Bedrock](models-supported.md). Per verificare quali funzionalità di Amazon Bedrock sono supportate dai modelli Cohere, consulta [Modelli di fondazione supportati in Amazon Bedrock](models-supported.md). Per verificare in quali Regioni AWS i modelli Cohere sono disponibili, consulta [Modelli di fondazione supportati in Amazon Bedrock](models-supported.md).
Quando effettui chiamate di inferenza con modelli Cohere, includi un prompt per il modello. Per informazioni generali sulla creazione di prompt per i modelli supportati da Amazon Bedrock, consulta [Concetti di progettazione dei prompt](prompt-engineering-guidelines.md). Per informazioni sui prompt specifiche di Cohere, consulta la [Guida alla progettazione dei prompt di Cohere](https://txt.cohere.com/how-to-train-your-pet-llm-prompt-engineering).
**Topics**
+ [Modelli Cohere Command](model-parameters-cohere-command.md)
+ [modelli Cohere Embed e Cohere Embed v4](model-parameters-embed.md)
+ [Cohere Command R e modelli Command R\$1](model-parameters-cohere-command-r-plus.md)
# Modelli Cohere Command
Le richieste di inferenza a un modelli Cohere Command vengono effettuate con [InvokeModel](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModel.html) o [InvokeModelWithResponseStream](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModelWithResponseStream.html) (streaming). È necessario l'ID modello per il modello che desideri utilizzare. Per ottenere l’ID modello, consulta [Modelli di fondazione supportati in Amazon Bedrock](models-supported.md).
**Topics**
+ [Richiesta e risposta](#model-parameters-cohere-command-request-response)
+ [esempio di codice](#api-inference-examples-cohere-command)
## Richiesta e risposta
------
#### [ Request ]
I modelli Cohere Command hanno i seguenti parametri di inferenza.
```
{
"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"
}
```
I seguenti sono parametri obbligatori.
+ **prompt** (obbligatorio): testo di input che funge da punto di partenza per la generazione della risposta.
Di seguito sono riportati i limiti di testo per chiamata e carattere.
**Testi per chiamata**
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/bedrock/latest/userguide/model-parameters-cohere-command.html)
**Caratteri**
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/bedrock/latest/userguide/model-parameters-cohere-command.html)
I seguenti sono parametri opzionali.
+ **return\$1likelihoods**: specifica come e se vengono restituite probabilità di token con la risposta. Puoi specificare le seguenti opzioni.
+ `GENERATION`: restituisce solo le verosimiglianze per i token generati.
+ `ALL`: restituisce le verosimiglianze per tutti i token.
+ `NONE`: (impostazione predefinita) non restituisce nessuna verosimiglianza.
+ **stream** (obbligatorio per supportare lo streaming): specifica `true` per restituire la risposta punto per punto in tempo reale e `false` per restituire la risposta completa al termine del processo.
+ **logit\$1bias**: impedisce al modello di generare token indesiderati o incentiva il modello a includere i token desiderati. Il formato è `{token_id: bias}`, dove bias è un numero a decimale mobile compreso tra -10 e 10. I token possono essere ottenuti dal testo utilizzando qualsiasi servizio di tokenizzazione, come l’endpoint Tokenize di Cohere. Per ulteriori informazioni, consulta la [documentazione di Cohere](https://docs.cohere.com/docs).
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/bedrock/latest/userguide/model-parameters-cohere-command.html)
+ **num\$1generations**: numero massimo di generazioni che il modello deve restituire.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/bedrock/latest/userguide/model-parameters-cohere-command.html)
+ **truncate**: specifica in che modo l’API gestisce gli input maggiori della lunghezza massima del token. Utilizzare una delle seguenti operazioni:
+ `NONE`: restituisce un errore quando l'input supera la lunghezza massima del token di input.
+ `START`: elimina l'inizio dell'input.
+ `END`: (impostazione predefinita) elimina la fine dell'input.
Se specifichi `START` o`END`, il modello elimina l'input finché quello rimanente non raggiunge esattamente la lunghezza massima del token di input per il modello.
+ **temperature**: utilizza un valore più basso per ridurre la randomizzazione nella risposta.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/bedrock/latest/userguide/model-parameters-cohere-command.html)
+ **p**: Top P. Utilizza un valore più basso per ignorare le opzioni meno probabili. Imposta 0 o 1,0 per disabilitare questa funzionalità. Se `p` e `k` sono entrambi abilitati, `p` agisce dopo `k`.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/bedrock/latest/userguide/model-parameters-cohere-command.html)
+ **k**: Top K. Specifica il numero di scelte di token utilizzate dal modello per generare il token successivo. Se `p` e `k` sono entrambi abilitati, `p` agisce dopo `k`.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/bedrock/latest/userguide/model-parameters-cohere-command.html)
+ **max\$1tokens**: specifica il numero massimo di token da utilizzare nella risposta generata.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/bedrock/latest/userguide/model-parameters-cohere-command.html)
+ **stop\$1sequences**: configura fino a quattro sequenze riconosciute dal modello. Dopo una sequenza di arresto, il modello smette di generare altri token. Il testo restituito non contiene la sequenza di arresto.
------
#### [ Response ]
La risposta ha i seguenti campi possibili:
```
{
"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`: un elenco dei risultati generati insieme alle verosimiglianze dei token richiesti. Viene restituito sempre. Ogni oggetto di generazione nell'elenco contiene i seguenti campi.
+ `id`: un identificatore per la generazione. Viene restituito sempre.
+ `likelihood`: la verosimiglianza dell'output. Il valore è la media delle verosimiglianze dei token in `token_likelihoods`. Restituito se specifichi il parametro di input `return_likelihoods`.
+ `token_likelihoods`: un array di verosimiglianze dei token. Restituito se specifichi il parametro di input `return_likelihoods`.
+ `finish_reason`: motivo per cui il modello ha smesso di generare token. `COMPLETE`: il modello ha restituito una risposta completa. `MAX_TOKENS`: la risposta è stata tagliata perché il modello ha raggiunto il numero massimo di token per la lunghezza del contesto. `ERROR `: si è verificato un errore durante la generazione della risposta. `ERROR_TOXIC`: il modello ha generato una risposta ritenuta tossica. `finish_reason` viene restituito solo quando `is_finished`=`true`. Non viene restituito sempre.
+ `is_finished`: un campo booleano usato solo quando `stream` è `true`, a indicare se esistono o meno altri token che verranno generati come parte della risposta in streaming. Non viene restituito sempre.
+ `text`: il testo generato.
+ `index`: da utilizzare in una risposta in streaming per stabilire a quale generazione appartiene un determinato token. Se viene trasmessa una sola risposta, tutti i token appartengono alla stessa generazione e l'indice non viene restituito. Di conseguenza, `index` viene restituito solo in una richiesta di streaming con un valore `num_generations` maggiore di uno.
+ `prompt`: prompt della richiesta di input (sempre restituito).
+ `id`: un identificatore per la richiesta. Viene restituito sempre.
Per ulteriori informazioni, consulta [Generate](https://docs.cohere.com/reference/generate-1) nella documentazione di Cohere.
------
## esempio di codice
Questo esempio mostra come chiamare il modello *Cohere Command*.
```
# 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()
```
# modelli Cohere Embed e Cohere Embed v4
Fai richieste di inferenza a un modello Embed con [InvokeModel](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModel.html) È necessario l’ID modello per il modello che desideri utilizzare. Per ottenere l’ID modello, consulta [Modelli di fondazione supportati in Amazon Bedrock](models-supported.md).
**Nota**
Amazon Bedrock non supporta lo streaming di risposte dai modelli Cohere Embed.
**Topics**
+ [Cohere Embed v4](model-parameters-embed-v4.md)
+ [Cohere Embed v3](model-parameters-embed-v3.md)
# Cohere Embed v4
Cohere Embed v4 è un modello di embedding multimodale che supporta input di testo e immagini. È in grado di elaborare contenuti interlacciati di testo e immagini ed è quindi ideale per le applicazioni di comprensione di documenti, di ricerca visiva e di recupero multimodale. Il modello supporta vari tipi di embedding, tra cui i formati float, int8, uint8, binary e ubinary, con dimensioni di output configurabili da 256 a 1536.
L’ID modello per Cohere Embed v4 è `cohere.embed-v4`.
**Note per l’utilizzo aggiuntive**
+ **Lunghezza del contesto:** sono supportati fino a \$1128.000 token; in caso di RAG, blocchi più piccoli spesso migliorano il recupero e i costi.
+ **Dimensionamento delle immagini:** le immagini con più di 2.458.624 pixel vengono sottocampionate fino a quelle dimensioni; le immagini con meno di 3.136 pixel vengono sovracampionate.
+ **Input interlacciati:** si preferisce il formato inputs.content[] per contenuti multimodali simili a pagine in modo che il contesto del testo, ad esempio nome file o entità, sia gestito con l’immagine.
**Topics**
+ [Richiesta e risposta](#model-parameters-embed-v4-request-response)
+ [Richiesta e risposta per diversi elementi input\$1types](#api-inference-examples-cohere-embed-v4)
+ [Codici di esempio](#code-examples-cohere-embed-v4)
## Richiesta e risposta
------
#### [ Request ]
Tipo di contenuto: 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** (necessario): aggiunge token speciali per distinguere i casi d’uso. Valori consentiti: `search_document`, `search_query`, `classification`, `clustering`. Per ricerca/RAG, integra il corpus con `search_document` e le query con `search_query`.
+ **texts** (facoltativo): array di stringhe da incorporare. Il numero massimo per chiamata è 96. Se utilizzi `texts`, non inviare `images` nella stessa chiamata.
+ **images** (facoltativo): array di immagini con URI dati base64 da incorporare. Il numero massimo per chiamata è 96. Non inviare `texts` e `images` insieme. Usa `inputs` per l’interlacciamento.
+ **ingressi** (opzionale; mixed/fused modalità) — Un elenco in cui ogni elemento ha un elenco di parti di contenuto. Ogni parte è `{ "type": "text", "text": ... }` o `{ "type": "image_url", "image_url": {"url": "data:;base64,..."} }`. Invia qui contenuti interlacciati simili a pagine (ad esempio l’immagine della pagina PDF più didascalia/metadati). Il numero massimo di elementi è 96.
+ **embedding\$1types** (facoltativo): uno o più dei valori `float`, `int8`, `uint8`, `binary`, `ubinary`. Se omesso, restituisce embedding di tipo float.
+ **output\$1dimension** (facoltativo): determina la lunghezza del vettore. Valori consentiti: `256`, `512`, `1024`, `1536` (se non specificato, il valore predefinito è `1536`).
+ **max\$1tokens** (facoltativo): budget per il troncamento per oggetto di input. Il modello supporta fino a \$1128.000 token; blocchi più piccoli per RAG, se appropriato.
+ **truncate** (facoltativo): consente di gestire gli input di lunghezza eccessiva. I valori consentiti sono: `LEFT` (elimina i token a partire dall’inizio), `RIGHT` (elimina i token a partire dalla fine), `NONE` (restituisce un errore se l’input supera il limite).
**Limiti e dimensionamento**
+ Elementi per richiesta: fino a 96 immagini. Il tipo di file di immagine originale deve essere png, jpeg, webp o gif e può avere una dimensione massima di 5 MB.
+ Dimensione massima della richiesta: \$120 MB di payload totale.
+ Numero massimo di token di input: 128.000 token. I file di immagine vengono convertiti in token, il cui totale deve essere inferiore a 128.000.
+ Immagini: massimo 2.458.624 pixel prima del sottocampionamento; le immagini di dimensioni inferiori a 3.136 pixel vengono sovracampionate. Le immagini devono essere fornite come `data:;base64,....`
+ Conteggio dei token (per elemento `inputs`): token provenienti da un input di immagine ≈ (pixel dell’immagine ÷ 784) x 4 token da un input di testo e immagine interlacciati = (pixel dell’immagine ÷ 784) x 4 \$1 (token di testo)
**Suggerimento:** ad esempio PDFs, converti ogni pagina in un'immagine e inviala `inputs` insieme ai metadati della pagina (ad esempio, file\$1name, entità) nelle parti di testo adiacenti.
------
#### [ Response ]
Tipo di contenuto: application/json
Se è stato richiesto un solo tipo di embedding, ad esempio solo `float`:
```
{
"id": "string",
"embeddings": [[ /* length = output_dimension */ ]],
"response_type": "embeddings_floats",
"texts": ["..."], // present if text was provided
"inputs": [ { "content": [ ... ] } ] // present if 'inputs' was used
}
```
Se sono stati richiesti più tipi di embedding, ad esempio `["float","int8"]`:
```
{
"id": "string",
"embeddings": {
"float": [[ ... ]],
"int8": [[ ... ]]
},
"response_type": "embeddings_by_type",
"texts": ["..."], // when text used
"inputs": [ { "content": [ ... ] } ] // when 'inputs' used
}
```
+ Il numero di vettori restituiti corrisponde alla lunghezza dell’array `texts`o al numero di elementi `inputs`.
+ La lunghezza di ogni vettore è uguale a `output_dimension` (valore predefinito `1536`).
------
## Richiesta e risposta per diversi elementi input\$1types
**A) Pagina interlacciata (immagine \$1 didascalia) con vettori int8 compatti**
**Richiesta**
```
{
"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
}
```
**Risposta (troncata)**
```
{
"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) Indicizzazione del corpus in solo testo (valori predefiniti: float, dimensioni 1536)**
**Richiesta**
```
{
"input_type": "search_document",
"texts": [
"RAG system design patterns for insurance claims",
"Actuarial loss triangles and reserving primer"
]
}
```
**Risposta (esempio)**
```
{
"response_type": "embeddings_floats",
"embeddings": [
[0.0135, -0.0272, ...], // length 1536
[0.0047, 0.0189, ...]
]
}
```
## Codici di esempio
------
#### [ 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**
+ [Richiesta e risposta](#model-parameters-embed-v3-request-response)
+ [esempio di codice](#api-inference-examples-cohere-embed-v3)
## Richiesta e risposta
------
#### [ Request ]
I modelli Cohere Embed hanno i seguenti parametri di inferenza.
```
{
"input_type": "search_document|search_query|classification|clustering|image",
"texts":[string],
"images":[image_base64_image_uri]
"truncate": "NONE|START|END",
"embedding_types": embedding_types
}
```
I seguenti sono parametri obbligatori.
+ **texts**: un array di stringhe da incorporare nel modello. Per prestazioni ottimali, consigliamo di ridurre la lunghezza di ogni testo a meno di 512 token. 1 token corrisponde a circa 4 caratteri.
Di seguito sono riportati i limiti di testo per chiamata e per carattere.
**Testi per chiamata**
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/bedrock/latest/userguide/model-parameters-embed-v3.html)
**Caratteri**
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/bedrock/latest/userguide/model-parameters-embed-v3.html)
+ **input\$1type**: aggiunto all’inizio dei token speciali per differenziare i vari tipi. Non conviene mischiare tipi diversi, tranne quelli per la ricerca e il recupero. In questo caso, incorpora il corpus con il tipo `search_document` e le query incorporate con il tipo `search_query`.
+ `search_document`: nei casi d’uso legati alla ricerca, utilizza `search_document` per codificare i documenti per gli embedding archiviati in un database vettoriale.
+ `search_query`: utilizza `search_query` per interrogare il database vettoriale al fine di trovare i documenti pertinenti.
+ `classification`: utilizza `classification` quando gli incorporamenti sono usati come input per un classificatore di testo.
+ `clustering`: utilizza `clustering` per raggruppare gli incorporamenti.
+ `images`: array di immagini.
+ Un array di URI di dati immagine che il modello deve incorporare. Il numero massimo di immagini per chiamata è 1 (ovvero, il modello supporta solo un’input dell’immagine).
+ L’immagine deve essere un URI dati valido. L’immagine deve essere in formato image/jpeg o image/png e avere una dimensione massima di 5 MB.
+ È necessario fornire solo uno dei due elementi: “immagini” o “testi”.
I seguenti sono parametri opzionali:
+ **truncate**: specifica in che modo l’API gestisce gli input maggiori della lunghezza massima del token. Utilizzare una delle seguenti operazioni:
+ `NONE`: (impostazione predefinita) restituisce un errore quando l’input supera la lunghezza massima del token di input.
+ `START`: elimina l’inizio dell’input.
+ `END`: elimina la fine dell’input.
Se specifichi `START` o`END`, il modello elimina l’input finché quello rimanente non raggiunge esattamente la lunghezza massima del token di input per il modello.
+ **embedding\$1types**: specifica i tipi di embedding che devono essere restituiti. Facoltativo e predefinito è `None`, che restituisce il tipo di risposta `Embed Floats`. Può essere uno o più dei seguenti tipi:
+ `float`: utilizza questo valore per restituire gli embedding float predefiniti.
+ `int8`: utilizza questo valore per restituire gli embedding int8 firmati.
+ `uint8`: utilizza questo valore per restituire gli embedding int8 firmati.
+ `binary`: utilizza questo valore per restituire gli embedding binari firmati.
+ `ubinary`: utilizza questo valore per restituire gli embedding binari non firmati.
Per ulteriori informazioni, consulta [https://docs.cohere.com/reference/embed](https://docs.cohere.com/reference/embed) nella documentazione Cohere.
------
#### [ Response ]
Di seguito è riportata la risposta `body` da una chiamata `InvokeModel`.
```
{
"embeddings": [
[ array of 1024 floats. ]
],
"id": string,
"response_type" : "embeddings_floats,
"texts": [string],
"images": [image_description]
}
```
La risposta `body` ha i seguenti campi possibili:
+ **id**: un identificatore per la risposta.
+ **response\$1type**: il tipo di risposta. Questo valore è sempre `embeddings_floats`.
+ **embeddings**: un array di incorporamenti, ognuno dei quali è un array di numeri a virgola mobile con 1024 elementi. La lunghezza dell’array `embeddings` sarà uguale alla lunghezza dell’array `texts` originale.
+ **texts**: un array contenente le voci di testo per le quali sono stati restituiti incorporamenti.
+ **images**: un array di una descrizione per ogni input dell’immagine.
Un `image_description`image\$1description ha il seguente formato:
```
{
"width": long,
"height": long,
"format": string,
"bit_depth": long
}
```
Se l’immagine è stata utilizzata come input, il campo di risposta `“texts”` sarà un array vuoto. Il contrario non è vero (ovvero, quando si utilizzano testi, `“images”` non saranno nella risposta)
Per ulteriori informazioni, consulta [https://docs.cohere.com/reference/embed](https://docs.cohere.com/reference/embed).
------
## esempio di codice
Questo esempio mostra come chiamare il modello *Cohere Embed English*.
```
# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
# SPDX-License-Identifier: Apache-2.0
"""
Shows how to generate text embeddings using the Cohere Embed English model.
"""
import json
import logging
import boto3
from botocore.exceptions import ClientError
logger = logging.getLogger(__name__)
logging.basicConfig(level=logging.INFO)
def generate_text_embeddings(model_id, body, region_name):
"""
Generate text embedding by using the Cohere Embed model.
Args:
model_id (str): The model ID to use.
body (str) : The reqest body to use.
region_name (str): The AWS region to invoke the model on
Returns:
dict: The response from the model.
"""
logger.info("Generating text embeddings with the Cohere Embed model %s", model_id)
accept = '*/*'
content_type = 'application/json'
bedrock = boto3.client(service_name='bedrock-runtime', region_name=region_name)
response = bedrock.invoke_model(
body=body,
modelId=model_id,
accept=accept,
contentType=content_type
)
logger.info("Successfully generated embeddings with Cohere model %s", model_id)
return response
def main():
"""
Entrypoint for Cohere Embed example.
"""
logging.basicConfig(level=logging.INFO, format="%(levelname)s: %(message)s")
region_name = 'us-east-1'
model_id = 'cohere.embed-english-v3'
text1 = "hello world"
text2 = "this is a test"
input_type = "search_document"
embedding_types = ["int8", "float"]
try:
body = json.dumps({
"texts": [
text1,
text2],
"input_type": input_type,
"embedding_types": embedding_types
})
response = generate_text_embeddings(model_id=model_id, body=body, region_name=region_name)
response_body = json.loads(response.get('body').read())
print(f"ID: {response_body.get('id')}")
print(f"Response type: {response_body.get('response_type')}")
print("Embeddings")
embeddings = response_body.get('embeddings')
for i, embedding_type in enumerate(embeddings):
print(f"\t{embedding_type} Embeddings:")
print(f"\t{embeddings[embedding_type]}")
print("Texts")
for i, text in enumerate(response_body.get('texts')):
print(f"\tText {i}: {text}")
except ClientError as err:
message = err.response["Error"]["Message"]
logger.error("A client error occurred: %s", message)
print("A client error occured: " +
format(message))
else:
print(
f"Finished generating text embeddings with Cohere model {model_id}.")
if __name__ == "__main__":
main()
```
**Input dell’immagine**
```
# 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()
```
# Cohere Command R e modelli Command R\$1
Per inviare richieste di inferenza a modelli Cohere Command R e Cohere Command R\$1 con [InvokeModel](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModel.html) o [InvokeModelWithResponseStream](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModelWithResponseStream.html) (streaming), è necessario l’ID modello da utilizzare. Per ottenere l’ID modello, consulta [Modelli di fondazione supportati in Amazon Bedrock](models-supported.md).
**Suggerimento**
Per le applicazioni conversazionali, consigliamo di utilizzare l’API Converse. L’API Converse fornisce un set unificato di parametri che funzionano su tutti i modelli che supportano i messaggi. Per ulteriori informazioni, consultate [Avvio di una conversazione con le operazioni dell’API Converse](conversation-inference.md).
**Topics**
+ [Richiesta e risposta](#model-parameters-cohere-command-request-response)
+ [Esempio di codice](#api-inference-examples-cohere-command-r)
## Richiesta e risposta
------
#### [ Request ]
I modelli Cohere Command hanno i seguenti parametri di inferenza.
```
{
"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
}
```
I seguenti parametri sono obbligatori.
+ **message**: (obbligatorio) input di testo a cui il modello deve rispondere.
I seguenti parametri sono facoltativi.
+ **chat\$1history**: elenco di messaggi precedenti tra l’utente e il modello, destinato a fornire al modello un contesto conversazionale per rispondere al messaggio dell’utente.
I seguenti campi sono obbligatori.
+ `role`: il ruolo del messaggio. I valori validi sono i token `USER` o `CHATBOT`.
+ `message`: contenuti di testo del messaggio.
Di seguito è riportato un esempio di JSON per il campo `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**: elenco di testi che il modello può citare per generare una risposta più accurata. Ogni documento è un dizionario di stringhe. La generazione risultante include citazioni che fanno riferimento ad alcuni di questi documenti. È consigliabile mantenere il numero totale di parole delle stringhe nel dizionario inferiore a 300. Facoltativamente è possibile specificare un campo `_excludes` (array di stringhe) per fare in modo che alcune coppie chiave-valore non vengano mostrate al modello. Per ulteriori informazioni sui documenti, consultare la guida [Document Mode](https://docs.cohere.com/docs/retrieval-augmented-generation-rag#document-mode) nella documentazione di Cohere.
Di seguito è riportato un esempio di JSON per il campo `documents`.
```
"documents": [
{"title": "Tall penguins", "snippet": "Emperor penguins are the tallest."},
{"title": "Penguin habitats", "snippet": "Emperor penguins only live in Antarctica."}
]
```
+ **search\$1queries\$1only**: `false` per impostazione predefinita. Se è `true`, la risposta contiene solo un elenco di query di ricerca generate, ma non viene effettuata alcuna ricerca né viene generata alcuna risposta dal modello al `message` dell’utente.
+ **preamble**: sostituisce il preambolo predefinito per la generazione delle query di ricerca. Non ha alcun effetto sulle generazioni di utilizzo degli strumenti.
+ **max\$1tokens**: numero massimo di token che il modello deve generare come parte della risposta. Tieni presente che l’impostazione di un valore basso può comportare generazioni incomplete. L’impostazione `max_tokens` può risultare in una generazione incompleta o assente se utilizzata con i campi `tools` o `documents`.
+ **temperature**: utilizza un valore più basso per ridurre la randomizzazione nella risposta. La randomizzazione può essere ulteriormente massimizzata aumentando il valore del parametro `p`.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/bedrock/latest/userguide/model-parameters-cohere-command-r-plus.html)
+ **p**: Top P. Utilizza un valore più basso per ignorare le opzioni meno probabili.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/bedrock/latest/userguide/model-parameters-cohere-command-r-plus.html)
+ **k**: Top K. Specifica il numero di scelte di token utilizzate dal modello per generare il token successivo.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/bedrock/latest/userguide/model-parameters-cohere-command-r-plus.html)
+ **prompt\$1truncation**: `OFF` per impostazione predefinita. Determina come viene creato il prompt. Con `prompt_truncation` impostato su `AUTO_PRESERVE_ORDER`, alcuni elementi di `chat_history` e `documents` verranno eliminati per creare un prompt che rientri nel limite di lunghezza del contesto del modello. Durante questo processo, l’ordine dei documenti e la cronologia delle chat verranno preservati. Con `prompt_truncation` `impostato su `OFF`, nessun elemento viene eliminato.
+ **frequency\$1penalty**: utilizzato per ridurre la ripetitività dei token generati. Più alto è il valore, più forte è la penalità applicata ai token presenti in precedenza, proporzionalmente al numero di volte in cui sono già apparsi nel prompt o nella generazione precedente.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/bedrock/latest/userguide/model-parameters-cohere-command-r-plus.html)
+ **presence\$1penalty**: utilizzato per ridurre la ripetitività dei token generati. Simile a `frequency_penalty`, tranne per il fatto che questa penalità viene applicata allo stesso modo a tutti i token che sono già apparsi, indipendentemente dalle loro frequenze esatte.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/bedrock/latest/userguide/model-parameters-cohere-command-r-plus.html)
+ **seed**: se specificato, il backend fa del suo meglio per campionare i token in modo deterministico, in modo tale che le richieste ripetute con lo stesso seme e gli stessi parametri restituiscano lo stesso risultato. Tuttavia, il determinismo non può essere totalmente garantito.
+ **return\$1prompt**: specificare `true` per restituire il prompt completo inviato al modello. Il valore predefinito è `false`. Nella risposta, il prompt nel campo `prompt`.
+ **tools**: elenco di strumenti (funzioni) disponibili che il modello può suggerire di invocare prima di produrre una risposta in formato testo. Quando `tools` viene specificato (senza`tool_results`), il campo `text` nella risposta è `""` e il campo `tool_calls` nella risposta viene compilato con un elenco di chiamate allo strumento da effettuare. Se non è necessario effettuare chiamate, l’array `tool_calls` è vuoto.
Per ulteriori informazioni, consulta [Tool Use](https://docs.cohere.com/docs/tool-use) nella documentazione di Cohere.
**Suggerimento**
È consigliabile utilizzare l’API Converse per integrare l’utilizzo dello strumento nell’applicazione. Per ulteriori informazioni, consulta [Utilizzo di uno strumento per completare una risposta al modello Amazon Bedrock](tool-use.md).
Di seguito è riportato un esempio di JSON per il campo `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
}
}
}
]
```
Per ulteriori informazioni, consulta [Single-Step Tool Use (Function Calling)](https://docs.cohere.com/docs/tool-use) nella documentazione di Cohere.
+ **tools\$1results**: elenco di risultati derivanti dall’invocazione degli strumenti consigliati dal modello nel turno di chat precedente. I risultati vengono utilizzati per produrre una risposta in formato testo e sono menzionati nelle citazioni. Se si utilizza`tool_results`, è necessario specificare anche `tools`. Ogni `tool_result` contiene informazioni su come è stato invocato, oltre a un elenco di output sotto forma di dizionari. L’esclusiva logica di citazione granulare di Cohere richiede che l’output sia un elenco. Nel caso in cui l’output sia solo un elemento, ad esempio `{"status": 200}`, deve comunque essere inserirlo in un elenco.
Per ulteriori informazioni, consulta [Tool Use](https://docs.cohere.com/docs/tool-use) nella documentazione di Cohere.
Di seguito è riportato un esempio di JSON per il campo `tools_results`.
```
[
{
"call": {
"name": "top_song",
"parameters": {
"sign": "WZPZ"
}
},
"outputs": [
{
"song": "Elemental Hotel"
}
]
}
]
```
+ **stop\$1sequences**: elenco di sequenze di arresto. Dopo una sequenza di arresto, il modello smette di generare altri token.
+ **raw\$1prompting**: specificare `true` per inviare il `message` dell’utente al modello senza alcuna preelaborazione, altrimenti false.
------
#### [ Response ]
I possibili campi per la risposta sono:
```
{
"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**: identificatore univoco per il completamento della chat
+ **text**: risposta del modello all’input del messaggio di chat.
+ **generation\$1id**: identificatore univoco per il completamento della chat, utilizzato con l’endpoint Feedback sulla piattaforma di Cohere.
+ **citations**: array di citazioni in linea e metadati associati per la risposta generata. Contiene i seguenti campi:
+ **start**: indice da cui inizia la citazione, a partire da 0.
+ **fine**: indice dopo il quale termina la citazione, a partire da 0.
+ **text**: testo a cui si riferisce la citazione.
+ **document\$1ids**: array di ID documento corrispondenti ai documenti citati per il testo.
+ **prompt**: prompt completo inviato al modello. Specificare il campo `return_prompt` campo per restituirlo.
+ **finish\$1reason**: motivo per cui il modello ha smesso di generare output. Può essere uno dei seguenti:
+ **complete**: la generazione ha raggiunto il limite massimo di token. Assicurarsi che sia il motivo della conclusione per ottenere le prestazioni migliori.
+ **error\$1toxic**: impossibile completare la generazione a causa di nostri filtri dei contenuti.
+ **error\$1limit**: impossibile completare la generazione perché è stato raggiunto il limite di contesto del modello.
+ **error**: impossibile completare la generazione a causa di un errore.
+ **user\$1cancel**: impossibile completare la generazione perché è stata interrotta dall’utente.
+ **max\$1tokens**: impossibile completare la generazione perché l’utente ha specificato un limite `max_tokens` nella richiesta e questo limite è stato raggiunto. Potrebbe non garantire le prestazioni migliori.
+ **tool\$1calls**: elenco di strumenti appropriati per le chiamate. Restituito solo se viene specificato il campo di input `tools`.
Per ulteriori informazioni, consulta [Tool Use](https://docs.cohere.com/docs/tool-use) nella documentazione di Cohere.
**Suggerimento**
È consigliabile utilizzare l’API Converse per integrare l’utilizzo dello strumento nell’applicazione. Per ulteriori informazioni, consulta [Utilizzo di uno strumento per completare una risposta al modello Amazon Bedrock](tool-use.md).
Di seguito è riportato un esempio di JSON per il campo `tool_calls`.
```
[
{
"name": "top_song",
"parameters": {
"sign": "WZPZ"
}
}
]
```
+ **meta**: dati sull’utilizzo dell’API (esistono solo per lo streaming).
+ `api_version`: versione dell’API. La versione è nel campo `version`.
+ `billed_units`: unità fatturate. I valori possibili sono:
+ `input_tokens`: numero di token di input fatturati.
+ `output_tokens`: numero di token di output fatturati.
------
## Esempio di codice
Questo esempio mostra come chiamare il modello *Cohere Command R*.
```
# 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()
```
# Modelli DeepSeek
DeepSeek[i modelli R1 e V3.1 sono text-to-text modelli disponibili per l'uso per l'inferenza tramite l'API Invoke ([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)) e l'API Converse (Converse e). [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)
Quando effettui chiamate di inferenza con modelli DeepSeek, devi includere un prompt per il modello. Per informazioni generali sulla creazione di prompt per i modelli DeepSeek supportati da Amazon Bedrock, consulta la [guida ai prompt di DeepSeek](https://api-docs.deepseek.com/guides/reasoning_model.html).
**Nota**
Non puoi rimuovere l'accesso alle richieste dai modelli Amazon Titan, Amazon Nova, DeepSeek -R1, Mistral AI, Meta Llama 3 Instruct e Meta Llama 4. Puoi impedire agli utenti di effettuare chiamate di inferenza a questi modelli utilizzando una policy IAM e specificando l’ID modello. Per ulteriori informazioni, consulta [Negare l’accesso per l’inferenza dei modelli di fondazione](https://docs.aws.amazon.com/bedrock/latest/userguide/security_iam_id-based-policy-examples.html#security_iam_id-based-policy-examples-deny-inference .html).
Per una qualità di risposta ottimale conDeepSeek-R1, limita il parametro a 8.192 token o meno. `max_tokens` Sebbene l'API accetti fino a 32.768 token, la qualità della risposta diminuisce notevolmente oltre gli 8.192 token. [Ciò è in linea con le capacità di ragionamento del modello descritte nella guida al ragionamento inferenziale.](https://docs.aws.amazon.com/bedrock/latest/userguide/inference-reasoning.html)
In questa sezione vengono descritti i parametri di richiesta e i campi di risposta per i modelli DeepSeek. Utilizzate queste informazioni per effettuare chiamate di inferenza ai DeepSeek modelli con l'operazione. [InvokeModel](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModel.html) Questa sezione include anche esempi di codice Python che mostrano come chiamare i modelli DeepSeek.
Per utilizzare un modello in un’operazione di inferenza, è necessario l’ID modello per il modello. Poiché questo modello viene invocato tramite l’inferenza tra Regioni, è necessario utilizzare l’[ID del profilo di inferenza](https://docs.aws.amazon.com/bedrock/latest/userguide/inference-profiles-support.html) come ID modello. Ad esempio, per gli Stati Uniti, utilizza `us.deepseek.r1-v1:0`.
+ Nome del modello: DeepSeek-R1
+ Modelli di testo
Per ulteriori informazioni su come utilizzare i DeepSeek modelli con APIs, consultate [DeepSeekModels](https://deepseek.com/).
**Richiesta e risposta DeepSeek**
**Corpo della richiesta**
DeepSeek include i seguenti parametri di inferenza per effettuare chiamate di inferenza Text Completions.
```
{
"prompt": string,
"temperature": float,
"top_p": float,
"max_tokens": int,
"stop": string array
}
```
**Campi:**
+ **prompt** (stringa): input di testo richiesto del prompt.
+ **temperature** (mobile): valore numerico inferiore o uguale a 1.
+ **top\$1p** (mobile): valore numerico inferiore o uguale a 1.
+ **max\$1tokens** — (int) Token utilizzati, da un minimo di 1 a un massimo di 8.192 token per una qualità ottimale. Sebbene l'API accetti fino a 32.768 token, la qualità della risposta diminuisce notevolmente oltre gli 8.192 token.
+ **stop** (array di stringhe): massimo 10 elementi.
**Corpo di risposta**
DeepSeek include i seguenti parametri di risposta per effettuare chiamate di inferenza Text Completions. Questo esempio è un completamento di testo di DeepSeek e non restituisce un blocco di ragionamento del contenuto.
```
{
"choices": [
{
"text": string,
"stop_reason": string
}
]
}
```
**Campi:**
+ **stop\$1reason** (stringa): motivo per cui la risposta ha smesso di generare testo. Valore `stop` o `length`.
+ **stop** (stringa): il modello ha terminato la generazione del testo per il prompt di input.
+ **length** (stringa): la lunghezza dei token per il testo generato supera il valore di `max_tokens` nella chiamata a `InvokeModel` (o `InvokeModelWithResponseStream`, nel caso di streaming dell’output). La risposta viene troncata in base al valore `max_tokens`. Aumenta il valore di `max_tokens` e ritenta la richiesta.
**Codice di esempio**
Questo esempio mostra come chiamare il modello DeepSeek-R1.
```
# 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 Regione AWS 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**
Corpo di richiesta: utilizza questo esempio di corpo di richiesta per chiamare l’API Converse.
```
{
"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"
}
}
```
**Campi:**
+ **system** (facoltativo): prompt di sistema per la richiesta.
+ **messages** (obbligatorio): messaggi di input.
+ **role**: ruolo del turno di conversazione. I valori validi sono `user` e `assistant`.
+ **content** (obbligatorio): contenuto del turno di conversazione, come array di oggetti. Ogni oggetto contiene un campo type, in cui è possibile specificare uno dei seguenti valori:
+ **text** (obbligatorio): se specificate questo tipo, dovete includere un campo di testo e indicare il prompt di testo come valore.
+ **inferenceConfig**
+ **temperature** (opzionale): valori: minimo = 0, massimo = 1.
+ **topP** (opzionale): valori: minimo = 0, massimo = 1.
+ **maxTokens** (facoltativo): numero massimo di token da generare prima dell’interruzione. Valori: minimo = 0, massimo = 32.768.
+ **stopSequences** (facoltativo): sequenze di testo personalizzato che interrompono la generazione di output da parte del modello. Massimo = 10 elementi.
Corpo di risposta: utilizza questo esempio di corpo di risposta per chiamare l’API Converse.
```
{
"message": {
"role" : "assistant",
"content": [
{
"text": string
},
{
"reasoningContent": {
"reasoningText": string
}
}
],
},
"stopReason": string,
"usage": {
"inputTokens": int,
"outputTokens": int,
"totalTokens": int
}
"metrics": {
"latencyMs": int
}
}
```
**Campi:**
+ **message**: risposta restituita dal modello.
+ **role**: ruolo conversazionale del messaggio generato. Il valore è sempre `assistant`.
+ **content**: contenuto generato dal modello, che viene restituito come array. Esistono due tipi di contenuto:
+ **text**: contenuto testuale della risposta.
+ **reasoningContent** (facoltativo): contenuto del ragionamento della risposta del modello.
+ **reasoningText**: testo di ragionamento della risposta del modello.
+ **stopReason**: motivo per cui il modello ha smesso di generare la risposta.
+ **end\$1turn**: turno in cui il modello ha raggiunto un punto di interruzione.
+ **max\$1tokens**: il testo generato ha superato il valore del campo di input `maxTokens` o ha superato il numero massimo di token supportati dal modello.
Codice di esempio: ecco un esempio di come DeepSeek creare una chiamata a 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()
```
# Modelli Luma AI
Questa sezione descrive i parametri di richiesta e i campi di risposta per i modelli Luma AI. Usa queste informazioni per effettuare chiamate di inferenza ai modelli di intelligenza artificiale di Luma con l'operazione. [StartAsyncInvoke](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_StartAsyncInvoke.html) Questa sezione include anche esempi di codice Python che mostrano come chiamare i modelli Luma AI. Per utilizzare un modello in un’operazione di inferenza, è necessario l’ID modello per il modello.
+ ID modello: luma.ray-v2:0
+ Nome del modello: Luma Ray 2
+ Modello da testo a video
I modelli Luma AI elaborano i prompt dei modelli in modo asincrono utilizzando Async, tra cui, e. APIs [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)
Il modello Luma AI elabora i prompt utilizzando la seguente procedura.
+ L'utente richiede [StartAsyncInvoke](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_StartAsyncInvoke.html)al modello di utilizzare.
+ Attendere che InvokeJob sia terminato. Puoi utilizzare `GetAsyncInvoke` o `ListAsyncInvokes` per controllare lo stato di completamento del processo.
+ L’output del modello viene inserito nel bucket Amazon S3 di output specificato
Per ulteriori informazioni sull'utilizzo dei modelli Luma AI con APIs, consulta [Generazione video](https://docs.lumalabs.ai/docs/video-generation).
Chiamata di inferenza 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"
}
}
}
```
**Campi**
+ **prompt** (stringa): contenuto necessario nel video di output (1 <= lunghezza <= 5.000 caratteri).
+ **aspect\$1ratio** (valore numerico) Proporzioni del video di output (“1:1”, “16:9”, “9:16”, “4:3”, “3:4”, “21:9”, “9:21”).
+ **loop** (valore booleano): indica se riprodurre in loop il video di output.
+ **duration** (valore numerico): durata del video di output (“5s”, “9s”).
+ **resolution** (valore numerico): risoluzione del video di output (“540p”, “720p”).
Il MP4 file verrà archiviato nel bucket Amazon S3 come configurato nella risposta.
## Text-to-Video Generazione
Genera video da prompt di testo utilizzando il modello Luma Ray 2. Il modello supporta varie opzioni di personalizzazione tra cui proporzioni, durata, risoluzione e loop.
** Text-to-VideoRichiesta di base**
```
{
"modelId": "luma.ray-v2:0",
"modelInput": {
"prompt": "an old lady laughing underwater, wearing a scuba diving suit"
},
"outputDataConfig": {
"s3OutputDataConfig": {
"s3Uri": "s3://your-bucket-name"
}
}
}
```
** Text-to-VideoAvanzato con opzioni**
```
{
"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"
}
}
}
```
** Text-to-VideoEsempio aggiuntivo**
Esempio con parametri di risoluzione e durata.
```
{
"modelId": "luma.ray-v2:0",
"modelInput": {
"prompt": "a car",
"resolution": "720p",
"duration": "5s"
},
"outputDataConfig": {
"s3OutputDataConfig": {
"s3Uri": "s3://your-bucket-name"
}
}
}
```
## Image-to-Video Generazione
Trasforma immagini statiche in video dinamici fornendo fotogrammi chiave. È possibile specificare fotogrammi iniziali, fotogrammi finali o entrambi per controllare il processo di generazione del video.
**Basic Image-to-Video con 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 con frame iniziale e finale**
```
{
"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"
}
}
}
```
**Parametri aggiuntivi per Image-to-Video**
+ **fotogrammi chiave** — (oggetto) Definisce i fotogrammi chiave di inizio (frame0) e and/or fine (frame1)
+ **frame0**: immagine del fotogramma chiave iniziale
+ **frame1**: immagine del fotogramma chiave finale
+ **type**: deve essere “image”
+ **source**: origine dell’immagine
## risoluzione dei problemi
Problemi e soluzioni comuni durante l’utilizzo di modelli Luma AI:
+ **Stato del processo non riuscito**: verifica che il bucket S3 disponga delle autorizzazioni di scrittura corrette e che il bucket esista nella stessa Regione del servizio Bedrock.
+ **Errori di accesso all'URL dell'immagine**: assicurati che le immagini URLs siano accessibili pubblicamente e utilizzi HTTPS. Le immagini devono essere nei formati supportati (JPEG o PNG).
+ **Errori di parametri non validi**: verifica che i valori delle proporzioni corrispondano alle opzioni supportate (“1:1”, “16:9”, “9:16”, “4:3”, “3:4”, “21:9”, “9:21”) e che la durata sia “5s” o “9s”.
+ **Problemi di timeout**: utilizza `GetAsyncInvoke` per controllare lo stato del processo anziché attendere in modo sincrono. La generazione di video può richiedere alcuni minuti.
+ **Errori di lunghezza dei prompt**: mantieni i prompt compresi tra 1 e 5.000 caratteri. Prompt più lunghi verranno rifiutati.
## Note per le prestazioni
Considerazioni importanti relative alle prestazioni e alle limitazioni dei modelli Luma AI:
+ **Tempo di elaborazione**: la generazione di video richiede in genere 2-5 minuti per video di 5 secondi e 4-8 minuti per video di 9 secondi, a seconda della complessità.
+ **Requisiti relativi alle immagini**: le immagini di input devono essere di alta qualità con una risoluzione minima di 512 x 512 pixel. La dimensione massima supportata dell’immagine è 4.096 x 4.096 pixel.
+ **Dimensioni dei video di output**: i video generati variano da 5 a 50 MB a seconda della durata, della risoluzione e della complessità del contenuto.
+ **Limiti di utilizzo**: le chiamate API asincrone sono soggette a quote di servizio. Monitora il tuo utilizzo e richiedi aumenti delle quote, se necessario.
+ **Archiviazione S3**: garantisci una capacità di archiviazione S3 sufficiente per i video di output e valuta le policy del ciclo di vita per l’ottimizzazione dei costi.
## Documentazione correlata
Per ulteriori informazioni e servizi correlati:
+ **Configurazione di Amazon S3**: [creazione di bucket S3](https://docs.aws.amazon.com/s3/latest/userguide/creating-buckets-s3.html) e [policy di bucket](https://docs.aws.amazon.com/s3/latest/userguide/bucket-policies.html) per l’archiviazione di output.
+ **Operazioni API asincrone** - [StartAsyncInvoke](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_StartAsyncInvoke.html)e [GetAsyncInvoke](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_GetAsyncInvoke.html)riferimento all'[ListAsyncInvokes](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_ListAsyncInvokes.html)API.
+ **Quote di servizio**: [Quote per Amazon Bedrock](quotas.md) per i limiti del servizio Bedrock e le richieste di aumento delle quote.
+ **Best practice per l’elaborazione video**: [Invio di prompt e generazione di risposte con l’inferenza del modello](inference.md) per linee guida generali sull’inferenza dei modelli.
+ **Documentazione di Luma AI**: [documentazione sulla generazione di video di Luma Labs](https://docs.lumalabs.ai/docs/video-generation) per funzionalità dettagliate dei modelli e funzionalità avanzate.
# Modelli Meta Llama
In questa sezione vengono descritti i parametri di richiesta e i campi di risposta per i modelli Meta Llama. Utilizza queste informazioni per effettuare chiamate di inferenza ai modelli Meta Llama con le operazioni [InvokeModel](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModel.html) e [InvokeModelWithResponseStream](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModelWithResponseStream.html) (streaming). Questa sezione include anche esempi di codice Python che mostrano come chiamare i modelli Meta Llama. Per utilizzare un modello in un’operazione di inferenza, è necessario l’ID modello per il modello. Per ottenere l’ID modello, consulta [Modelli di fondazione supportati in Amazon Bedrock](models-supported.md). Alcuni modelli funzionano anche con l’[API Converse](conversation-inference.md). Per verificare se l’API Converse supporta un modello Meta Llama specifico, consulta [Modelli e funzionalità del modello supportati](conversation-inference-supported-models-features.md). Per ulteriori esempi di codice, consulta [Esempi di codice per l'utilizzo di Amazon Bedrock AWS SDKs](service_code_examples.md).
I modelli di fondazione in Amazon Bedrock supportano modalità di input e output, che variano da modello a modello. Per verificare le modalità supportate dai modelli Meta Llama, consulta [Modelli di fondazione supportati in Amazon Bedrock](models-supported.md). Per verificare quali funzionalità di Amazon Bedrock sono supportate dai modelli Meta Llama, consulta [Modelli di fondazione supportati in Amazon Bedrock](models-supported.md). Per verificare in quali Regioni AWS sono disponibili i modelli Meta Llama, consulta [Modelli di fondazione supportati in Amazon Bedrock](models-supported.md).
Quando effettui chiamate di inferenza con modelli Meta Llama, includi un prompt per il modello. Per informazioni generali sulla creazione di prompt per i modelli supportati da Amazon Bedrock, consulta [Concetti di progettazione dei prompt](prompt-engineering-guidelines.md). Per informazioni sui prompt specifiche di Meta Llama, consulta la [Guida alla progettazione dei prompt Meta Llama](https://ai.meta.com/llama/get-started/#prompting).
**Nota**
I modelli Llama 3.2 Instruct e Llama 3.3 Instruct utilizzano il geofencing. Questo significa che non possono essere utilizzati al di fuori delle Regioni AWS disponibili per tali modelli elencate nella tabella Regioni.
In questa sezione vengono fornite informazioni per l’utilizzo dei seguenti modelli di Meta.
+ Llama 3 Instruct
+ Llama 3.1 Instruct
+ Llama 3.2 Instruct
+ Llama 3.3 Instruct
+ Llama 4 Instruct
**Topics**
+ [Richiesta e risposta](#model-parameters-meta-request-response)
+ [Codice di esempio](#api-inference-examples-meta-llama)
## Richiesta e risposta
Il corpo della richiesta viene passato nel campo `body` di una richiesta a [InvokeModel](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModel.html) o [InvokeModelWithResponseStream](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModelWithResponseStream.html).
**Nota**
Non è possibile utilizzare le operazioni [InvokeModelWithResponseStream](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModelWithResponseStream.html) o [ConverseStream](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_ConverseStream.html) (streaming) con Llama 4 Instruct.
------
#### [ Request ]
I modelli Llama 3 Instruct, Llama 3.1 Instruct, Llama 3.2 Instruct e Llama 4 Instruct hanno i seguenti parametri di inferenza:
```
{
"prompt": string,
"temperature": float,
"top_p": float,
"max_gen_len": int
}
```
NOTA: i modelli Llama 3.2 e versioni successive aggiungono `images` alla struttura della richiesta, che consiste in un elenco di stringhe. Ad esempio: `images: Optional[List[str]]`
I seguenti sono parametri obbligatori:
+ **prompt**: (obbligatorio) il prompt che desideri passare al modello. Per risultati ottimali, formatta la conversazione con il modello indicato di seguito.
```
<|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|>
```
**Modello di esempio con prompt di sistema**
Di seguito è riportato un esempio di prompt che include un prompt di sistema.
```
<|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|>
```
**Esempio di conversazione multi-turno**
Di seguito è riportato un esempio di prompt di conversazione multi-turno.
```
<|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|>
```
**Modello di esempio con prompt di sistema**
Per ulteriori informazioni, consulta [Meta Llama 3](https://llama.meta.com/docs/model-cards-and-prompt-formats/meta-llama-3).
I seguenti sono parametri opzionali:
+ **temperature**: utilizza un valore più basso per ridurre la randomizzazione nella risposta.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/bedrock/latest/userguide/model-parameters-meta.html)
+ **top\$1p**: utilizza un valore più basso per ignorare le opzioni meno probabili. Imposta 0 o 1,0 per disabilitare questa funzionalità.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/bedrock/latest/userguide/model-parameters-meta.html)
+ **max\$1gen\$1len**: specifica il numero massimo di token da utilizzare nella risposta generata. Il modello tronca la risposta se il testo generato supera `max_gen_len`.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/bedrock/latest/userguide/model-parameters-meta.html)
------
#### [ Response ]
I modelli Llama 3 Instruct restituiscono i campi indicati di seguito per effettuare chiamate di inferenza per il completamento del testo.
```
{
"generation": "\n\n",
"prompt_token_count": int,
"generation_token_count": int,
"stop_reason" : string
}
```
Di seguito sono fornite ulteriori informazioni su ciascun campo.
+ **generation**: il testo generato.
+ **prompt\$1token\$1count**: il numero di token nel prompt.
+ **generation\$1token\$1count**: il numero di token nel testo generato.
+ **stop\$1reason**: il motivo per cui la risposta ha smesso di generare testo. I valori possibili sono:
+ **stop**: il modello ha terminato la generazione del testo per il prompt di input.
+ **length**: la lunghezza dei token per il testo generato supera `max_gen_len` nella chiamata a `InvokeModel` (`InvokeModelWithResponseStream`, nel caso di streaming dell'output). La risposta viene troncata in base al valore `max_gen_len` specificato per i token. Valuta la possibilità di aumentare il valore di `max_gen_len` e riprovare.
------
## Codice di esempio
Questo esempio mostra come chiamare il modello *Llama 3 Instruct*.
```
# 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 Regione AWS 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)
```
Questo esempio mostra come controllare la lunghezza della generazione tramite i modelli Llama 3 Instruct. Per risposte o riepiloghi dettagliati, modifica “max\$1gen\$1len” e includi istruzioni specifiche nel prompt.
# Modelli Mistral AI
Questa sezione descrive i parametri di richiesta e i campi di risposta per i modelli Mistral AI. Utilizza queste informazioni per effettuare chiamate di inferenza ai modelli Mistral AI con le operazioni [InvokeModel](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModel.html) e [InvokeModelWithResponseStream](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModelWithResponseStream.html) (streaming). Questa sezione include anche esempi di codice Python che mostrano come chiamare i modelli Mistral AI. Per utilizzare un modello in un’operazione di inferenza, è necessario l’ID modello per il modello. Per ottenere l’ID modello, consulta [Modelli di fondazione supportati in Amazon Bedrock](models-supported.md). Alcuni modelli funzionano anche con l’[API Converse](conversation-inference.md). Per verificare se l’API Converse supporta un modello Mistral AI specifico, consulta [Modelli e funzionalità del modello supportati](conversation-inference-supported-models-features.md). Per ulteriori esempi di codice, consulta [Esempi di codice per l'utilizzo di Amazon Bedrock AWS SDKs](service_code_examples.md).
I modelli di fondazione in Amazon Bedrock supportano modalità di input e output, che variano da modello a modello. Per verificare le modalità supportate dai modelli Mistral AI, consulta [Modelli di fondazione supportati in Amazon Bedrock](models-supported.md). Per verificare quali funzionalità di Amazon Bedrock sono supportate dai modelli Mistral AI, consulta [Modelli di fondazione supportati in Amazon Bedrock](models-supported.md). Per verificare in quali Regioni AWS i modelli Mistral AI sono disponibili, consulta [Modelli di fondazione supportati in Amazon Bedrock](models-supported.md).
Quando effettui chiamate di inferenza con modelli Mistral AI, includi un prompt per il modello. Per informazioni generali sulla creazione di prompt per i modelli supportati da Amazon Bedrock, consulta [Concetti di progettazione dei prompt](prompt-engineering-guidelines.md). Per informazioni sui prompt specifiche di Mistral AI, consulta la [Guida alla progettazione dei prompt di Mistral AI](https://docs.mistral.ai/guides/prompting_capabilities/).
**Topics**
+ [Completamento del testo Mistral AI](model-parameters-mistral-text-completion.md)
+ [Completamento della chat Mistral AI](model-parameters-mistral-chat-completion.md)
+ [Parametri e inferenza di Mistral AI Large (24.07)](model-parameters-mistral-large-2407.md)
+ [Parametri e inferenza Pixtral Large (25.02)](model-parameters-mistral-pixtral-large.md)
# Completamento del testo Mistral AI
L’API di completamento del testo Mistral AI consente di generare testo con un modello Mistral AI.
Effettui richieste di inferenza ai modelli Mistral AI con [InvokeModel](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModel.html) o [InvokeModelWithResponseStream](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModelWithResponseStream.html) (streaming).
I modelli Mistral AI sono disponibili con la [licenza Apache 2.0](https://www.apache.org/licenses/LICENSE-2.0.txt). Per ulteriori informazioni sull’utilizzo dei modelli Mistral AI, consulta la [Documentazione di Mistral AI](https://docs.mistral.ai/).
**Topics**
+ [Modelli supportati](#mistral--text-completion-supported-models)
+ [Richiesta e risposta](#model-parameters-mistral-text-completion-request-response)
+ [Esempio di codice](#api-inference-examples-mistral-text-completion)
## Modelli supportati
Puoi utilizzare i seguenti modelli Mistral AI.
+ Mistral 7B Instruct
+ Mixtral 8X7B Instruct
+ Mistral Large
+ Mistral Small
È necessario l’ID modello per il modello che desideri utilizzare. Per ottenere l’ID modello, consulta [Modelli di fondazione supportati in Amazon Bedrock](models-supported.md).
## Richiesta e risposta
------
#### [ Request ]
I modelli Mistral AI hanno i seguenti parametri di inferenza.
```
{
"prompt": string,
"max_tokens" : int,
"stop" : [string],
"temperature": float,
"top_p": float,
"top_k": int
}
```
I seguenti sono parametri obbligatori.
+ **prompt**: (obbligatorio) Il prompt che desideri passare al modello, come mostrato nell’esempio seguente.
```
[INST] What is your favourite condiment? [/INST]
```
L’esempio seguente mostra come formattare un prompt a più turni.
```
[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]
```
Il testo per il ruolo utente si trova all’interno dei token `[INST]...[/INST]`, il testo all’esterno è il ruolo di assistente. L’inizio e la fine di una stringa sono rappresentati dai token `` (inizio di stringa) e `` (fine di stringa). Per informazioni sull’invio di un prompt di chat nel formato corretto, consulta [Modello di chat](https://docs.mistral.ai/models/#chat-template) nella documentazione Mistral AI.
I seguenti sono parametri opzionali.
+ **max\$1tokens**: specifica il numero massimo di token da utilizzare nella risposta generata. Il modello tronca la risposta se il testo generato supera `max_tokens`.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/bedrock/latest/userguide/model-parameters-mistral-text-completion.html)
+ **stop**: un elenco di sequenze di arresti che, se generate dal modello, impediscono al modello di generare ulteriore output.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/bedrock/latest/userguide/model-parameters-mistral-text-completion.html)
+ **temperature**: controlla la casualità delle previsioni fatte dal modello. Per ulteriori informazioni, consulta [Influenza sulla generazione della risposta con i parametri di inferenza](inference-parameters.md).
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/bedrock/latest/userguide/model-parameters-mistral-text-completion.html)
+ **top\$1p**: controlla la diversità di testo che il modello genera impostando la percentuale di candidati più probabili che il modello considera per il token successivo. Per ulteriori informazioni, consulta [Influenza sulla generazione della risposta con i parametri di inferenza](inference-parameters.md).
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/bedrock/latest/userguide/model-parameters-mistral-text-completion.html)
+ **top\$1k**: il numero di candidati più probabili che il modello considera per il token successivo. Per ulteriori informazioni, consulta [Influenza sulla generazione della risposta con i parametri di inferenza](inference-parameters.md).
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/bedrock/latest/userguide/model-parameters-mistral-text-completion.html)
------
#### [ Response ]
Di seguito è riportata la risposta `body` da una chiamata `InvokeModel`:
```
{
"outputs": [
{
"text": string,
"stop_reason": string
}
]
}
```
La risposta `body` ha i seguenti campi:
+ **outputs**: un elenco di output del modello. Ogni voce ha i campi riportati di seguito:
+ **text**: il testo generato dal modello.
+ **stop\$1reason**: il motivo per cui la risposta ha smesso di generare testo. I valori possibili sono:
+ **stop**: il modello ha terminato la generazione del testo per il prompt di input. Il modello si arresta perché non ha più contenuto da generare oppure se genera una delle sequenze di arresti definite nel parametro di richiesta `stop`.
+ **length**: la lunghezza dei token per il testo generato supera il valore di `max_tokens` nella chiamata a `InvokeModel` (`InvokeModelWithResponseStream`, nel caso di streaming dell’output). La risposta viene troncata in base ai token `max_tokens`.
------
## Esempio di codice
Questo esempio mostra come chiamare il modello Mistral 7B Instruct.
```
# 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()
```
# Completamento della chat Mistral AI
L’API di completamento della chat Mistral AI consente di creare applicazioni conversazionali.
**Suggerimento**
Puoi utilizzare l’API di completamento della chat Mistral AI con le operazioni di inferenza di base ([InvokeModel](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModel.html) o [InvokeModelWithResponseStream](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModelWithResponseStream.html)). Tuttavia, ti consigliamo di utilizzare l’API Converse per implementare i messaggi nell’applicazione. L’API Converse fornisce un set unificato di parametri che funzionano su tutti i modelli che supportano i messaggi. Per ulteriori informazioni, consulta [Avvio di una conversazione con le operazioni dell’API Converse](conversation-inference.md).
I modelli Mistral AI sono disponibili con la [licenza Apache 2.0](https://www.apache.org/licenses/LICENSE-2.0.txt). Per ulteriori informazioni sull’utilizzo dei modelli Mistral AI, consulta la [Documentazione di Mistral AI](https://docs.mistral.ai/).
**Topics**
+ [Modelli supportati](#mistral-supported-models-chat-completion)
+ [Richiesta e risposta](#model-parameters-mistral-chat-completion-request-response)
## Modelli supportati
Puoi utilizzare i seguenti modelli Mistral AI.
+ Mistral Large
È necessario l'ID modello per il modello che desideri utilizzare. Per ottenere l’ID modello, consulta [Modelli di fondazione supportati in Amazon Bedrock](models-supported.md).
## Richiesta e risposta
------
#### [ Request ]
I modelli Mistral AI hanno i seguenti parametri di inferenza.
```
{
"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
}
```
I seguenti sono parametri obbligatori.
+ **messages**: (obbligatorio) i messaggi che desideri passare al modello.
+ **role**: il ruolo del messaggio. I valori validi sono:
+ **system**: imposta il comportamento e il contesto del modello nella conversazione.
+ **user**: il messaggio dell’utente da inviare al modello.
+ **assistant**: la risposta del modello.
+ **content**: il contenuto per il messaggio.
```
[
{
"role": "user",
"content": "What is the most popular song on WZPZ?"
}
]
```
Per passare il risultato di uno strumento, utilizza JSON con i seguenti campi.
+ **role**: il ruolo del messaggio. Il valore deve essere `tool`.
+ **tool\$1call\$1id**: l’ID della richiesta dello strumento. L’ID si ottiene dai campi `tool_calls` della risposta alla richiesta precedente.
+ **content**: il risultato dello strumento.
L’esempio seguente è il risultato di uno strumento che riproduce i brani più popolari su una stazione radio.
```
{
"role": "tool",
"tool_call_id": "v6RMMiRlT7ygYkT4uULjtg",
"content": "{\"song\": \"Elemental Hotel\", \"artist\": \"8 Storey Hike\"}"
}
```
I seguenti sono parametri opzionali.
+ **tools**: definizioni degli strumenti che il modello può utilizzare.
Se includi `tools` nella richiesta, il modello potrebbe restituire un campo `tool_calls` nel messaggio che rappresenta l’utilizzo di tali strumenti da parte del modello. È quindi possibile eseguire tali strumenti utilizzando l’input dello strumento generato dal modello e quindi, facoltativamente, restituire i risultati al modello utilizzando blocchi di contenuto `tool_result`.
L’esempio seguente riguarda uno strumento che riproduce i brani più popolari su una stazione radio.
```
[
{
"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**: specifica come vengono chiamate le funzioni. Se impostato su `none`, il modello non chiama una funzione, generando invece un messaggio. Se impostato su `auto`, il modello può ora scegliere di generare un messaggio o di chiamare una funzione. Se impostato su `any`, il modello è forzato a chiamare una funzione.
+ **max\$1tokens**: specifica il numero massimo di token da utilizzare nella risposta generata. Il modello tronca la risposta se il testo generato supera `max_tokens`.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/bedrock/latest/userguide/model-parameters-mistral-chat-completion.html)
+ **temperature**: controlla la casualità delle previsioni fatte dal modello. Per ulteriori informazioni, consulta [Influenza sulla generazione della risposta con i parametri di inferenza](inference-parameters.md).
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/bedrock/latest/userguide/model-parameters-mistral-chat-completion.html)
+ **top\$1p**: controlla la diversità di testo che il modello genera impostando la percentuale di candidati più probabili che il modello considera per il token successivo. Per ulteriori informazioni, consulta [Influenza sulla generazione della risposta con i parametri di inferenza](inference-parameters.md).
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/bedrock/latest/userguide/model-parameters-mistral-chat-completion.html)
------
#### [ Response ]
Di seguito è riportata la risposta `body` da una chiamata `InvokeModel`.
```
{
"choices": [
{
"index": 0,
"message": {
"role": "assistant",
"content": str,
"tool_calls": [...]
},
"stop_reason": "stop"|"length"|"tool_calls"
}
]
}
```
La risposta `body` ha i seguenti campi possibili:
+ **choices**: l’output dei campi del modello.
+ **index**: l’indice del messaggio.
+ **message**: il messaggio del modello.
+ **role**: il ruolo del messaggio.
+ **content**: il contenuto per il messaggio.
+ **tool\$1calls**: se il valore di `stop_reason` è `tool_calls`, questo campo contiene un elenco di richieste di strumenti che il modello vuole che tu esegua.
+ **id**: l’ID per la richiesta di strumento.
+ **function**: la funzione richiesta dal modello.
+ **name**: il nome della funzione.
+ **arguments**: gli argomenti da passare allo strumento.
Di seguito è riportato un esempio di richiesta per uno strumento che recupera la canzone più popolare di una stazione radio.
```
[
{
"id": "v6RMMiRlT7ygYkT4uULjtg",
"function": {
"name": "top_song",
"arguments": "{\"sign\": \"WZPZ\"}"
}
}
]
```
+ **stop\$1reason**: il motivo per cui la risposta ha smesso di generare testo. I valori possibili sono:
+ **stop**: il modello ha terminato la generazione del testo per il prompt di input. Il modello si arresta perché non ha più contenuto da generare oppure se genera una delle sequenze di arresti definite nel parametro di richiesta `stop`.
+ **length**: la lunghezza dei token per il testo generato supera il valore `max_tokens`. La risposta viene troncata in base al valore `max_tokens` specificato per i token.
+ **tool\$1calls**: il modello richiede l’esecuzione di uno strumento.
------
# Parametri e inferenza di Mistral AI Large (24.07)
L’API di completamento della chat di Mistral AI consente di creare applicazioni conversazionali. Puoi anche utilizzare l’API Converse di Amazon Bedrock con questo modello. Puoi utilizzare gli strumenti per effettuare chiamate di funzioni.
**Suggerimento**
Puoi utilizzare l’API di completamento della chat Mistral AI con le operazioni di inferenza di base ([InvokeModel](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModel.html) o [InvokeModelWithResponseStream](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModelWithResponseStream.html)). Tuttavia, ti consigliamo di utilizzare l’API Converse per implementare i messaggi nell’applicazione. L’API Converse fornisce un set unificato di parametri che funzionano su tutti i modelli che supportano i messaggi. Per ulteriori informazioni, consulta [Avvio di una conversazione con le operazioni dell’API Converse](conversation-inference.md).
I modelli Mistral AI sono disponibili con la [licenza Apache 2.0](https://www.apache.org/licenses/LICENSE-2.0.txt). Per ulteriori informazioni sull’utilizzo dei modelli Mistral AI, consulta la [Documentazione di Mistral AI](https://docs.mistral.ai/).
**Topics**
+ [Modelli supportati](#mistral-supported-models-chat-completion)
+ [Esempi di richiesta e risposta](#model-parameters-mistral-large-2407-request-response)
## Modelli supportati
Puoi utilizzare i seguenti modelli Mistral AI con gli esempi di codice riportati in questa pagina.
+ Mistral Large 2 (24.07)
È necessario l'ID modello per il modello che desideri utilizzare. Per ottenere l’ID modello, consulta [Modelli di fondazione supportati in Amazon Bedrock](models-supported.md).
## Esempi di richiesta e risposta
------
#### [ Request ]
Esempio di modello di invocazione di 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 ]
Esempio di conversione di 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 ]
Esempio invoke\$1model\$1with\$1response\$1stream di 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 ]
Esempio converse\$1stream di 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 ]
Esempio di output JSON di 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 ]
Esempio di strumenti di 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()
```
------
# Parametri e inferenza Pixtral Large (25.02)
Pixtral Large 25.02 è un modello multimodale con parametri 124B che combina la comprensione delle state-of-the-art immagini con potenti funzionalità di elaborazione del testo. AWS è il primo provider di servizi cloud a fornire Pixtral Large (25.02) come modello serverless completamente gestito. Questo modello offre prestazioni all’avanguardia nell’analisi dei documenti, nell’interpretazione dei grafici e nella comprensione delle immagini naturali, mantenendo al contempo le avanzate funzionalità di elaborazione del testo di Mistral Large 2.
Con una finestra contestuale di 128K, Pixtral Large 25.02 raggiunge best-in-class prestazioni su benchmark chiave, tra cui DocVQA e. MathVista VQAv2 Il modello offre un supporto multilingue completo in molte lingue ed è stato addestrato su oltre 80 linguaggi di programmazione. Le funzionalità chiave includono ragionamento matematico avanzato, chiamata di funzioni native, output JSON e solida aderenza al contesto per applicazioni RAG.
L’API di completamento della chat Mistral AI consente di creare applicazioni conversazionali. Puoi anche utilizzare l’API Converse di Amazon Bedrock con questo modello. Puoi utilizzare gli strumenti per effettuare chiamate di funzioni.
**Suggerimento**
È possibile utilizzare l'API di completamento della Mistral AI chat con le operazioni di inferenza di base (o). [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) Tuttavia, ti consigliamo di utilizzare l’API Converse per implementare i messaggi nell’applicazione. L’API Converse fornisce un set unificato di parametri che funzionano su tutti i modelli che supportano i messaggi. Per ulteriori informazioni, consulta [Avvio di una conversazione con le operazioni dell’API Converse](conversation-inference.md).
Il modello Mistral AI Pixtral Large è disponibile con la [licenza Mistral Research](https://mistral.ai/licenses/MRL-0.1.md). Per ulteriori informazioni sull’utilizzo dei modelli Mistral AI, consulta la [Documentazione di Mistral AI](https://docs.mistral.ai/).
**Topics**
+ [Modelli supportati](#mistral-supported-models-chat-completion)
+ [Esempi di richiesta e risposta](#model-parameters-pixtral-large-2502-request-response)
## Modelli supportati
Puoi utilizzare i seguenti modelli Mistral AI con gli esempi di codice in questa pagina.
+ Pixtral Large (25.02)
È necessario l’ID modello per il modello che desideri utilizzare. Per ottenere l’ID modello, consulta [Modelli di fondazione supportati in Amazon Bedrock](models-supported.md).
## Esempi di richiesta e risposta
------
#### [ Request ]
Esempio di modello di invocazione 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 ]
Esempio Pixtral Large (25.02) Converse.
```
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 ]
Esempio invoke\$1model\$1with\$1response\$1stream 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 ]
Esempio Pixtral Large (25.02) Converse.
```
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 ]
Esempio di output JSON 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 ]
Esempio di strumenti 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()
```
------
# Modelli OpenAI
OpenAI offre i seguenti modelli a pesi aperti:
+ [https://huggingface.co/openai/gpt-oss-20b](https://huggingface.co/openai/gpt-oss-20b): modello più piccolo ottimizzato per una latenza inferiore e casi d’uso locali o specializzati.
+ [https://huggingface.co/openai/gpt-oss-120b](https://huggingface.co/openai/gpt-oss-120b): modello più grande ottimizzato per la produzione e per casi d’uso generici o che richiedono elevate capacità di ragionamento.
La tabella seguente riepiloga le informazioni sui modelli:
| Informazioni | gpt-oss-20b | gpt-oss-120b |
| --- | --- | --- |
| Data di rilascio | 5 agosto 2025 | 5 agosto 2025 |
| ID modello | openai.gpt-oss-20b-1:0 | openai.gpt-oss-120b-1:0 |
| ID prodotto | N/D | N/D |
| Modalità di input supportate | Testo | Testo |
| Modalità di input supportate | Testo | Testo |
| Finestra contestuale | 128.000 | 128.000 |
I modelli OpenAI supportano le seguenti funzionalità:
+ [Invocazione del modello](inference.md) con le seguenti operazioni:
+ [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 Chat Completions di OpenAI](inference-chat-completions.md)
+ [Inferenza in batch](batch-inference.md) con [CreateModelInvocationJob](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_CreateModelInvocationJob.html).
+ Applicazione [Guardrail](guardrails.md) tramite l’uso di intestazioni nelle operazioni di invocazione del modello.
**Topics**
+ [Corpo della richiesta di OpenAI](#model-parameters-openai-request)
+ [Corpo della risposta di OpenAI](#model-parameters-openai-response)
+ [Esempio di utilizzo di modelli OpenAI](#model-parameters-openai-use)
## Corpo della richiesta di OpenAI
Per informazioni sui parametri nel corpo della richiesta e sulle relative descrizioni, consultare [Create chat completion](https://platform.openai.com/docs/api-reference/chat/create) nella documentazione di OpenAI.
Utilizzare i campi del corpo della richiesta nei seguenti modi:
+ In una richiesta [InvokeModel](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModel.html)o OpenAI Chat Completions, includi i campi nel corpo della richiesta.
+ In una richiesta [Converse](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_Converse.html), procedere come segue:
+ Mappare i `messages` nel modo seguente:
+ Per ogni messaggio il cui ruolo è`developer`, aggiungi la `content` a [SystemContentBlock](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_SystemContentBlock.html)nell'`system`array.
+ Per ogni messaggio il cui ruolo è `user` o`assistant`, aggiungi `content` a a [ContentBlock](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_ContentBlock.html)nel `content` campo e specifica il `role` nel `role` campo di un [messaggio](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_Message.html) nell'`messages`array.
+ Associare i valori dei seguenti ai campi corrispondenti nell’oggetto `inferenceConfig`:
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/bedrock/latest/userguide/model-parameters-openai.html)
+ Includere qualsiasi altro campo nell’oggetto `additionalModelRequestFields`.
**Considerazioni durante la creazione del corpo della richiesta**
+ I modelli OpenAI supportano solo input e output di testo.
+ Il valore nel campo `model` deve corrispondere a quello nell’intestazione. È possibile omettere questo campo per consentire che venga compilato automaticamente con lo stesso valore dell’intestazione.
+ Il valore nel campo `stream` deve corrispondere all’operazione dell’API utilizzata. È possibile omettere questo campo per consentire che venga compilato automaticamente con il valore corretto.
+ Se si utilizza [InvokeModel](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModel.html), il `stream` valore deve essere`false`.
## Corpo della risposta di OpenAI
Il corpo della risposta per i modelli OpenAI è conforme all’oggetto di completamento della chat restituito da OpenAI. Per ulteriori informazioni sui campi di risposta, consultare [The chat completion object](https://platform.openai.com/docs/api-reference/chat/object) nella documentazione di OpenAI.
**Nota**
Se si utilizza `InvokeModel`, il ragionamento del modello, circondato da tag ``, precede il contenuto di testo della risposta.
## Esempio di utilizzo di modelli OpenAI
Questa sezione fornisce alcuni esempi di come utilizzare i modelli OpenAI.
### Prerequisiti
Prima di provare questi esempi, verificare di aver soddisfatto i prerequisiti:
+ **Autenticazione**: puoi autenticarti con AWS le tue credenziali o con una chiave API Amazon Bedrock.
Configura AWS le tue credenziali o genera una chiave API Amazon Bedrock per autenticare la tua richiesta.
+ Per ulteriori informazioni sulla configurazione delle AWS credenziali, consulta Accesso [programmatico](https://docs.aws.amazon.com/IAM/latest/UserGuide/security-creds-programmatic-access.html) con credenziali di sicurezza. AWS
+ Per informazioni sulle chiavi API di Amazon Bedrock e su come generarle, consulta la sezione Chiavi API nel capitolo Build.
**Nota**
Se si utilizza l’API Chat Completions di OpenAI, è possibile autenticarsi solo con una chiave API Amazon Bedrock.
+ **Endpoint**: trova l'endpoint che corrisponde alla AWS regione da utilizzare negli [endpoint e nelle quote di Amazon Bedrock Runtime](https://docs.aws.amazon.com/general/latest/gr/bedrock.html#br-rt). Se utilizzi un AWS SDK, potresti dover specificare solo il codice regionale e non l'intero endpoint quando configuri il client. È necessario utilizzare un endpoint associato a una Regione supportata dal modello utilizzato nell’esempio.
+ **Accesso al modello**: consente di richiedere l’accesso a un modello OpenAI. Per ulteriori informazioni, consulta [Gestisci l'accesso ai modelli tramite SDK e CLI](model-access.md#model-access-modify).
+ **(Se l'esempio utilizza un SDK) Installa l'SDK: dopo l'**installazione, configura le credenziali predefinite e una regione predefinite. AWS Se non vengono configurate le credenziali predefinite o una Regione, è necessario specificarle esplicitamente negli esempi di codice pertinenti. Per ulteriori informazioni sui provider di credenziali standardizzati, consulta [AWS SDKs and](https://docs.aws.amazon.com/sdkref/latest/guide/standardized-credentials.html) Tools (provider di credenziali standardizzati).
**Nota**
Se si utilizza l’SDK OpenAI, è possibile autenticarsi solo con una chiave API Amazon Bedrock ed è necessario impostare esplicitamente l’endpoint Amazon Bedrock.
Espandere la sezione relativa all’esempio desiderato:
### Create chat completion di OpenAI
Per esempi di utilizzo dell’API Create chat completion di OpenAI, scegliere la scheda corrispondente al metodo preferito, poi seguire la procedura:
------
#### [ OpenAI SDK (Python) ]
Il seguente script Python chiama l’API Create chat completion con l’SDK Python di OpenAI:
```
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 ]
Eseguire il seguente comando in un terminale per chiamare l’API Create chat completion con curl:
```
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
Scegli la scheda relativa al metodo che preferisci, quindi segui la procedura:
------
#### [ 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
Quando si utilizza l’API [Converse](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_Converse.html) unificata, è necessario associare i campi di Create chat completion di OpenAI al campo corrispondente nel corpo della richiesta di Converse.
Ad esempio, confrontare il seguente corpo della richiesta di completamento della chat con il corpo della richiesta di Converse corrispondente:
------
#### [ 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
}
}
```
------
Scegli la scheda relativa al metodo che preferisci, quindi segui la procedura:
------
#### [ 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)
```
------
### Guardrails con InvokeModel
Per applicare un guardrail durante l’invocazione del modello, specificare l’ID del guardrail, la versione e se abilitare o meno la traccia del guardrail nell’intestazione di una richiesta di invocazione del modello.
Scegli la scheda relativa al metodo che preferisci, quindi segui la procedura:
------
#### [ 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
```
------
### Guardrail con Chat Completions di OpenAI
Per esempi di utilizzo dei guardrail con Chat Completions OpenAI, scegli la scheda relativa al metodo che preferisci, quindi segui la procedura:
------
#### [ 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);
```
------
### Inferenza in batch
L’[inferenza in batch](batch-inference.md) consente di eseguire l’inferenza del modello con più prompt. Per eseguire l’inferenza in batch con un modello OpenAI, procedere come segue:
1. Creare un file JSONL e popolarlo con almeno il numero minimo di oggetti JSON, ciascuno separato da una nuova riga. Ogni oggetto `modelInput` deve essere conforme al formato del corpo della richiesta [Create chat completion di OpenAI](https://platform.openai.com/docs/api-reference/chat/create). Di seguito viene mostrato un esempio delle prime due righe di un file JSONL contenente i corpi della richiesta per OpenAI.
```
{
"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
}
}
...
```
**Nota**
Il campo `model` è facoltativo perché il servizio di inferenza in batch lo inserirà automaticamente in base all’intestazione, se omesso.
Verificare il tuo file JSONL sia conforme alle quote di inferenza in batch come indicato in [Formattazione e caricamento dei propri dati di inferenza in batch](batch-inference-data.md).
1. Caricare il file immagine in un bucket Amazon S3.
1. Invia una [CreateModelInvocationJob](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_CreateModelInvocationJob.html)richiesta con un [endpoint del piano di controllo Amazon Bedrock](https://docs.aws.amazon.com/general/latest/gr/bedrock.html#br-cp) con il bucket S3 del passaggio precedente specificato nel `inputDataConfig` campo e il OpenAI modello specificato nel campo. `modelId`
Per un esempio di end-to-end codice, consulta. [Esempio di codice per inferenza in batch](batch-inference-example.md) Sostituire con le configurazioni appropriate per i modelli OpenAI.
# Modelli Stability AI
In questa sezione vengono descritti i parametri di richiesta e i campi di risposta per i modelli Stability AI. Usa queste informazioni per effettuare chiamate di inferenza ai modelli di Stability AI con l'[InvokeModel](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModel.html)operazione. Questa sezione include anche esempi di codice Python che mostrano come chiamare i modelli Stability AI. Per utilizzare un modello in un’operazione di inferenza, è necessario l’ID modello per il modello. Per ottenere l’ID modello, consulta [Modelli di fondazione supportati in Amazon Bedrock](models-supported.md). Alcuni modelli funzionano anche con l’[API Converse](conversation-inference.md). Per verificare se l’API Converse supporta un modello Stability AI specifico, consulta [Modelli e funzionalità del modello supportati](conversation-inference-supported-models-features.md). Per ulteriori esempi di codice, consulta [Esempi di codice per l'utilizzo di Amazon Bedrock AWS SDKs](service_code_examples.md).
I modelli di fondazione in Amazon Bedrock supportano modalità di input e output, che variano da modello a modello. Per verificare le modalità supportate dai modelli Stability AI, consulta [Modelli di fondazione supportati in Amazon Bedrock](models-supported.md). Per verificare quali funzionalità di Amazon Bedrock sono supportate dai modelli Stability AI, consulta [Modelli di fondazione supportati in Amazon Bedrock](models-supported.md). Per verificare in quali AWS regioni sono disponibili i modelli Stability AI, consulta[Modelli di fondazione supportati in Amazon Bedrock](models-supported.md).
Quando effettui chiamate di inferenza con modelli Stability AI, includi un prompt per il modello. Per informazioni generali sulla creazione di prompt per i modelli supportati da Amazon Bedrock, consulta [Concetti di progettazione dei prompt](prompt-engineering-guidelines.md). Per informazioni specifiche sui prompt di Stability AI, consulta la [Guida alla progettazione dei prompt di Stability AI](https://platform.stability.ai/docs/getting-started).
## Modelli e servizi di immagine supportati
Amazon Bedrock supporta i seguenti modelli Stability AI e servizi di immagine.
**Nota**
Il supporto per tutti gli altri modelli Stability AI è in fase di deprecazione.
| Modello | Casi d’uso | Esempio |
| --- | --- | --- |
| [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/it_it/bedrock/latest/userguide/model-parameters-stability-diffusion.html) | Un marchio di lusso utilizza Stable Image Ultra per creare immagini straordinarie della sua ultima collezione per riviste, garantendo un’atmosfera premium all’altezza dei suoi standard elevati. |
| [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/it_it/bedrock/latest/userguide/model-parameters-stability-diffusion.html) | Un team di sviluppo di giochi utilizza SD3 .5 Large per creare texture ambientali dettagliate e concetti di personaggi, accelerando la propria pipeline creativa. |
| [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/it_it/bedrock/latest/userguide/model-parameters-stability-diffusion.html) | Un rivenditore online utilizza Stable Image Core per generare rapidamente immagini di prodotti per i nuovi arrivi, consentendogli di mettere in vendita gli articoli più velocemente e conservare il proprio catalogo. up-to-date |
| [Servizi di immagine Stability AI](stable-image-services.md) | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/bedrock/latest/userguide/model-parameters-stability-diffusion.html) | Un’azienda media utilizza la ricerca e ricolorazione, il transfer di stile e la rimozione dello sfondo per generare varianti delle immagini per una campagna pubblicitaria. |
**Topics**
+ [Modelli e servizi di immagine supportati](#supported-stability-models)
+ [Richiesta e risposta 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)
+ [Richiesta e risposta Stable Image Core](model-parameters-diffusion-stable-image-core-text-image-request-response.md)
+ [Servizi di immagine Stability AI](stable-image-services.md)
# Richiesta e risposta Stable Image Ultra
Il corpo della richiesta viene passato nel `body` campo di una richiesta all'[InvokeModel](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModel.html)operazione.
**Campo del corpo della richiesta per l’invocazione del modello**
Quando effettui una InvokeModel chiamata utilizzando un modello Stable Image Ultra, riempi il campo body con un oggetto JSON simile al seguente.
+ **prompt**: (stringa) cosa desideri vedere nell’immagine di output. Un prompt forte e descrittivo che definisca chiaramente elementi, colori e soggetti porterà a risultati migliori.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/bedrock/latest/userguide/model-parameters-diffusion-stable-ultra-text-image-request-response.html)
**Campo del corpo delle risposte per l’invocazione del modello**
Quando effettui una chiamata `InvokeModel` utilizzando un modello Stable Image Ultra, la risposta è simile alla seguente.
```
{
'seeds': [2130420379],
"finish_reasons":[null],
"images":["..."]
}
```
Una risposta con una “finish reason” diversa da `null` avrà il seguente aspetto:
```
{
"finish_reasons":["Filter reason: prompt"]
}
```
+ **seeds**: (stringa) elenco dei seed utilizzati per generare immagini per il modello.
+ **finish\$1reasons**: enum che indica se la richiesta è stata filtrata o meno. `null` indica che la richiesta è andata a buon fine. Valori correnti possibili: `"Filter reason: prompt", "Filter reason: output image", "Filter reason: input image", "Inference error", null`.
+ **images**: un elenco di immagini generate in formato stringa base64.
Per ulteriori informazioni, consultate [https://platform.us.stability. ai/docs/api-reference\$1tag/v1 generazione](https://platform.us.stability.ai/docs/api-reference#tag/v1generation).
------
#### [ Text to image ]
Il modello Stability.ai Stable Image Ultra ha i seguenti parametri di inferenza per una chiamata di text-to-image inferenza.
+ **prompt**: (stringa) cosa desideri vedere nell’immagine di output. Un prompt forte e descrittivo che definisca chiaramente elementi, colori e soggetti porterà a risultati migliori.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/bedrock/latest/userguide/model-parameters-diffusion-stable-ultra-text-image-request-response.html)
**Campi opzionali**
+ **aspect\$1ratio**: (stringa) controlla le proporzioni dell’immagine generata. Questo parametro è valido solo per text-to-image le richieste. Impostazione predefinita: 1:1. Enum: 16:9, 1:1, 21:9, 2:3, 3:2, 4:5, 5:4, 9:16, 9:21.
+ **modalità**: imposta su text-to-image. Predefinito: text-to-image. Enum: `text-to-image`.
+ **output\$1format**: specifica il formato dell’immagine di output. Formati supportati: JPEG, PNG. Dimensioni supportate: altezza da 640 a 1.536 px, larghezza da 640 a 1.536 px.
+ **seed**: (numero) un valore specifico utilizzato per determinare la “casualità” della generazione. Ometti questo parametro o passa 0 per utilizzare un seed casuale. Intervallo: da 0 a 4294967295.
+ **negative\$1prompt**: parole chiave che indicano ciò che non desideri vedere nell’immagine di output. Massimo: 10.000 caratteri.
```
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 ]
Il modello Stability.ai Stable Image Ultra ha i seguenti parametri di inferenza per una chiamata di image-to-image inferenza.
+ **prompt**: (stringa) cosa desideri vedere nell’immagine di output. Un prompt forte e descrittivo che definisca chiaramente elementi, colori e soggetti porterà a risultati migliori.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/bedrock/latest/userguide/model-parameters-diffusion-stable-ultra-text-image-request-response.html)
**Campi opzionali**
+ **image**: (stringa) immagine Base64 da utilizzare come punto di partenza per la generazione. Formati supportati: JPEG, PNG, WebP.
+ **strength**: (numero) quanto influisce il parametro image sull’immagine generata. Le immagini con valori di strength inferiori avranno un aspetto più simile all’immagine originale. Intervallo: da 0,0 a 1,0. Impostazione predefinita: 0,35.
+ **aspect\$1ratio**: (stringa) controlla le proporzioni dell’immagine generata. Questo parametro è valido solo per text-to-image le richieste. Impostazione predefinita: 1:1. Enum: 16:9, 1:1, 21:9, 2:3, 3:2, 4:5, 5:4, 9:16, 9:21.
+ **output\$1format**: specifica il formato dell’immagine di output. Formati supportati: JPEG, PNG. Dimensioni supportate: altezza da 640 a 1.536 px, larghezza da 640 a 1.536 px.
+ **seed**: (numero) un valore specifico utilizzato per determinare la “casualità” della generazione. Ometti questo parametro o passa 0 per utilizzare un seed casuale. Intervallo: da 0 a 4294967295.
+ **negative\$1prompt**: parole chiave che indicano ciò che non desideri vedere nell’immagine di output. Massimo: 10.000 caratteri.
```
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
Il modello Stable Diffusion 3.5 Large utilizza 8 miliardi di parametri e supporta l'output con risoluzione di 1 megapixel per la generazione text-to-image e image-to-image la generazione.
Il corpo della richiesta viene passato nel `body` campo di una richiesta a. [InvokeModel](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModel.html)
**Campo del corpo della richiesta per l’invocazione del modello**
Quando effettui una InvokeModel chiamata utilizzando un modello Stable Diffusion 3.5 Large, riempi il campo body con un oggetto JSON simile al seguente.
+ **prompt**: (stringa) descrizione testuale dell’immagine di output desiderata. Massimo 10.000 caratteri.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/bedrock/latest/userguide/model-parameters-diffusion-3-5-large.html)
**Campo del corpo delle risposte per l’invocazione del modello**
Quando effettui una chiamata `InvokeModel` utilizzando un modello Stable Diffusion 3.5 Large, la risposta è simile alla seguente.
```
{
'seeds': [2130420379],
"finish_reasons":[null],
"images":["..."]
}
```
Una risposta con una “finish reason” diversa da `null` avrà il seguente aspetto:
```
{
"finish_reasons":["Filter reason: prompt"]
}
```
+ **seeds**: (stringa) elenco dei seed utilizzati per generare immagini per il modello.
+ **finish\$1reasons**: enum che indica se la richiesta è stata filtrata o meno. `null` indica che la richiesta è andata a buon fine. Valori correnti possibili: `"Filter reason: prompt", "Filter reason: output image", "Filter reason: input image", "Inference error", null`.
+ **images**: un elenco di immagini generate in formato stringa base64.
------
#### [ Text to image ]
Il modello Stability.ai Stable Diffusion 3.5 Large ha i seguenti parametri di inferenza per una chiamata di inferenza. text-to-image
+ **prompt** (string) — Descrizione testuale dell'immagine di output desiderata. Massimo 10.000 caratteri.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/bedrock/latest/userguide/model-parameters-diffusion-3-5-large.html)
**Parametri opzionali**
+ **aspect\$1ratio** (string) — Controlla le proporzioni dell'immagine generata. Valido solo per le richieste text-to-image. Enum: 16:9, 1:1, 21:9, 2:3, 3:2, 4:5, 5:4, 9:16, 9:21. Impostazione predefinita 1:1.
+ **mode** (string) (GenerationMode) - Predefinito: text-to-image. Enum: image-to-image o text-to-image. Controlla se si tratta di una image-to-image generazione text-to-image o, il che influisce sui parametri richiesti:
+ text-to-image richiede solo il parametro prompt.
+ image-to-image richiede i parametri prompt, image e strength.
+ **seed** (number) — Valore per controllare la casualità nella generazione. Intervallo compreso tra 0 e 4294967294. Impostazione predefinita: 0 (seed casuale).
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/bedrock/latest/userguide/model-parameters-diffusion-3-5-large.html)
+ **negative\$1prompt** (string) — Testo che descrive gli elementi da escludere dall'immagine di output. Massimo 10.000 caratteri.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/bedrock/latest/userguide/model-parameters-diffusion-3-5-large.html)
+ **output\$1format** (string) — Formato dell'immagine di output. Enum: jpeg, png, webp. Impostazione predefinita: 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 ]
Il modello Stability.ai Stable Diffusion 3.5 Large ha i seguenti parametri di inferenza per una chiamata di inferenza. image-to-image
+ **prompt** (string) — Descrizione testuale dell'immagine di output desiderata. Massimo 10.000 caratteri.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/bedrock/latest/userguide/model-parameters-diffusion-3-5-large.html)
+ **image** (string) — Immagine di input con codifica Base64. Minimo 64 pixel per lato. Formati supportati: jpeg, png, webp.
+ **mode** (string) () - PredefinitoGenerationMode:. text-to-image Enum: image-to-image o text-to-image. Controlla se si tratta di una image-to-image generazione text-to-image o, il che influisce sui parametri richiesti:
+ text-to-image richiede solo il parametro prompt.
+ image-to-image richiede i parametri prompt, image e strength.
+ **forza** (numero) — Controlla l'influenza dell'immagine in ingresso sull'output. Intervallo compreso tra 0 e 1. Il valore 0 preserva l’immagine di input, il valore 1 ignora l’immagine di input.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/bedrock/latest/userguide/model-parameters-diffusion-3-5-large.html)
+ **seed** (number) — Valore per controllare la casualità nella generazione. Intervallo compreso tra 0 e 4294967294. Impostazione predefinita: 0 (seed casuale).
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/bedrock/latest/userguide/model-parameters-diffusion-3-5-large.html)
+ **negative\$1prompt** (string) — Testo che descrive gli elementi da escludere dall'immagine di output. Massimo 10.000 caratteri.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/bedrock/latest/userguide/model-parameters-diffusion-3-5-large.html)
+ **output\$1format** (string) — Formato dell'immagine di output. Enum: jpeg, png, webp. Impostazione predefinita: 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
})
)
```
------
# Richiesta e risposta Stable Image Core
Il corpo della richiesta viene passato nel `body` campo di una richiesta a [InvokeModel](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModel.html).
**Campo del corpo della richiesta per l’invocazione del modello**
Quando effettui una InvokeModel chiamata utilizzando un modello Stability AI Stable Diffusion Stable Image Core, compila il campo body con un oggetto JSON simile al seguente.
```
{
'prompt': 'Create an image of a panda'
}
```
**Campo del corpo delle risposte per l’invocazione del modello**
Quando effettui una InvokeModel chiamata utilizzando un modello Stability AI Stable Diffusion Stable Image Core, la risposta è la seguente
```
{
'seeds': [2130420379],
'finish_reasons': [null],
'images': ['...']
}
```
+ **seeds**: (stringa) elenco dei seed utilizzati per generare immagini per il modello.
+ **finish\$1reasons**: enum che indica se la richiesta è stata filtrata o meno. `null` indica che la richiesta è andata a buon fine. Valori correnti possibili: `"Filter reason: prompt", "Filter reason: output image", "Filter reason: input image", "Inference error", null`.
+ **images**: un elenco di immagini generate in formato stringa base64.
Per ulteriori informazioni, consulta [https://platform.us.stability. ai/docs/api-reference\$1tag/v1 generazione](https://platform.us.stability.ai/docs/api-reference#tag/v1generation).
------
#### [ Text to image ]
Il modello Stable Image Core ha i seguenti parametri di inferenza per effettuare chiamate di inferenza da testo a immagine.
**text\$1prompts** (obbligatorio): una matrice di prompt di testo da utilizzare per la generazione. Ogni elemento è un oggetto JSON che contiene un prompt e un peso per il prompt.
+ **prompt**: (stringa) cosa desideri vedere nell’immagine di output. Un prompt forte e descrittivo che definisca chiaramente elementi, colori e soggetti porterà a risultati migliori.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/bedrock/latest/userguide/model-parameters-diffusion-stable-image-core-text-image-request-response.html)
**Campi opzionali**
+ **aspect\$1ratio**: (stringa) controlla le proporzioni dell’immagine generata. Questo parametro è valido solo per text-to-image le richieste. Impostazione predefinita: 1:1. Enum: 16:9, 1:1, 21:9, 2:3, 3:2, 4:5, 5:4, 9:16, 9:21.
+ **output\$1format**: specifica il formato dell’immagine di output. Formati supportati: JPEG, PNG. Dimensioni supportate: altezza da 640 a 1.536 px, larghezza da 640 a 1.536 px.
+ **seed**: (numero) un valore specifico utilizzato per determinare la “casualità” della generazione. Ometti questo parametro o passa 0 per utilizzare un seed casuale. Intervallo: da 0 a 4294967295.
+ **negative\$1prompt**: parole chiave che indicano ciò che non desideri vedere nell’immagine di output. Massimo: 10.000 caratteri.
```
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")
```
------
# Servizi di immagine Stability AI
Puoi utilizzare Stability AI Image Services con Amazon Bedrock per accedere a tredici strumenti di modifica delle immagini specializzati progettati per accelerare i flussi di lavoro creativi professionali. Con i servizi di immagine Stability AI puoi generare immagini da uno schizzo, ristrutturare e ridisegnare un’immagine esistente o rimuovere e sostituire oggetti all’interno di un’immagine.
Questa sezione descrive come effettuare chiamate di inferenza a Stability AI Image Services utilizzando. [InvokeModel](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModel.html) Questa sezione fornisce anche esempi di codice in Python ed esempi di immagini prima e dopo l’utilizzo dei servizi di immagine Stability AI.
I servizi di immagine Stability AI sono disponibili nelle seguenti categorie:
+ **Modifica**: servizi di modifica delle immagini basati sull’IA, tra cui l’inpainting con maschere (riempimento generativo) o con parole. Include strumenti per il posizionamento e la pubblicità dei prodotti, oltre a strumenti di base come la rimozione dello sfondo.
+ **Controllo**: può richiedere prompt, mappe e altre guide. Questi servizi sfruttano ControlNets tecnologie simili basate su modelli Stable Diffusion.
**Nota**
L'abbonamento a qualsiasi servizio di modifica o controllo di Stability AI Image Service ti iscrive automaticamente a tutti i tredici Stability AI Image Services disponibili.
**Topics**
+ [Richiesta e risposta](#model-parameters-stable-image-services-request-response)
+ [Di lusso](#stable-image-services-upscale)
+ [Modifica](#stable-image-services-edit)
+ [Controllo](#stable-image-services-control)
## Richiesta e risposta
Il corpo della richiesta viene passato nel `body` campo di una richiesta a. [InvokeModel](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModel.html)
**Campo del corpo della richiesta per l’invocazione del modello**
Quando effettui una InvokeModel chiamata utilizzando Stability AI Image Services, compila il campo body con un oggetto JSON simile al seguente.
```
{
'prompt': 'Create an image of a panda'
}
```
**Campo del corpo delle risposte per l’invocazione del modello**
Quando effettui una InvokeModel chiamata utilizzando Stability AI Image Services, la risposta è la seguente
```
{
'seeds': [2130420379],
'finish_reasons': [null],
'images': ['...']
}
```
+ **seeds**: (stringa) elenco dei seed utilizzati per generare immagini per il modello.
+ **finish\$1reasons**: enum che indica se la richiesta è stata filtrata o meno. `null` indica che la richiesta è andata a buon fine. Valori correnti possibili: `"Filter reason: prompt", "Filter reason: output image", "Filter reason: input image", "Inference error", null`.
+ **images**: un elenco di immagini generate in formato stringa base64.
Per ulteriori informazioni, consulta [https://platform.us.stability. ai/docs/api-reference\$1tag/v1 generazione](https://platform.us.stability.ai/docs/api-reference#tag/v1generation).
## Di lusso
La sezione seguente descrive i servizi di immagine Stability AI di alto livello.
### Creative Upscale
Creative Upscale scatta immagini tra 64x64 e 1 megapixel e le converte alla risoluzione 4K. Questo servizio è in grado di eseguire l'upscaling delle immagini da 20 a 40 volte, preservandone e spesso migliorandone la qualità. Creative Upscale funziona al meglio su immagini altamente degradate e non è adatto a foto da 1 megapixel o più, in quanto esegue pesanti reimmaginazioni.
Creative Upscale presenta i seguenti parametri obbligatori:
+ **prompt**: ciò che desideri vedere nell’immagine di output. Un prompt forte e descrittivo che definisca chiaramente elementi, colori e soggetti porterà a risultati migliori. Per controllare il peso di una determinata parola utilizza il formato (word:weight), dove word è la parola di cui vuoi controllare il peso e weight è un valore. Un valore pari a 0 o 1,0 riduce l’enfasi sulla parola, mentre un valore compreso tra 1,1 e 2 la aumenta. Ad esempio: il cielo era nitido (blu: 0,3) e (verde: 1,8) indica un cielo blu e verde, ma più verde che blu. Minimo 0 e massimo 10.000 caratteri.
+ **image** ‐ (stringa) L'immagine Base64 di cui eseguire l'upscaling. Ogni lato dell’immagine deve avere una dimensione di almeno 64 pixel. Il numero totale di pixel deve essere compreso tra 4.096 e 1.048.576 pixel. Formati supportati: jpeg, png, webp.
I parametri seguenti sono facoltativi:
+ **creatività** ‐ (numero) Indica quanto deve essere creativo il modello quando si esegue l'upscaling di un'immagine. Valori più alti comporteranno l'aggiunta di maggiori dettagli all'immagine durante l'upscaling. Intervallo compreso tra 0,1 e 0,5. Predefinito 0,3
+ **negative\$1prompt**: (stringa) un testo che descrive ciò che non si desidera vedere nell’immagine di output. Questa è una caratteristica avanzata. Massimo 10000 caratteri.
+ **seed**: (numero) un valore specifico utilizzato per determinare la “casualità” della generazione. Ometti questo parametro o passa 0 per utilizzare un seed casuale. Intervallo compreso tra 0 e 4294967294. Impostazione predefinita: 0.
+ **output\$1format**: (stringa) indica il tipo di contenuto dell’immagine generata. Enum: jpeg, png, webp. Impostazione predefinita: png.
+ **style\$1preset**: guida il modello di immagine verso uno stile particolare. Enum: 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)
```
------
La tabella seguente mostra le immagini di input e output di un'operazione Creative Upscale utilizzando il seguente prompt: *Questa arte digitale onirica cattura un vivace uccello caleidoscopico in una lussureggiante foresta pluviale*.
| Input | Output |
| --- | --- |
| ![\[alt text not found\]](http://docs.aws.amazon.com/it_it/bedrock/latest/userguide/images/stable-image-services/input-creative-upscale.jpg) | ![\[alt text not found\]](http://docs.aws.amazon.com/it_it/bedrock/latest/userguide/images/stable-image-services/output-creative-upscale.jpg) |
### Elegante e conservatore
Conservative Upscale scatta immagini tra 64x64 e 1 megapixel e le converte alla risoluzione 4K. Questo servizio può eseguire l'upscaling delle immagini da 20 a 40 volte preservando tutti gli aspetti. Conservative Upscale riduce al minimo le alterazioni dell'immagine e non deve essere usato per reimmaginare un'immagine.
Conservative Upscale presenta i seguenti parametri obbligatori:
+ **prompt**: ciò che desideri vedere nell’immagine di output. Un prompt forte e descrittivo che definisca chiaramente elementi, colori e soggetti porterà a risultati migliori. Per controllare il peso di una determinata parola utilizza il formato (word:weight), dove word è la parola di cui vuoi controllare il peso e weight è un valore. Un valore pari a 0 o 1,0 riduce l’enfasi sulla parola, mentre un valore compreso tra 1,1 e 2 la aumenta. Ad esempio: il cielo era nitido (blu: 0,3) e (verde: 1,8) indica un cielo blu e verde, ma più verde che blu. Minimo 0 e massimo 10.000 caratteri.
+ **image** ‐ (string) L'immagine Base64 di cui eseguire l'upscaling. Ogni lato dell’immagine deve avere una dimensione di almeno 64 pixel. Il numero totale di pixel non può superare 9.437.184 pixel. Le proporzioni devono essere comprese tra 1:2.5 e 2.5:1. Formati supportati: jpeg, png, webp.
I parametri seguenti sono facoltativi:
+ **creatività** ‐ (numero) Indica quanto deve essere creativo il modello quando si esegue l'upscaling di un'immagine. Valori più alti comporteranno l'aggiunta di maggiori dettagli all'immagine durante l'upscaling. Intervallo compreso tra 0,1 e 0,5. Valore predefinito: 0,35
+ **negative\$1prompt**: (stringa) un testo che descrive ciò che non si desidera vedere nell’immagine di output. Questa è una caratteristica avanzata. Massimo 10000 caratteri.
+ **seed**: (numero) un valore specifico utilizzato per determinare la “casualità” della generazione. Ometti questo parametro o passa 0 per utilizzare un seed casuale. Intervallo compreso tra 0 e 4294967294. Impostazione predefinita: 0.
+ **output\$1format**: (stringa) indica il tipo di contenuto dell’immagine generata. Enum: jpeg, png, webp. Impostazione predefinita: 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)
```
------
La tabella seguente mostra le immagini di input e output di un'operazione Conservative Upscale utilizzando il seguente prompt: *foto di un pollo gigante in una* foresta.
| Input | Output |
| --- | --- |
| ![\[alt text not found\]](http://docs.aws.amazon.com/it_it/bedrock/latest/userguide/images/stable-image-services/input-conservative-upscale.jpg) | ![\[alt text not found\]](http://docs.aws.amazon.com/it_it/bedrock/latest/userguide/images/stable-image-services/output-conservative-upscale.jpg) |
### Veloce e di alto livello
Fast Upscale migliora la risoluzione delle immagini di 4 volte utilizzando l'intelligenza artificiale predittiva e generativa. Questo servizio leggero e veloce è ideale per migliorare la qualità delle immagini compresse, rendendolo adatto per post sui social media e altre applicazioni.
Fast upscale ha i seguenti parametri obbligatori:
+ **image** ‐ (string) L'immagine Base64 di cui eseguire l'upscaling. La larghezza deve essere compresa tra 32 e 1.536 pixel. L'altezza deve essere compresa tra 32 e 1.536 pixel. Il numero totale di pixel deve essere compreso tra 1.024 e 1.048.576 pixel. Formati supportati: jpeg, png, webp.
+ **output\$1format**: (stringa) indica il tipo di contenuto dell’immagine generata. Enum: jpeg, png, webp. Impostazione predefinita: 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)
```
------
La tabella seguente mostra le immagini di input e output di un'operazione Fast Upscale.
| Input | Output |
| --- | --- |
| ![\[alt text not found\]](http://docs.aws.amazon.com/it_it/bedrock/latest/userguide/images/stable-image-services/input-fast-upscale.jpg) | ![\[alt text not found\]](http://docs.aws.amazon.com/it_it/bedrock/latest/userguide/images/stable-image-services/output-fast-upscale.jpg) |
## Modifica
Nella sezione seguente viene descritta la modifica dei servizi di immagine Stability AI.
### Inpaint
Inpaint modifica in modo intelligente le immagini riempiendo o sostituendo aree specifiche con nuovi contenuti basati sul contenuto di un’immagine di maschera.
Inpaint ha i seguenti parametri richiesti:
+ **prompt**: ciò che desideri vedere nell’immagine di output. Un prompt forte e descrittivo che definisca chiaramente elementi, colori e soggetti porterà a risultati migliori. Per controllare il peso di una determinata parola utilizza il formato (word:weight), dove word è la parola di cui vuoi controllare il peso e weight è un valore. Un valore pari a 0 o 1,0 riduce l’enfasi sulla parola, mentre un valore compreso tra 1,1 e 2 la aumenta. Ad esempio: il cielo era nitido (blu: 0,3) e (verde: 1,8) indica un cielo blu e verde, ma più verde che blu. Minimo 0 e massimo 10.000 caratteri.
+ **image**: (stringa) l’immagine Base64 da colorare. Ogni lato dell’immagine deve avere una dimensione di almeno 64 pixel. Il numero totale di pixel non può superare 9.437.184 pixel. Le proporzioni devono essere comprese tra 1:2.5 e 2.5:1. Formati supportati: jpeg, png, webp.
I parametri seguenti sono facoltativi:
+ **style\$1preset**: (stringa) guida il modello di immagine verso uno stile particolare. Enum: 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**: (stringa) un testo che descrive ciò che non si desidera vedere nell’immagine di output. Questa è una caratteristica avanzata. Massimo 10000 caratteri.
+ **seed**: (numero) un valore specifico utilizzato per determinare la “casualità” della generazione. Ometti questo parametro o passa 0 per utilizzare un seed casuale. Intervallo compreso tra 0 e 4294967294. Impostazione predefinita: 0.
+ **output\$1format**: (stringa) indica il tipo di contenuto dell’immagine generata. Enum: jpeg, png, webp. Impostazione predefinita: png.
+ **mask**: (stringa) controlla l’intensità del processo di inpainting su una base per pixel, tramite una seconda immagine (passata a questo parametro) o tramite il canale alfa del parametro dell’immagine.
+ **Inserimento di una maschera**: l’immagine passata a questo parametro deve essere un’immagine in bianco e nero che rappresenti, in ogni pixel, la forza dell’inpainting in base al grado di oscurità o luce del pixel in questione. I pixel completamente neri rappresentano assenza di intensità di inpainting, mentre i pixel completamente bianchi rappresentano la massima intensità. Se la maschera ha una dimensione diversa dal parametro dell’immagine, verrà ridimensionata automaticamente.
+ **Supporto canale alfa**: se non fornisci una maschera esplicita, ne verrà derivata una dal canale alfa del parametro dell’immagine. I pixel trasparenti verranno sottoposti a inpainting, mentre i pixel opachi saranno preservati. Nel caso in cui venga fornita un’immagine con un canale alfa insieme a una maschera, la maschera avrà la precedenza.
+ **grow\$1mask**: espande gli edge della maschera verso l’esterno in tutte le direzioni del numero di pixel specificato. L’area ampliata intorno alla maschera verrà sfocata, il che può aiutare a rendere più uniforme la transizione tra il contenuto sottoposto a inpainting e l’immagine originale. Intervallo compreso tra 0 e 20. Impostazione predefinita: 5. Utilizza questo parametro se noti giunzioni o edge irregolari intorno al contenuto sottoposto a inpainting. Nota che una crescita eccessiva può oscurare i dettagli più piccoli della maschera e and/or unire le aree mascherate vicine.
------
#### [ 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)
```
------
La tabella seguente mostra le immagini di input e output di un’operazione Inpaint.
| Input | Mask (Maschera) | Output |
| --- | --- | --- |
| ![\[alt text not found\]](http://docs.aws.amazon.com/it_it/bedrock/latest/userguide/images/stable-image-services/input-image-inpaint.jpg) | ![\[alt text not found\]](http://docs.aws.amazon.com/it_it/bedrock/latest/userguide/images/stable-image-services/mask-image-inpaint.png) | ![\[alt text not found\]](http://docs.aws.amazon.com/it_it/bedrock/latest/userguide/images/stable-image-services/output-image-inpaint.jpg) |
### Vernice esterna
Outpaint inserisce contenuti aggiuntivi in un'immagine per riempire lo spazio in qualsiasi direzione. Rispetto ad altri tentativi automatici o manuali di espandere il contenuto di un'immagine, il servizio Outpaint riduce al minimo le indicazioni che l'immagine originale è stata modificata.
Outpaint ha i seguenti parametri obbligatori:
+ **image** ‐ (string) L'immagine Base64 da colorare. Ogni lato dell’immagine deve avere una dimensione di almeno 64 pixel. Il numero totale di pixel non può superare 9.437.184 pixel. Le proporzioni devono essere comprese tra 1:2.5 e 2.5:1. Formati supportati: jpeg, png, webp.
**Nota**
Almeno una direzione di outpaint: (sinistra, destra, su o giù) deve essere fornita con un valore diverso da zero. Per ottenere risultati di qualità ottimale, considerate la composizione e il contenuto dell'immagine originale quando scegliete le direzioni per la verniciatura.
I parametri seguenti sono facoltativi:
+ **prompt**: ciò che desideri vedere nell’immagine di output. Un prompt forte e descrittivo che definisca chiaramente elementi, colori e soggetti porterà a risultati migliori. Per controllare il peso di una determinata parola utilizza il formato (word:weight), dove word è la parola di cui vuoi controllare il peso e weight è un valore. Un valore pari a 0 o 1,0 riduce l’enfasi sulla parola, mentre un valore compreso tra 1,1 e 2 la aumenta. Ad esempio: il cielo era nitido (blu: 0,3) e (verde: 1,8) indica un cielo blu e verde, ma più verde che blu. Minimo 0 e massimo 10.000 caratteri.
+ **style\$1preset**: (stringa) guida il modello di immagine verso uno stile particolare. Enum: 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**: (numero) un valore specifico utilizzato per determinare la “casualità” della generazione. Ometti questo parametro o passa 0 per utilizzare un seed casuale. Intervallo compreso tra 0 e 4294967294. Impostazione predefinita: 0.
+ **output\$1format**: (stringa) indica il tipo di contenuto dell’immagine generata. Enum: jpeg, png, webp. Impostazione predefinita: png.
+ **creatività** ‐ (numero) Indica quanto deve essere creativo il modello quando deve sovraperniciare un'immagine. Valori più alti comporteranno l'aggiunta di più contenuti creativi all'immagine durante l'outpainting. Intervallo compreso tra 0,1 e 1,0. Impostazione predefinita: 0,5.
+ **left** ‐ (intero) Il numero di pixel da sovrapporre sul lato sinistro dell'immagine. Almeno una direzione di verniciatura deve essere fornita con un valore diverso da zero. Intervallo da 0 a 2000. Valore predefinito 0.
+ **right** ‐ (intero) Il numero di pixel da sovrapporre sul lato destro dell'immagine. Almeno una direzione di outpainting deve essere fornita con un valore diverso da zero. Intervallo da 0 a 2000. Valore predefinito 0.
+ **up** ‐ (intero) Il numero di pixel da sovrapporre alla parte superiore dell'immagine. Almeno una direzione di verniciatura deve essere fornita con un valore diverso da zero. Intervallo da 0 a 2000. Valore predefinito 0.
+ **down** ‐ (intero) Il numero di pixel da sovrapporre alla parte inferiore dell'immagine. Almeno una direzione di verniciatura deve essere fornita con un valore diverso da zero. Intervallo da 0 a 2000. Valore predefinito 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)
```
------
La tabella seguente mostra le immagini di input e output di un'operazione Outpaint.
| Input | Output |
| --- | --- |
| ![\[alt text not found\]](http://docs.aws.amazon.com/it_it/bedrock/latest/userguide/images/stable-image-services/input-image-outpaint.jpg) | ![\[alt text not found\]](http://docs.aws.amazon.com/it_it/bedrock/latest/userguide/images/stable-image-services/output-image-outpaint.jpg) |
### Cerca e ricolora
Cerca e ricolora consente di cambiare il colore di un oggetto specifico in un’immagine utilizzando un prompt. Questo servizio è una versione specifica di Inpainting che non richiede una maschera. Segmenta automaticamente l’oggetto e lo ricolora utilizzando i colori richiesti nel prompt.
Cerca e ricolora prevede parametri obbligatori seguenti:
+ **prompt**: ciò che desideri vedere nell’immagine di output. Un prompt forte e descrittivo che definisca chiaramente elementi, colori e soggetti porterà a risultati migliori. Per controllare il peso di una determinata parola utilizza il formato (word:weight), dove word è la parola di cui vuoi controllare il peso e weight è un valore. Un valore pari a 0 o 1,0 riduce l’enfasi sulla parola, mentre un valore compreso tra 1,1 e 2 la aumenta. Ad esempio: il cielo era nitido (blu: 0,3) e (verde: 1,8) indica un cielo blu e verde, ma più verde che blu. Minimo 0 e massimo 10.000 caratteri.
+ **image**: (stringa) l’immagine Base64 da ricolorare. Ogni lato dell’immagine deve avere una dimensione di almeno 64 pixel. Il numero totale di pixel non può superare 9.437.184 pixel. Le proporzioni devono essere comprese tra 1:2.5 e 2.5:1. Formati supportati: jpeg, png, webp.
+ **select\$1prompt**: (stringa) breve descrizione di cosa cercare nell’immagine. Massimo 10000 caratteri.
I parametri seguenti sono facoltativi:
+ **style\$1preset**: (stringa) guida il modello di immagine verso uno stile particolare. Enum: 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**: (stringa) un testo che descrive ciò che non si desidera vedere nell’immagine di output. Questa è una caratteristica avanzata. Massimo 10000 caratteri.
+ **seed**: (numero) un valore specifico utilizzato per determinare la “casualità” della generazione. Ometti questo parametro o passa 0 per utilizzare un seed casuale. Intervallo compreso tra 0 e 4294967294. Impostazione predefinita: 0.
+ **output\$1format**: (stringa) indica il tipo di contenuto dell’immagine generata. Enum: jpeg, png, webp. Impostazione predefinita: png.
+ **grow\$1mask**: espande gli edge della maschera verso l’esterno in tutte le direzioni del numero di pixel specificato. L’area ampliata intorno alla maschera verrà sfocata, il che può aiutare a rendere più uniforme la transizione tra il contenuto sottoposto a inpainting e l’immagine originale. Intervallo compreso tra 0 e 20. Impostazione predefinita: 5. Utilizza questo parametro se noti giunzioni o edge irregolari intorno al contenuto sottoposto a inpainting. Nota che una crescita eccessiva può oscurare i dettagli più piccoli della maschera e and/or unire le aree mascherate vicine.
------
#### [ 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)
```
------
La tabella seguente mostra le immagini di input e output di un’operazione di ricerca e ricolora utilizzando il seguente prompt: *giacca rosa*.
| Input | Output |
| --- | --- |
| ![\[alt text not found\]](http://docs.aws.amazon.com/it_it/bedrock/latest/userguide/images/stable-image-services/input-search-recolor.jpg) | ![\[alt text not found\]](http://docs.aws.amazon.com/it_it/bedrock/latest/userguide/images/stable-image-services/output-search-recolor.jpg) |
### Trova e sostituisci
Trova e sostituisci consente di utilizzare un prompt di ricerca per identificare un oggetto in un linguaggio semplice da sostituire. Il servizio segmenta automaticamente l’oggetto e lo sostituisce con l’oggetto richiesto nel prompt senza richiedere una maschera.
Trova e sostituisci prevede parametri obbligatori seguenti:
+ **prompt**: ciò che desideri vedere nell’immagine di output. Un prompt forte e descrittivo che definisca chiaramente elementi, colori e soggetti porterà a risultati migliori. Per controllare il peso di una determinata parola utilizza il formato (word:weight), dove word è la parola di cui vuoi controllare il peso e weight è un valore. Un valore pari a 0 o 1,0 riduce l’enfasi sulla parola, mentre un valore compreso tra 1,1 e 2 la aumenta. Ad esempio: il cielo era nitido (blu: 0,3) e (verde: 1,8) indica un cielo blu e verde, ma più verde che blu. Minimo 0 e massimo 10.000 caratteri.
+ **image**: (stringa) l’immagine Base64 da ricolorare. Ogni lato dell’immagine deve avere una dimensione di almeno 64 pixel. Il numero totale di pixel non può superare 9.437.184 pixel. Le proporzioni devono essere comprese tra 1:2.5 e 2.5:1. Formati supportati: jpeg, png, webp.
+ **search\$1prompt** ‐ (stringa) breve descrizione di cosa colorare nell’immagine. Massimo 10000 caratteri.
I parametri seguenti sono facoltativi:
+ **style\$1preset**: (stringa) guida il modello di immagine verso uno stile particolare. Enum: 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**: (stringa) un testo che descrive ciò che non si desidera vedere nell’immagine di output. Questa è una caratteristica avanzata. Massimo 10000 caratteri.
+ **seed**: (numero) un valore specifico utilizzato per determinare la “casualità” della generazione. Ometti questo parametro o passa 0 per utilizzare un seed casuale. Intervallo compreso tra 0 e 4294967294. Impostazione predefinita: 0.
+ **output\$1format**: (stringa) indica il tipo di contenuto dell’immagine generata. Enum: jpeg, png, webp. Impostazione predefinita: png.
+ **grow\$1mask**: espande gli edge della maschera verso l’esterno in tutte le direzioni del numero di pixel specificato. L’area ampliata intorno alla maschera verrà sfocata, il che può aiutare a rendere più uniforme la transizione tra il contenuto sottoposto a inpainting e l’immagine originale. Intervallo compreso tra 0 e 20. Impostazione predefinita: 5. Utilizza questo parametro se noti giunzioni o edge irregolari intorno al contenuto sottoposto a inpainting. Nota che una crescita eccessiva può oscurare i dettagli più piccoli della maschera e and/or unire le aree mascherate vicine.
------
#### [ 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)
```
------
La tabella seguente mostra le immagini di input e output di un’operazione Trova e sostituisci utilizzando il seguente prompt: *giacca*.
| Input | Output |
| --- | --- |
| ![\[alt text not found\]](http://docs.aws.amazon.com/it_it/bedrock/latest/userguide/images/stable-image-services/input-search-replace.jpg) | ![\[alt text not found\]](http://docs.aws.amazon.com/it_it/bedrock/latest/userguide/images/stable-image-services/output-search-replace.jpg) |
### Cancella
Cancella consente di rimuovere elementi indesiderati utilizzando maschere di immagini, mantenendo al contempo in modo intelligente la coerenza dello sfondo.
Cancella ha i seguenti parametri richiesti:
+ **image**: (stringa) l’immagine Base64 da cancellare. Ogni lato dell’immagine deve avere una dimensione di almeno 64 pixel. Il numero totale di pixel non può superare 9.437.184 pixel. Le proporzioni devono essere comprese tra 1:2.5 e 2.5:1. Formati supportati: jpeg, png, webp.
I parametri seguenti sono facoltativi:
+ **seed**: (numero) un valore specifico utilizzato per determinare la “casualità” della generazione. Ometti questo parametro o passa 0 per utilizzare un seed casuale. Intervallo compreso tra 0 e 4294967294. Impostazione predefinita: 0.
+ **output\$1format**: (stringa) indica il tipo di contenuto dell’immagine generata. Enum: jpeg, png, webp. Impostazione predefinita: png.
+ **mask**: (stringa) controlla l’intensità del processo di inpainting su una base per pixel, tramite una seconda immagine (passata a questo parametro) o tramite il canale alfa del parametro dell’immagine.
+ **Inserimento di una maschera**: l’immagine passata a questo parametro deve essere un’immagine in bianco e nero che rappresenti, in ogni pixel, la forza dell’inpainting in base al grado di oscurità o luce del pixel in questione. I pixel completamente neri rappresentano assenza di intensità di inpainting, mentre i pixel completamente bianchi rappresentano la massima intensità. Se la maschera ha una dimensione diversa dal parametro dell’immagine, verrà ridimensionata automaticamente.
+ **Supporto canale alfa**: se non fornisci una maschera esplicita, ne verrà derivata una dal canale alfa del parametro dell’immagine. I pixel trasparenti verranno sottoposti a inpainting, mentre i pixel opachi saranno preservati. Nel caso in cui venga fornita un’immagine con un canale alfa insieme a una maschera, la maschera avrà la precedenza.
+ **grow\$1mask**: espande gli edge della maschera verso l’esterno in tutte le direzioni del numero di pixel specificato. L’area ampliata intorno alla maschera verrà sfocata, il che può aiutare a rendere più uniforme la transizione tra il contenuto sottoposto a inpainting e l’immagine originale. Intervallo compreso tra 0 e 20. Impostazione predefinita: 5. Utilizza questo parametro se noti giunzioni o edge irregolari intorno al contenuto sottoposto a inpainting. Nota che una crescita eccessiva può oscurare i dettagli più piccoli della maschera e and/or unire le aree mascherate vicine.
**Nota**
Per risultati di cancellazione ottimali, assicurati che la maschera definisca accuratamente le aree da rimuovere. Se non viene fornita alcuna maschera esplicita, il servizio utilizza il canale alfa dell’immagine di input. La maschera ha la precedenza se vengono fornite entrambe.
------
#### [ 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)
```
------
La tabella seguente mostra le immagini di input e output di un’operazione Cancella.
| Input | Mask (Maschera) | Output |
| --- | --- | --- |
| ![\[alt text not found\]](http://docs.aws.amazon.com/it_it/bedrock/latest/userguide/images/stable-image-services/input-erase-object.jpg) | ![\[alt text not found\]](http://docs.aws.amazon.com/it_it/bedrock/latest/userguide/images/stable-image-services/mask-erase-object.png) | ![\[alt text not found\]](http://docs.aws.amazon.com/it_it/bedrock/latest/userguide/images/stable-image-services/output-erase-object.jpg) |
### Rimuovi sfondo
Rimuovi sfondo consente di isolare i soggetti dallo sfondo con precisione.
Rimuovi sfondo prevede parametri obbligatori seguenti:
+ **image**: (string) l’immagine Base64 da cui rimuovere lo sfondo. Ogni lato dell’immagine deve avere una dimensione di almeno 64 pixel. Il numero totale di pixel non può superare 9.437.184 pixel. Le proporzioni devono essere comprese tra 1:2.5 e 2.5:1. Formati supportati: jpeg, png, webp.
I parametri seguenti sono facoltativi:
+ **output\$1format**: (stringa) indica il tipo di contenuto dell’immagine generata. Enum: jpeg, png, webp. Impostazione predefinita: 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)
```
------
La tabella seguente mostra le immagini di input e output di un’operazione Rimuovi sfondo.
| Input | Output |
| --- | --- |
| ![\[alt text not found\]](http://docs.aws.amazon.com/it_it/bedrock/latest/userguide/images/stable-image-services/input-remove-background.jpg) | ![\[alt text not found\]](http://docs.aws.amazon.com/it_it/bedrock/latest/userguide/images/stable-image-services/output-remove-background.jpg) |
## Controllo
Nella sezione seguente viene descritto il controllo dei servizi Stability AI Image.
### Schizzo di controllo
Trasforma schizzi grezzi disegnati a mano in risultati raffinati con un controllo preciso. Per le immagini non disegnate, Schizzo di controllo consente una manipolazione dettagliata dell’aspetto finale sfruttando le linee di contorno e gli edge all’interno dell’immagine.
Schizzo di controllo ha i seguenti parametri richiesti:
+ **prompt**: ciò che desideri vedere nell’immagine di output. Un prompt forte e descrittivo che definisca chiaramente elementi, colori e soggetti porterà a risultati migliori. Per controllare il peso di una determinata parola utilizza il formato (word:weight), dove word è la parola di cui vuoi controllare il peso e weight è un valore. Un valore pari a 0 o 1,0 riduce l’enfasi sulla parola, mentre un valore compreso tra 1,1 e 2 la aumenta. Ad esempio: il cielo era nitido (blu: 0,3) e (verde: 1,8) indica un cielo blu e verde, ma più verde che blu. Minimo 0 e massimo 10.000 caratteri.
+ **image**: (stringa) l’immagine Base64 dello schizzo. Ogni lato dell’immagine deve avere una dimensione di almeno 64 pixel. Il numero totale di pixel non può superare 9.437.184 pixel. Le proporzioni devono essere comprese tra 1:2.5 e 2.5:1. Formati supportati: jpeg, png, webp.
I parametri seguenti sono facoltativi:
+ **control\$1strength**: (numero) quanta influenza o controllo ha l’immagine sulla generazione. Rappresentata come un float compreso tra 0 e 1, dove 0 è l’influenza minima e 1 è la massima. Impostazione predefinita: 0,7.
+ **negative\$1prompt**: (stringa) un testo che descrive ciò che non si desidera vedere nell’immagine di output. Questa è una caratteristica avanzata. Massimo 10000 caratteri.
+ **seed**: (numero) un valore specifico utilizzato per determinare la “casualità” della generazione. Ometti questo parametro o passa 0 per utilizzare un seed casuale. Intervallo compreso tra 0 e 4294967294. Impostazione predefinita: 0.
+ **output\$1format**: (stringa) indica il tipo di contenuto dell’immagine generata. Enum: jpeg, png, webp. Impostazione predefinita: png.
+ **style\$1preset**: guida il modello di immagine verso uno stile particolare. Enum: 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)
```
------
La tabella seguente mostra le immagini di input e output di una chiamata Schizzo di controllo utilizzando il seguente prompt: *una casa con sullo sfondo le montagne e il fiume che scorre nelle vicinanze*.
| Input | Output |
| --- | --- |
| ![\[alt text not found\]](http://docs.aws.amazon.com/it_it/bedrock/latest/userguide/images/stable-image-services/input-control-sketch.jpg) | ![\[alt text not found\]](http://docs.aws.amazon.com/it_it/bedrock/latest/userguide/images/stable-image-services/output-control-sketch.jpg) |
| | |
### Struttura di controllo
Struttura di controllo consente di generare immagini mantenendo la struttura di un’immagine di input. Ciò è particolarmente utile per scenari avanzati di creazione di contenuti, come la ricreazione di scene o il rendering di personaggi a partire da modelli.
Schizzo di controllo ha i seguenti parametri richiesti:
+ **prompt**: ciò che desideri vedere nell’immagine di output. Un prompt forte e descrittivo che definisca chiaramente elementi, colori e soggetti porterà a risultati migliori. Per controllare il peso di una determinata parola utilizza il formato (word:weight), dove word è la parola di cui vuoi controllare il peso e weight è un valore. Un valore pari a 0 o 1,0 riduce l’enfasi sulla parola, mentre un valore compreso tra 1,1 e 2 la aumenta. Ad esempio: il cielo era nitido (blu: 0,3) e (verde: 1,8) indica un cielo blu e verde, ma più verde che blu. Minimo 0 e massimo 10.000 caratteri.
+ **image**: (stringa) l’immagine Base64 dello schizzo. Ogni lato dell’immagine deve avere una dimensione di almeno 64 pixel. Il numero totale di pixel non può superare 9.437.184 pixel. Le proporzioni devono essere comprese tra 1:2.5 e 2.5:1. Formati supportati: jpeg, png, webp.
I parametri seguenti sono facoltativi:
+ **control\$1strength**: (numero) quanta influenza o controllo ha l’immagine sulla generazione. Rappresentata come un float compreso tra 0 e 1, dove 0 è l’influenza minima e 1 è la massima. Impostazione predefinita: 0,7.
+ **negative\$1prompt**: (stringa) un testo che descrive ciò che non si desidera vedere nell’immagine di output. Questa è una caratteristica avanzata. Massimo 10000 caratteri.
+ **seed**: (numero) un valore specifico utilizzato per determinare la “casualità” della generazione. Ometti questo parametro o passa 0 per utilizzare un seed casuale. Intervallo compreso tra 0 e 4294967294. Impostazione predefinita: 0.
+ **output\$1format**: (stringa) indica il tipo di contenuto dell’immagine generata. Enum: jpeg, png, webp. Impostazione predefinita: png.
+ **style\$1preset**: guida il modello di immagine verso uno stile particolare. Enum: 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)
```
------
La tabella seguente mostra le immagini di input e output di un’operazione Struttura di controllo utilizzando il seguente prompt: *struttura surreale con scintille generate dal movimento che illuminano la scena*.
| Input | Output |
| --- | --- |
| ![\[alt text not found\]](http://docs.aws.amazon.com/it_it/bedrock/latest/userguide/images/stable-image-services/input-control-structure.jpg) | ![\[alt text not found\]](http://docs.aws.amazon.com/it_it/bedrock/latest/userguide/images/stable-image-services/output-control-structure.jpg) |
### Guida di stile
La Guida di stile consente di estrarre elementi stilistici da un’immagine di input e utilizzarli per guidare la creazione di un’immagine di output in base al prompt. Il risultato è una nuova immagine nello stesso stile dell’immagine di input.
La guida di stile ha i seguenti parametri richiesti:
+ **prompt**: ciò che desideri vedere nell’immagine di output. Un prompt forte e descrittivo che definisca chiaramente elementi, colori e soggetti porterà a risultati migliori. Per controllare il peso di una determinata parola utilizza il formato (word:weight), dove word è la parola di cui vuoi controllare il peso e weight è un valore. Un valore pari a 0 o 1,0 riduce l’enfasi sulla parola, mentre un valore compreso tra 1,1 e 2 la aumenta. Ad esempio: il cielo era nitido (blu: 0,3) e (verde: 1,8) indica un cielo blu e verde, ma più verde che blu. Minimo 0 e massimo 10.000 caratteri.
+ **image**: (stringa) l’immagine Base64 dello schizzo. Ogni lato dell’immagine deve avere una dimensione di almeno 64 pixel. Il numero totale di pixel non può superare 9.437.184 pixel. Le proporzioni devono essere comprese tra 1:2.5 e 2.5:1. Formati supportati: jpeg, png, webp.
I parametri seguenti sono facoltativi:
+ **aspect\$1ratio**: (stringa) controlla le proporzioni dell’immagine generata. Questo parametro è valido solo per text-to-image le richieste. Impostazione predefinita: 1:1. Enum: 16:9, 1:1, 21:9, 2:3, 3:2, 4:5, 5:4, 9:16, 9:21. Impostazione predefinita 1:1.
+ **negative\$1prompt**: (stringa) un testo che descrive ciò che non si desidera vedere nell’immagine di output. Questa è una caratteristica avanzata. Massimo 10000 caratteri.
+ **seed**: (numero) un valore specifico utilizzato per determinare la “casualità” della generazione. Ometti questo parametro o passa 0 per utilizzare un seed casuale. Intervallo compreso tra 0 e 4294967294. Impostazione predefinita: 0.
+ **output\$1format**: (stringa) indica il tipo di contenuto dell’immagine generata. Enum: jpeg, png, webp. Impostazione predefinita: png.
+ **fidelity**: (numero) quanto lo stile dell’immagine di output assomiglia allo stile dell’immagine di input. Intervallo compreso tra 0 e 1. Impostazione predefinita: 0,5.
+ **style\$1preset**: guida il modello di immagine verso uno stile particolare. Enum: 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)
```
------
La tabella seguente mostra le immagini di input e output di una chiamata Guida di stile utilizzando il seguente prompt: *ripresa panoramica di una metropoli moderna*.
| Input | Output |
| --- | --- |
| ![\[alt text not found\]](http://docs.aws.amazon.com/it_it/bedrock/latest/userguide/images/stable-image-services/input-style-guide.jpg) | ![\[alt text not found\]](http://docs.aws.amazon.com/it_it/bedrock/latest/userguide/images/stable-image-services/output-style-guide.jpg) |
### Trasferimento di stile
Trasferimento di stile consente di applicare le caratteristiche visive delle immagini di stile di riferimento alle immagini di destinazione. Mentre il servizio Guida di stile estrae gli elementi stilistici da un’immagine di input e li utilizza per guidare la creazione di un’immagine di output in base al prompt, Trasferimento di stile trasforma specificamente il contenuto esistente preservando la composizione originale. Questo strumento aiuta a creare contenuti coerenti su più risorse.
Trasferimento di stile ha i seguenti parametri richiesti:
+ **init\$1image**: (stringa) un’immagine Base64 contenente il soggetto a cui desideri modificare lo stile. Ogni lato dell’immagine deve avere una dimensione di almeno 64 pixel. Il numero totale di pixel non può superare 9.437.184 pixel. Le proporzioni devono essere comprese tra 1:2.5 e 2.5:1. Formati supportati: jpeg, png, webp.
+ **style\$1image**: (stringa) un’immagine Base64 contenente il soggetto di cui desideri modificare lo stile. Ogni lato dell’immagine deve avere una dimensione di almeno 64 pixel. Il numero totale di pixel non può superare 9.437.184 pixel. Le proporzioni devono essere comprese tra 1:2.5 e 2.5:1. Formati supportati: jpeg, png, webp.
I parametri seguenti sono facoltativi:
+ **prompt**: (stringa) cosa si desidera vedere nell’immagine di output. Un prompt forte e descrittivo che definisca chiaramente elementi, colori e soggetti porterà a risultati migliori. Per controllare il peso di una determinata parola utilizza il formato (word:weight), dove word è la parola di cui vuoi controllare il peso e weight è un valore. Un valore pari a 0 o 1,0 riduce l’enfasi sulla parola, mentre un valore compreso tra 1,1 e 2 la aumenta. Ad esempio: il cielo era nitido (blu: 0,3) e (verde: 1,8) indica un cielo blu e verde, ma più verde che blu.
+ **negative\$1prompt**: (stringa) un testo che descrive ciò che non si desidera vedere nell’immagine di output. Questa è una caratteristica avanzata. Massimo 10000 caratteri.
+ **seed**: (numero) un valore specifico utilizzato per determinare la “casualità” della generazione. Ometti questo parametro o passa 0 per utilizzare un seed casuale. Intervallo compreso tra 0 e 4294967294. Impostazione predefinita: 0.
+ **output\$1format**: (stringa) indica il tipo di contenuto dell’immagine generata. Enum: jpeg, png, webp. Impostazione predefinita: png.
+ **composition\$1fidelity**: (numero) quanto lo stile dell’immagine di output assomiglia allo stile dell’immagine di input. Intervallo compreso tra 0 e 1. Impostazione predefinita: 0,9.
+ **style\$1strength**: (numero) a volte chiamato denoising, questo parametro controlla l’influenza del parametro style\$1image sull’immagine generata. Un valore pari a 0 restituirebbe un’immagine identica all’input. Un valore pari a 1 sarebbe come se non fosse stata trasmessa alcuna immagine. Intervallo compreso tra 0 e 1. Impostazione predefinita: 1.
+ **change\$1strength**: (numero) quanto deve cambiare l’immagine originale. Intervallo compreso tra 0,1 e 1. Impostazione predefinita: 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)
```
------
La tabella seguente mostra le immagini di input e output di una chiamata Trasferimento di stile.
| Input | Stile | Output |
| --- | --- | --- |
| ![\[alt text not found\]](http://docs.aws.amazon.com/it_it/bedrock/latest/userguide/images/stable-image-services/input-style-transfer.jpg) | ![\[alt text not found\]](http://docs.aws.amazon.com/it_it/bedrock/latest/userguide/images/stable-image-services/style-style-transfer.jpg) | ![\[alt text not found\]](http://docs.aws.amazon.com/it_it/bedrock/latest/userguide/images/stable-image-services/output-style-transfer.jpg) |
# Modelli TwelveLabs
In questa sezione vengono descritti i parametri di richiesta e i campi di risposta per i modelli TwelveLabs. Utilizzare queste informazioni per effettuare chiamate di inferenza ai modelli TwelveLabs. Il TwelveLabs Pegasus 1.2 modello supporta operazioni [InvokeModel](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModel.html)e [InvokeModelWithResponseStream](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModelWithResponseStream.html)(streaming). I TwelveLabs Marengo Embed 3.0 modelli TwelveLabs Marengo Embed 2.7 e supportano [StartAsyncInvoke](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_StartAsyncInvoke.html)le operazioni. Questa sezione include anche esempi di codice che mostrano come chiamare i modelli TwelveLabs. Per utilizzare un modello in un’operazione di inferenza, è necessario l’ID modello per il modello. Per ottenere l’ID modello, consulta [Modelli di fondazione supportati in Amazon Bedrock](models-supported.md).
TwelveLabs è un provider leader di modelli di IA multimodali specializzato nella comprensione e nell’analisi dei video. I loro modelli avanzati consentono sofisticate funzionalità di ricerca, analisi e generazione di contenuti video attraverso tecnologie di visione state-of-the-art artificiale e di elaborazione del linguaggio naturale.
Amazon Bedrock offre tre TwelveLabs modelli:
+ TwelveLabs Pegasus 1.2fornisce una comprensione e un'analisi video complete.
+ TwelveLabs Marengo Embed 2.7genera incorporamenti di alta qualità per contenuti video, di testo, audio e immagini.
+ TwelveLabs Marengo Embed 3.0è il modello di incorporamento più recente con prestazioni e funzionalità avanzate.
Questi modelli consentono di creare applicazioni in grado di elaborare, analizzare e ricavare informazioni dai dati video su larga scala.
**TwelveLabs Pegasus 1.2**
Un modello multimodale che offre funzionalità complete di comprensione e analisi dei video, tra cui il riconoscimento dei contenuti, il rilevamento delle scene e la comprensione contestuale. Il modello può analizzare i contenuti video e generare descrizioni testuali, approfondimenti e risposte a domande sul video.
**TwelveLabs Marengo Embed 2.7**
Un modello di embedding multimodale che genera rappresentazioni vettoriali di alta qualità di contenuti video, testo, audio e immagini per la ricerca di similarità, il clustering e altre attività di machine learning. Il modello supporta diverse modalità di input e fornisce embedding specializzati ottimizzati per diversi casi d’uso.
**TwelveLabs Marengo Embed 3.0**
Un modello di incorporamento multimodale avanzato che estende le funzionalità di Marengo 2.7 con il supporto per la modalità di immissione interlacciata di testo e immagini. Questo modello genera rappresentazioni vettoriali di alta qualità di contenuti video, testo, audio, immagini e testo e immagini interlacciati per la ricerca di similarità, il clustering e altre attività di apprendimento automatico.
**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
Il modello TwelveLabs Pegasus 1.2 offre funzionalità complete di comprensione e analisi video. Può analizzare i contenuti video e generare descrizioni testuali, approfondimenti e risposte a domande sul video.
Utilizzate queste informazioni per effettuare chiamate di inferenza ai TwelveLabs modelli con le operazioni InvokeModel, InvokeModelWithResponseStream (streaming).
+ Provider: TwelveLabs
+ Categorie: comprensione dei video, analisi dei contenuti
+ ID modello: `twelvelabs.pegasus-1-2-v1:0`
+ Modalità di input: video
+ Modalità di output: testo
+ Dimensione massima del video: video della durata di 1 ora (dimensione del file < 2 GB)
## Parametri delle richieste di TwelveLabs Pegasus 1.2
La tabella seguente descrive i parametri di input per il modello TwelveLabs Pegasus 1.2:
**Parametri della richiesta di TwelveLabs Pegasus 1.2**
| Campo | Tipo | Campo obbligatorio | Descrizione |
| --- | --- | --- | --- |
| inputPrompt | stringa | Sì | Prompt per analizzare il video. Max: 2.000 token. |
| temperature | virgola mobile a doppia precisione | No | Temperatura per il modello. Controlla la casualità nell’output. Predefinito: 0,2, Min: 0, Max: 1. |
| responseFormat | Oggetto | No | Consente agli utenti di specificare il formato di output strutturato. Attualmente supporta solo json\$1schema. |
| mediaSource | oggetto | Sì | Descrive l’origine del file multimediale. È necessario specificarebase64String o s3Location. |
| mediaSource.base64String | stringa | No | Stringa di byte codificata in Base64 per il video. Massimo: 25 MB. |
| mediaSource.s3Location.uri | stringa | No | URI S3 da cui è possibile scaricare il video. Max: video della durata di 1 ora (dimensione del file < 2 GB). |
| mediaSource.s3Location.bucketOwner | stringa | No | ID account AWS del proprietario del bucket. |
| maxOutputTokens | numero intero | No | Il numero massimo di token da generare. Massimo: 4096. |
## Campi di risposta di TwelveLabs Pegasus 1.2
La tabella seguente descrive i campi di output per il modello TwelveLabs Pegasus 1.2:
**Campi di risposta di TwelveLabs Pegasus 1.2**
| Campo | Tipo | Description |
| --- | --- | --- |
| message | stringa | Messaggio di output contenente l’analisi del video effettuata dal modello. |
| finishReason | stringa | Motivo dell’interruzione che descrive il motivo per cui l’output è terminato. Valori validi: stop (l’API ha restituito i completamenti completi senza raggiungere alcun limite), length (la generazione ha superato il limite max\$1tokens). |
## Richiesta e risposta di TwelveLabs Pegasus 1.2
Negli esempi seguenti viene illustrato come utilizzare il modello TwelveLabs Pegasus 1.2 con diverse origini di input.
------
#### [ Request ]
Gli esempi seguenti mostrano i formati di richiesta per il modello TwelveLabs Pegasus 1.2.
**Utilizzo di video con codifica base64:**
```
{
"inputPrompt": "tell me about the video",
"mediaSource": {
"base64String": ""
},
"temperature": 0
}
```
**Utilizzo di video archiviati in S3:**
```
{
"inputPrompt": "Tell me about this video",
"mediaSource": {
"s3Location": {
"uri": "s3://path-to-video-object-in-s3",
"bucketOwner": "bucket-owner-account-id"
}
},
"temperature": 0
}
```
**Utilizzo del formato di output strutturato:**
```
{
"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 ]
Gli esempi seguenti mostrano i formati di richiesta per il modello TwelveLabs Pegasus 1.2.
**Risposta standard:**
```
{
"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"
}
```
**Risposta con output strutturato:**
```
{
"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"
}
```
**Risposta al raggiungimento del numero massimo di token:**
```
{
"message": "This video contains multiple scenes showing various activities. The first scene shows...",
"finishReason": "length"
}
```
------
# TwelveLabs Marengo Embed 2.7
Il modello TwelveLabs Marengo Embed 2.7 genera embedding da input video, testo, audio o immagini. Questi embedding possono essere utilizzati per la ricerca di similarità, il clustering e altre attività di machine learning.
+ Fornitore: TwelveLabs
+ ID modello: twelvelabs.marengo-embed-2-7-v1:0
Il modello TwelveLabs Marengo Embed 2.7 supporta le operazioni di runtime per Amazon Bedrock riportate nella tabella seguente.
+ Per ulteriori informazioni sui casi d’uso per i diversi metodi API, consultare [Informazioni sui casi d’uso per diversi metodi di inferenza del modelloDiversi metodi di inferenza](inference-methods.md).
+ Per ulteriori informazioni sui tipi di modello, consultare [Funzionamento dell’inferenza in Amazon BedrockFunzionamento dell’inferenza](inference-how.md).
+ Per un elenco di modelli IDs e per visualizzare i modelli e AWS le regioni supportati TwelveLabs Marengo Embed 2.7 in, cercate il modello nella tabella all'indirizzo[Modelli di fondazione supportati in Amazon Bedrock](models-supported.md).
+ Per un elenco completo dei profili di inferenza IDs, vedere[Regioni e modelli supportati per i profili di inferenza](inference-profiles-support.md). L'ID del profilo di inferenza si basa sulla AWS regione.
****
| Operazione API | Tipi di modelli supportati | Modalità di input | Modalità di output |
| --- | --- | --- | --- |
| InvokeModel | [Profili di inferenza](inference-profiles-support.md) | Testo Immagine | Embedding |
| StartAsyncInvoke | [Modelli base](models-supported.md) | Video Audio Immagine Testo | Embedding |
**Nota**
Utilizzare `InvokeModel` per generare embedding per la query di ricerca. Utilizzare `StartAsyncInvoke` per generare embedding per risorse su larga scala.
All’input si applicano i seguenti limiti:
****
| Modalità di input | Massimo |
| --- | --- |
| Testo | 77 gettoni |
| Immagine | 5 MB |
| Video (S3) | 2 GB |
| Audio (S3) | 2 GB |
**Nota**
Se si definiscono audio o video inline utilizzando la codifica base64, assicurarsi che il payload del corpo della richiesta non superi la quota di invocazione del modello Amazon Bedrock di 25 MB.
**Topics**
+ [Parametri delle richieste di TwelveLabs Marengo Embed 2.7](#model-parameters-marengo-async-request)
+ [Risposta di TwelveLabs Marengo Embed 2.7](#model-parameters-marengo-response)
+ [Esempi di codice di TwelveLabs Marengo Embed 2.7](#model-parameters-marengo-examples)
## Parametri delle richieste di TwelveLabs Marengo Embed 2.7
Quando si effettua una richiesta, il campo in cui viene specificato l’input specifico del modello dipende dall’operazione dell’API:
+ [InvokeModel](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModel.html)— Nella richiesta`body`.
+ [StartAsyncInvoke](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_StartAsyncInvoke.html)— Nel `modelInput` campo del corpo della richiesta.
Il formato dell’input del modello dipende dalla modalità di input:
------
#### [ 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
}
```
------
Espandi le seguenti sezioni per ulteriori informazioni sui parametri di input:
### inputType
Modalità per l’embedding.
+ **Tipo:** stringa
+ **Obbligatorio:** sì
+ **Valori validi**: `video` \$1 `text` \$1 `audio` \$1 `image`
### inputText
Testo da incorporare.
+ ▬**Tipo:** stringa
+ **Obbligatorio:** sì (per i tipi di input compatibili)
+ **Tipi di input compatibili:** testo
### textTruncate
Specifica in che modo la piattaforma tronca il testo.
+ ▬**Tipo:** stringa
+ **Obbligatorio:** no
+ **Valori validi**:
+ `end`: tronca la fine del testo.
+ `none`: restituisce un errore se il testo supera il limite.
+ **Valore predefinito:** end
+ **Tipi di input compatibili:** testo
### mediaSource
Contiene informazioni sull’origine multimediale.
+ **Tipo:** oggetto
+ **Obbligatorio:** sì (se il tipo è compatibile)
+ **Tipi di input compatibili:** immagine, video, audio
Il formato dell’oggetto `mediaSource` nel corpo della richiesta dipende se il file multimediale è definito come stringa codificata in Base64 o come posizione S3.
+ **Stringa con codifica Base64**
```
{
"mediaSource": {
"base64String": "base64-encoded string"
}
}
```
+ `base64String`: stringa con codifica Base64 per il file multimediale.
+ **Posizione S3**: specifica l'URI S3 e il proprietario del bucket.
```
{
"s3Location": {
"uri": "string",
"bucketOwner": "string"
}
}
```
+ `uri`: URI S3 contenente il file multimediale.
+ `bucketOwner`— L'ID dell'AWSaccount del proprietario del bucket S3.
### embeddingOption
Specifica i tipi di embedding da recuperare.
+ Tipo: elenco
+ **Obbligatorio:** no
+ **Valori validi per i membri dell’elenco:**
+ `visual-text`: embedding visivi ottimizzati per la ricerca di testo.
+ `visual-image`: embedding visivi ottimizzati per la ricerca di immagine.
+ `audio`: embedding dell’audio nel video.
+ **Valore predefinito:** [“visual-text”, “visual-image”, “audio”]
+ **Tipi di input compatibili:** video, audio
### startSec
Punto temporale in secondi del clip in cui deve iniziare l’elaborazione.
+ **Tipo:** numero a doppia precisione
+ **Obbligatorio:** no
+ **Valore minimo:** 0
+ **Valore predefinito**: 0
+ **Tipi di input compatibili:** video, audio
### lengthSec
Tempo in secondi, contando a partire dal momento temporale `startSec`, dopo il quale l’elaborazione dovrebbe interrompersi.
+ **Tipo:** numero a doppia precisione
+ **Obbligatorio:** no
+ **Valori validi:** 0 - Durata del file multimediale
+ **Valore predefinito:** durata del file multimediale
+ **Tipi di input compatibili:** video, audio
Esempio:
+ startSec: 5
+ lengthSec: 20
+ Risultato: la clip viene elaborata da 0:05 a 0:25 (5 secondi \$1 20 secondi).
### useFixedLengthSec
Durata di ogni clip per il quale il modello deve generare un embedding.
+ **Tipo:** numero a doppia precisione
+ **Obbligatorio:** no
+ **Parametri del valore:** 2 - 10. Deve essere maggiore o uguale a `minClipSec`.
+ **Valore predefinito:** dipende dal tipo di file multimediale:
+ **Video:** diviso dinamicamente mediante il rilevamento dei confini del colpo.
+ **Audio:** diviso in modo uniforme con segmenti il più vicini possibile a 10 secondi.
Esempi:
+ Una clip di 50 secondi è divisa in 5 segmenti da 10 secondi.
+ Una clip di 16 secondi è divisa in 2 segmenti da 8 secondi.
+ **Tipi di input compatibili:** video, audio
+ **Note:** deve essere maggiore o uguale a `minClipSec`.
### minClipSec
Imposta un valore minimo per ogni clip in secondi.
+ **Type:** int
+ **Obbligatorio:** no
+ **Parametri del valore:** intervallo: 1-5
+ **Valore predefinito: 4**
+ **Tipi di input compatibili:** video
+ **Note:** deve essere maggiore o uguale a `useFixedLengthSec`.
## Risposta di TwelveLabs Marengo Embed 2.7
La posizione degli embedding di output e dei metadati associati dipende dal metodo di invocazione:
+ [InvokeModel](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModel.html)— Nel corpo della risposta.
+ [StartAsyncInvoke](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_StartAsyncInvoke.html)— Nel bucket S3 definito in`s3OutputDataConfig`, dopo il completamento del processo di invocazione asincrona.
Se sono presenti più vettori di embedding, l’output è un elenco di oggetti, ciascuno contenente un vettore e i relativi metadati associati.
Il formato del vettore degli embedding di output è il seguente:
```
{
"embedding": ["string"],
"embeddingOption": "visual-text" | "visual-image" | "audio",
"startSec": double,
"endsec": double
}
```
Espandere le seguenti sezioni per ulteriori informazioni sui parametri della risposta:
### embedding
Rappresentazione dei vettori di embedding dell’input.
+ **Tipo**: elenco di numeri a doppia precisione
### embeddingOption
Tipo di embedding.
+ ▬**Tipo:** stringa
+ **Valori possibili:**
+ `visual-text`: embedding visivi ottimizzati per la ricerca di testo.
+ `visual-image`: embedding visivi ottimizzati per la ricerca di immagine.
+ `audio`: embedding dell’audio nel video.
+ **Tipi di input compatibili:** video
### startSec
Offset iniziale del clip.
+ **Tipo:** numero a doppia precisione
+ **Tipi di input compatibili:** video, audio
### endSec
Offset finale del clip, in secondi.
+ **Tipo:** numero a doppia precisione
+ **Tipi di input compatibili:** video, audio
## Esempi di codice di TwelveLabs Marengo Embed 2.7
Questa sezione mostra come utilizzare il modello TwelveLabs Marengo Embed 2.7 con diversi tipi di input utilizzando Python. Gli esempi mostrano come definire l'input specifico del modello ed eseguire le chiamate del modello.
**Nota**
InvokeModel supporta solo l'immissione di testo e immagini. Per l'ingresso video e audio, usa StartAsyncInvoke.
Assemblare il codice seguendo questa procedura:
**1. Definisci l’input specifico del modello**
Definire l’input specifico del modello in base al tipo di input:
------
#### [ 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. Eseguire l’invocazione del modello utilizzando l’input del modello**
Poi aggiungere il frammento di codice che corrisponde al metodo di invocazione del modello scelto.
------
#### [ 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
Il TwelveLabs Marengo Embed 3.0 modello genera incorporamenti avanzati da input di video, testo, audio o immagini. Quest'ultima versione offre prestazioni e precisione migliorate per la ricerca di similarità, il clustering e altre attività di apprendimento automatico.
+ Fornitore: TwelveLabs
+ ID modello: twelvelabs.marengo-embed-3-0-v1:0
Marengo Embed 3.0 offre diversi miglioramenti chiave:
+ **Capacità di elaborazione video estesa**: elabora fino a 4 ore di contenuti video e audio. I file possono pesare fino a 6 GB, ovvero il doppio della capacità delle versioni precedenti. Ciò lo rende ideale per analizzare eventi sportivi completi, video di allenamento prolungati e produzioni cinematografiche complete.
+ **Analisi sportiva avanzata**: il modello offre miglioramenti significativi. Fornisce una migliore comprensione delle dinamiche di gioco, dei movimenti dei giocatori e del rilevamento degli eventi.
+ **Supporto multilingue globale**: funzionalità linguistiche estese da 12 a 36 lingue. Ciò consente alle organizzazioni globali di creare sistemi di ricerca e recupero unificati che funzionano perfettamente in diverse regioni e mercati.
+ **Precisione della ricerca multimodale**: combina immagini e testo descrittivo in un'unica richiesta di incorporamento. Ciò unisce la somiglianza visiva con la comprensione semantica per fornire risultati di ricerca più accurati e contestualmente pertinenti.
+ **Dimensione di incorporamento ridotta**: ridotta da 1024 a 512, il che può aiutare a ridurre i costi di archiviazione.
Il modello TwelveLabs Marengo Embed 3.0 supporta le operazioni di runtime per Amazon Bedrock riportate nella tabella seguente.
+ Per ulteriori informazioni sui casi d’uso per i diversi metodi API, consultare [Informazioni sui casi d’uso per diversi metodi di inferenza del modelloDiversi metodi di inferenza](inference-methods.md).
+ Per ulteriori informazioni sui tipi di modello, consultare [Funzionamento dell’inferenza in Amazon BedrockFunzionamento dell’inferenza](inference-how.md).
+ Per un elenco di modelli IDs e per visualizzare i modelli e AWS le regioni supportatiTwelveLabs Marengo Embed 3.0, cercate il modello nella tabella all'indirizzo. [Modelli di fondazione supportati in Amazon Bedrock](models-supported.md)
+ Per un elenco completo dei profili di inferenza IDs, vedere[Regioni e modelli supportati per i profili di inferenza](inference-profiles-support.md). L'ID del profilo di inferenza si basa sulla AWS regione.
****
| Operazione API | Tipi di modelli supportati | Modalità di input | Modalità di output |
| --- | --- | --- | --- |
| InvokeModel | [Stati Uniti orientali (Virginia settentrionale): [modelli di base](models-supported.md) e profili di inferenza](inference-profiles-support.md) Europa (Irlanda) [— Profili di inferenza](inference-profiles-support.md) [Asia Pacifico (Seoul) - Modelli base](models-supported.md) | Testo Immagine **Nota:** sono supportati anche testo e immagini interlacciati. | Embedding |
| StartAsyncInvoke | [Modelli base](models-supported.md) | Video Audio Immagine Testo **Nota:** sono supportati anche testo e immagini interlacciati. | Embedding |
**Nota**
Utilizzare `InvokeModel` per generare embedding per la query di ricerca. Utilizzare `StartAsyncInvoke` per generare embedding per risorse su larga scala.
All’input si applicano i seguenti limiti:
****
| Modalità di input | Massimo |
| --- | --- |
| Testo | 500 gettoni |
| Immagine | 5 MB per immagine |
| Video (S3) | 6 GB, durata 4 ore |
| Audio (S3) | 6 GB, durata 4 ore |
**Nota**
Se si definiscono audio o video inline utilizzando la codifica base64, assicurarsi che il payload del corpo della richiesta non superi la quota di invocazione del modello Amazon Bedrock di 25 MB.
**Topics**
+ [Parametri delle richieste di TwelveLabs Marengo Embed 3.0](#model-parameters-marengo-3-async-request)
+ [Risposta di TwelveLabs Marengo Embed 3.0](#model-parameters-marengo-3-response)
+ [Esempi di codice di TwelveLabs Marengo Embed 3.0](#model-parameters-marengo-3-examples)
## Parametri delle richieste di TwelveLabs Marengo Embed 3.0
Quando si effettua una richiesta, il campo in cui viene specificato l’input specifico del modello dipende dall’operazione dell’API:
+ [InvokeModel](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModel.html)— Nella richiesta`body`.
+ [StartAsyncInvoke](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_StartAsyncInvoke.html)— Nel `modelInput` campo del corpo della richiesta.
Il formato dell’input del modello dipende dalla modalità di input:
------
#### [ 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"
}
```
------
Espandi le seguenti sezioni per ulteriori informazioni sui parametri di input:
### inputType
Modalità per l’embedding.
+ **Tipo:** stringa
+ **Obbligatorio:** sì
+ **Valori validi**: `text` \$1 `image` \$1 `text_image` \$1 `audio` \$1 `video`
### inputText
Testo da incorporare.
+ ▬**Tipo:** stringa
+ **Obbligatorio:** sì (per i tipi di input compatibili)
+ **Tipi di input compatibili:** testo
### mediaSource
Contiene informazioni sull’origine multimediale.
+ **Tipo:** oggetto
+ **Obbligatorio:** sì (se il tipo è compatibile)
+ **Tipi di input compatibili:** immagine, video, audio
Il formato dell’oggetto `mediaSource` nel corpo della richiesta dipende se il file multimediale è definito come stringa codificata in Base64 o come posizione S3.
+ **Stringa con codifica Base64**
```
{
"mediaSource": {
"base64String": "base64-encoded string"
}
}
```
+ `base64String`: stringa con codifica Base64 per il file multimediale.
+ **Posizione S3**: specifica l'URI S3 e il proprietario del bucket.
```
{
"s3Location": {
"uri": "string",
"bucketOwner": "string"
}
}
```
+ `uri`: URI S3 contenente il file multimediale.
+ `bucketOwner`— L'ID dell'AWSaccount del proprietario del bucket S3.
### embeddingOption
Specifica i tipi di embedding da recuperare.
+ Tipo: elenco
+ **Obbligatorio:** no
+ **Valori validi per i membri dell’elenco:**
+ `visual`— Incorporamenti visivi tratti dal video.
+ `audio`: embedding dell’audio nel video.
+ `transcription`— Incorporamenti del testo trascritto.
+ **Valore predefinito:**
+ Video: ["visivo», «audio», «trascrizione"]
+ Audio: ["audio», «trascrizione"]
+ **Tipi di input compatibili:** video, audio
### Ambito di incorporamento
Specifica l'ambito degli incorporamenti da recuperare.
+ Tipo: elenco
+ **Obbligatorio:** no
+ **Valori validi per i membri dell’elenco:**
+ `clip`— Restituisce gli incorporamenti per ogni clip.
+ `asset`— Restituisce gli incorporamenti per l'intera risorsa.
+ **Tipi di input compatibili:** video, audio
### startSec
Punto temporale in secondi del clip in cui deve iniziare l’elaborazione.
+ **Tipo:** numero a doppia precisione
+ **Obbligatorio:** no
+ **Valore minimo:** 0
+ **Valore predefinito: 0**
+ **Tipi di input compatibili:** video, audio
### endSec
Il punto temporale in secondi in cui deve terminare l'elaborazione.
+ **Tipo:** numero a doppia precisione
+ **Obbligatorio:** no
+ **Valore minimo:** StartSec \$1 lunghezza del segmento
+ **Valore massimo:** durata del file multimediale
+ **Valore predefinito:** durata del file multimediale
+ **Tipi di input compatibili:** video, audio
### segmentazione
Definisce il modo in cui i file multimediali vengono suddivisi in segmenti per la generazione di incorporamenti.
+ **Tipo:** oggetto
+ **Obbligatorio:** no
+ **Tipi di input compatibili:** video, audio
L'oggetto di segmentazione contiene un `method` campo e parametri specifici del metodo:
+ `method`— Il metodo di segmentazione da utilizzare. Valori validi: `dynamic` \$1 `fixed`
+ `dynamic`— Per i video, utilizza il rilevamento dei limiti delle riprese per dividere i contenuti in modo dinamico. Contiene:
+ `minDurationSec`— Durata minima per ogni segmento in secondi. Tipo: Integer. Intervallo: 1-5. Valore predefinito: 4.
+ `fixed`— Divide il contenuto in segmenti di uguale durata. Contiene:
+ `durationSec`— Durata di ogni segmento in secondi. Tipo: Integer. Intervallo: 1-10. Valore predefinito: 6.
**Comportamento predefinito:**
+ Video: utilizza la segmentazione dinamica con il rilevamento dei limiti delle riprese.
+ Audio: utilizza la segmentazione fissa. Il contenuto viene suddiviso nel modo più uniforme possibile con segmenti di durata prossima ai 10 secondi.
### ID di inferenza
Identificatore univoco per la richiesta di inferenza.
+ ▬**Tipo:** stringa
+ **Obbligatorio:** no
## Risposta di TwelveLabs Marengo Embed 3.0
La posizione degli embedding di output e dei metadati associati dipende dal metodo di invocazione:
+ InvokeModel — Nel corpo della risposta.
+ StartAsyncInvoke — Nel bucket S3 definito in`s3OutputDataConfig`, dopo il completamento del processo di invocazione asincrona.
Se sono presenti più vettori di embedding, l’output è un elenco di oggetti, ciascuno contenente un vettore e i relativi metadati associati.
Il formato del vettore degli embedding di output è il seguente:
```
{
"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
}
}
```
Gli incorporamenti vengono restituiti come una matrice di float.
La posizione in cui vedi questa risposta dipende dal metodo API che hai utilizzato:
+ InvokeModel — Viene visualizzato nel corpo della risposta.
+ StartAsyncInvoke — Viene visualizzato nella posizione S3 specificata nella richiesta. La risposta restituisce un`invocationArn`. Puoi usarlo per ottenere metadati sulla chiamata asincrona. Ciò include lo stato e la posizione S3 in cui vengono scritti i risultati.
Espandere le seguenti sezioni per ulteriori informazioni sui parametri della risposta:
### embedding
Rappresentazione dei vettori di embedding dell’input.
+ **Tipo**: elenco di numeri a doppia precisione
### embeddingOption
Tipo di embedding.
+ ▬**Tipo:** stringa
+ **Valori possibili:**
+ visivo: incorporamenti visivi del video.
+ audio: incorporamenti dell'audio nel video.
+ trascrizione — Incorporamenti del testo trascritto.
+ **Tipi di input compatibili:** video, audio
### Ambito di incorporamento
Specifica l'ambito degli incorporamenti da recuperare.
+ ▬**Tipo:** stringa
È possibile includere uno o più dei seguenti valori:
+ clip: restituisce gli incorporamenti per ogni clip.
+ asset: restituisce gli incorporamenti per l'intera risorsa.
### startSec
Offset iniziale del clip.
+ **Tipo:** numero a doppia precisione
+ **Tipi di input compatibili:** video, audio
### endSec
L'offset finale della clip. Non applicabile per gli incorporamenti di testo, immagini e text\$1image.
+ **Tipo:** numero a doppia precisione
+ **Tipi di input compatibili:** video, audio
## Esempi di codice di TwelveLabs Marengo Embed 3.0
Questa sezione mostra come utilizzare il modello TwelveLabs Marengo Embed 3.0 con diversi tipi di input utilizzando Python. Gli esempi mostrano come definire l'input specifico del modello ed eseguire le chiamate del modello.
**Nota**
InvokeModel supporta testo, immagini e testo con input interlacciato da immagini. Per l'input video e audio, usa. StartAsyncInvoke
Assemblare il codice seguendo questa procedura:
**1. Definisci l’input specifico del modello**
Definire l’input specifico del modello in base al tipo di input:
------
#### [ 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. Eseguire l’invocazione del modello utilizzando l’input del modello**
Poi aggiungere il frammento di codice che corrisponde al metodo di invocazione del modello scelto.
------
#### [ 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}")
```
------
# Modelli Writer AI Palmyra
In questa sezione vengono descritti i parametri di richiesta e i campi di risposta per i modelli Writer AI. Utilizza queste informazioni per effettuare chiamate di inferenza ai modelli Writer AI con le operazioni [InvokeModel](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModel.html) o [InvokeModelWithResponseStream](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModelWithResponseStream.html) (streaming). Questa sezione include anche esempi di codice Python che mostrano come chiamare i modelli Writer AI. Per utilizzare un modello in un’operazione di inferenza, è necessario l’ID modello per il modello. Per ottenere l’ID modello, consulta [Modelli di fondazione supportati in Amazon Bedrock](models-supported.md). Alcuni modelli funzionano anche con l’[API Converse](conversation-inference.md). Per verificare se l’API Converse supporta un modello Writer AI specifico, consulta [Modelli e funzionalità del modello supportati](conversation-inference-supported-models-features.md). Per ulteriori esempi di codice, consulta [Esempi di codice per l'utilizzo di Amazon Bedrock AWS SDKs](service_code_examples.md).
I modelli di fondazione in Amazon Bedrock supportano modalità di input e output, che variano da modello a modello. Per verificare le modalità supportate dai modelli Writer AI, consulta [Modelli di fondazione supportati in Amazon Bedrock](models-supported.md). Per verificare quali funzionalità di Amazon Bedrock sono supportate dai modelli Writer AI, consulta [Modelli di fondazione supportati in Amazon Bedrock](models-supported.md). Per verificare in quali Regioni AWS i modelli Writer AI sono disponibili, consulta [Modelli di fondazione supportati in Amazon Bedrock](models-supported.md).
Quando effettui chiamate di inferenza con modelli Writer AI, includi un prompt per il modello. Per informazioni generali sulla creazione di prompt per i modelli supportati da Amazon Bedrock, consulta [Concetti di progettazione dei prompt](prompt-engineering-guidelines.md). Per informazioni sui prompt specifiche di Writer AI, consulta la [Guida alla progettazione dei prompt Writer AI]().
**Writer Palmyra X4**
Al primo posto nella classifica HELM di Stanford, Writer Palmyra X4 raggiunge prestazioni superiori in compiti complessi e flussi di lavoro agentici. Combina una finestra di contesto token da 128k con una suite di funzionalità di livello aziendale, tra cui ragionamento avanzato, chiamata di strumenti, delega LLM, RAG integrato, generazione di codice, output strutturati, multimodalità e supporto multilingue. Utilizzando strumenti specifici per le aziende che ampliano la capacità del modello di agire, Palmyra X4 consente agli sviluppatori di creare app e agenti in grado di aggiornare il sistema, eseguire transazioni, inviare e-mail, attivare flussi di lavoro e molto altro ancora.
**Writer Palmyra X5**
Con una finestra contestuale di un milione di token, Writer Palmyra X5 segna la fine dei vincoli contestuali per lo sviluppo di app e agenti. Il nuovo modello di Writer raggiunge prestazioni superiori nell’inferenza contestuale a lungo termine grazie alla memoria ampliata e alla maggiore potenza di elaborazione, consentendo agli sviluppatori di creare più rapidamente flussi di lavoro agentici più complessi e articolati in più fasi. Come Palmyra X4, Palmyra X5 include una suite di funzionalità pronte per l’uso aziendale, tra cui ragionamento avanzato, chiamata di strumenti, delega LLM, RAG integrato, generazione di codice, output strutturati, multimodalità e supporto multilingue.
**Topics**
+ [Writer Palmyra X4](model-parameters-palmyra-x4.md)
+ [Writer Palmyra X5](model-parameters-palmyra-x5.md)
# Writer Palmyra X4
Writer Palmyra X4 è un modello con una finestra contestuale di un massimo di 128.000 token. Questo modello eccelle nell’elaborazione e nella comprensione di attività complesse, caratteristiche che lo rendono ideale per l’automazione del flusso di lavoro, le attività di codifica e l’analisi dei dati.
+ Provider: Writer
+ Categorie: generazione di testo, generazione di codice, formattazione RTF
+ Ultima versione: v1
+ Data di rilascio: 28 aprile 2025
+ ID modello: `writer.palmyra-x4-v1:0`
+ Modalità: testo
+ Numero massimo di token – input: 122.880 token, output: 8.192 token
+ Lingua: inglese, spagnolo, francese, tedesco, cinese e molte altre lingue
+ Tipo di implementazione: serverless
## Campo del corpo della richiesta per l’invocazione di Palmyra X4
Quando esegui una chiamata [InvokeModel](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModel.html) o [InvokeModelWithResponseStream](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModelWithResponseStream.html) utilizzando un modello Writer, inserisci nel campo `body` un oggetto JSON conforme a quello seguente. Immetti il prompt nel campo `text` dell’oggetto `text_prompts`.
```
{
"modelId": "writer.palmyra-x4-v1:0",
"contentType": "application/json",
"accept": "application/json",
"body": "{\"messages\":[{\"role\":\"user\",\"content\":{\"text\":\"Explain quantum computing in simple terms\"}}]}"
}
```
La tabella che segue mostra i valori minimo, massimo e predefinito per i parametri numerici.
****
| Parametro | Tipo | Valore predefinito | Intervallo/convalida | Descrizione |
| --- | --- | --- | --- | --- |
| messages | array | Obbligatorio | 1-∞ elementi | Messaggi di cronologia chat |
| temperature | float | 1,0 | 0,0 ≤ x ≤ 2,0 | Temperatura campionamento |
| top\$1p | float | 1,0 | 0,0 < valore ≤ 1,0 | Soglia campionamento nucleus |
| max\$1tokens | int | 16 | 1 ≤ x ≤ 8.192 | Numero massimo di token da generare |
| min\$1tokens | int | 0 | 0 ≤ x ≤ max\$1tokens | Numero minimo di token prima dell’arresto |
| stop | array | [] | ≤4 inserimenti | Sequenze di arresto |
| seed | int | nullo | Qualsiasi numero intero | Seed casuale |
| presence\$1penalty | float | 0,0 | -2,0 ≤ x ≤ 2,0 | Nuova penalità per presenza di token |
| frequency\$1penalty | float | 0,0 | -2,0 ≤ x ≤ 2,0 | Penalità per frequenza di token |
## Campo del corpo della risposta per l’invocazione di Palmyra X4
La risposta JSON per Writer Palmyra X4 utilizza il seguente formato:
```
{
"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
}
```
## Codice di esempio per Writer Palmyra X4
Esempio di codice per 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 include una suite di funzionalità pronte per l’uso aziendale, tra cui ragionamento avanzato, chiamata di strumenti, delega LLM, RAG integrato, generazione di codice, output strutturati, multimodalità e supporto multilingue.
Il modello Writer Palmyra X5 ha i seguenti controlli:
+ Provider: Writer
+ Categorie: generazione di testo, generazione di codice, formattazione RTF
+ Ultima versione: v1
+ Data di rilascio: 28 aprile 2025
+ ID modello: `writer.palmyra-x5-v1:0`
+ Modalità: testo
+ Numero massimo di token – input: 1.040.000 token, output: 8.192 token
+ Lingua: inglese, spagnolo, francese, tedesco, cinese e molte altre lingue
+ Tipo di implementazione: serverless
## Campo del corpo della richiesta per l’invocazione di Palmyra X5
Quando esegui una chiamata [InvokeModel](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModel.html) o [InvokeModelWithResponseStream](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModelWithResponseStream.html) utilizzando un modello Writer, inserisci nel campo `body` un oggetto JSON conforme a quello seguente. Immetti il prompt nel campo `text` dell’oggetto `text_prompts`.
```
{
"modelId": "writer.palmyra-x5-v1:0",
"contentType": "application/json",
"accept": "application/json",
"body": "{\"messages\":[{\"role\":\"user\",\"content\":{\"text\":\"Explain quantum computing in simple terms\"}}]}"
}
```
La tabella che segue mostra i valori minimo, massimo e predefinito per i parametri numerici.
****
| Parametro | Tipo | Valore predefinito | Intervallo/convalida | Descrizione |
| --- | --- | --- | --- | --- |
| messages | array | Obbligatorio | 1-∞ elementi | Messaggi di cronologia chat |
| temperature | float | 1,0 | 0,0 ≤ x ≤ 2,0 | Temperatura campionamento |
| top\$1p | float | 1,0 | 0,0 < x ≤ 1,0 | Soglia campionamento nucleus |
| max\$1tokens | int | 16 | 1 ≤ x ≤ 8.192 | Numero massimo di token da generare |
| min\$1tokens | int | 0 | 0 ≤ x ≤ max\$1tokens | Numero minimo di token prima dell’arresto |
| stop | array | [] | ≤4 inserimenti | Sequenze di arresto |
| seed | int | nullo | Qualsiasi numero intero | Seed casuale |
| presence\$1penalty | float | 0,0 | -2,0 ≤ x ≤ 2,0 | Nuova penalità per presenza di token |
| frequency\$1penalty | float | 0,0 | -2,0 ≤ x ≤ 2,0 | Penalità per frequenza di token |
## Campo del corpo della risposta per l’invocazione di Palmyra X5
La risposta JSON per Writer Palmyra X5 utilizza il seguente formato:
```
{
"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
}
```