Claude Messages API richiesta e utilizzo

Anthropic Claude è un sistema di dialogo AI molto potente, in grado di generare risposte fluide e naturali in pochi secondi semplicemente inserendo un prompt. Claude Messages API è il formato API nativo ufficiale di Anthropic, che, a differenza del formato compatibile con OpenAI (Chat Completion), utilizza una struttura di richiesta e risposta proprietaria di Anthropic, in grado di sfruttare meglio le capacità uniche di Claude, come l’input di contenuti multimodali, l’invocazione di strumenti, il pensiero profondo (Extended Thinking) e altre caratteristiche avanzate. Questo documento descrive principalmente il processo di utilizzo dell’API Claude Messages, permettendoci di utilizzare un’interfaccia nativa coerente con quella ufficiale di Anthropic per richiamare le funzionalità di dialogo di Claude.

Processo di richiesta

Per utilizzare Claude Messages API, prima di tutto vai al Ace Data Cloud Console per ottenere il tuo API Token, da conservare per uso futuro.

Se non hai ancora effettuato il login o la registrazione, verrai automaticamente reindirizzato alla pagina di login che ti invita a registrarti e accedere; una volta completato, verrai riportato automaticamente alla pagina corrente. Un API Token è sufficiente per accedere a tutti i servizi della piattaforma, senza necessità di richiederne uno per ogni servizio. La prima richiesta ti darà un credito gratuito, permettendoti di provare senza costi; quando il credito è insufficiente, puoi ricaricare il saldo generale nella console.

📘 Documentazione completa: Claude Messages API →

Utilizzo di base

Il percorso di richiesta per Claude Messages API è /v1/messages, mantenendo la coerenza con l’API ufficiale di Anthropic. Dobbiamo fornire almeno tre parametri obbligatori:

model: seleziona il modello Claude da utilizzare. L’ultimo flagship è claude-fable-5-1 (1 milione di token di contesto, output massimo 128K token); il precedente claude-fable-5 è ancora compatibile e disponibile.
messages: array di messaggi in input, ogni messaggio contiene role (ruolo) e content (contenuto), dove role supporta user e assistant.
max_tokens: numero massimo di token in output, utilizzato per limitare la lunghezza della risposta singola.

Parametri opzionali comuni:

system: prompt di sistema, utilizzato per impostare il comportamento e il ruolo del modello.
temperature: casualità nella generazione, tra 0 e 1, valori più alti producono risposte più disperse.
stream: se utilizzare la risposta in streaming, impostato su true per ottenere un effetto di restituzione parola per parola.
stop_sequences: sequenze di arresto personalizzate, il modello smetterà di generare quando incontra questi testi.
top_p: parametro di campionamento nucleare, in combinazione con la temperatura per controllare la casualità della generazione.
top_k: campiona solo tra le K opzioni con la probabilità più alta.
tools: definizione degli strumenti, per consentire al modello di invocare funzioni esterne.
tool_choice: controlla come il modello utilizza gli strumenti forniti.
cache_control: crea automaticamente un punto di interruzione della cache all’ultimo blocco di contenuto cacheabile nella richiesta; può anche essere scritto su un blocco di contenuto specifico.

Esempio cURL

curl -X POST 'https://api.acedata.cloud/v1/messages' \
  -H 'accept: application/json' \
  -H 'authorization: Bearer {token}' \
  -H 'content-type: application/json' \
  -d '{
    "model": "claude-fable-5-1",
    "max_tokens": 1024,
    "messages": [
      {
        "role": "user",
        "content": "Hello, Claude"
      }
    ]
  }'

Esempio Python

import requests

url = "https://api.acedata.cloud/v1/messages"

headers = {
    "accept": "application/json",
    "authorization": "Bearer {token}",
    "content-type": "application/json"
}

payload = {
    "model": "claude-fable-5-1",
    "max_tokens": 1024,
    "messages": [
        {"role": "user", "content": "Hello, Claude"}
    ]
}

response = requests.post(url, json=payload, headers=headers)
print(response.json())

Dopo la chiamata, il risultato restituito è il seguente:

{
  "id": "msg_013Zva2CMHLNnXjNJJKqJ2EF",
  "type": "message",
  "role": "assistant",
  "content": [
    {
      "type": "text",
      "text": "Hi! My name is Claude. How can I help you today?"
    }
  ],
  "model": "claude-opus-4-8",
  "stop_reason": "end_turn",
  "stop_sequence": null,
  "usage": {
    "input_tokens": 12,
    "output_tokens": 15
  }
}

Descrizione dei campi del risultato restituito:

id: identificatore unico per questo messaggio.
type: sempre message.
role: sempre assistant.
content: array di contenuti di risposta, ogni elemento contiene type (come text) e il contenuto corrispondente.
model: nome del modello che ha elaborato la richiesta.
stop_reason: motivo di arresto. I valori stabili includono end_turn, max_tokens, stop_sequence, tool_use, pause_turn (può restituire il contenuto attuale dell’assistente per continuare), refusal e model_context_window_exceeded.
stop_sequence: se l’arresto è avvenuto a causa di una sequenza di arresto personalizzata, mostra il testo della sequenza di arresto corrispondente.
stop_details: quando stop_reason è refusal, può contenere categorie e spiegazioni di rifiuto.
usage: statistiche sull’uso dei token. input_tokens è l’input non cacheabile; cache_creation_input_tokens e cache_read_input_tokens sono rispettivamente la scrittura e la lettura della cache; output_tokens è il numero di token in output. Il prezzo ufficiale di lettura della cache per Fable 5.1 è di $0.25/milione di token, i prezzi di scrittura della cache per 5 minuti e 1 ora sono rispettivamente di$ 12.50 e $20/milione di token; i prezzi effettivi della piattaforma sono calcolati in base agli sconti del pacchetto. Le risposte non in streaming possono anche includere il cost registrato da Ace Data Cloud.

Prompt di sistema

Claude Messages API supporta la definizione di prompt di sistema tramite il campo system, utilizzato per definire il comportamento, il ruolo e il contesto del modello.

Esempio Python

import requests

url = "https://api.acedata.cloud/v1/messages"

headers = {
    "accept": "application/json",
    "authorization": "Bearer {token}",
    "content-type": "application/json"
}

payload = {
    "model": "claude-sonnet-4-20250514",
    "max_tokens": 1024,
    "system": "Sei un assistente di traduzione professionale in cinese, per favore traduci l'inglese fornito dall'utente in cinese.",
    "messages": [
        {"role": "user", "content": "The quick brown fox jumps over the lazy dog."}
    ]
}

response = requests.post(url, json=payload, headers=headers)
print(response.json())

Impostando il prompt system, è possibile controllare con precisione il ruolo e il comportamento di Claude.

Risposta in streaming

Questa interfaccia supporta anche la risposta in streaming, impostando il parametro stream su true per ottenere un effetto di restituzione graduale, molto adatto per implementare la visualizzazione parola per parola in una pagina web.

Esempio Python

import requests

url = "https://api.acedata.cloud/v1/messages"

headers = {
    "accept": "application/json",
    "authorization": "Bearer {token}",
    "content-type": "application/json"
}

payload = {
    "model": "claude-sonnet-4-20250514",
    "max_tokens": 1024,
    "stream": True,
    "messages": [
        {"role": "user", "content": "Ciao, Claude"}
    ]
}

response = requests.post(url, json=payload, headers=headers, stream=True)
for line in response.iter_lines():
    if line:
        print(line.decode("utf-8"))

La risposta in streaming viene restituita nel formato Server-Sent Events (SSE), con ogni riga preceduta da event: e data:. I tipi di eventi in streaming includono:

message_start: inizio del messaggio, contiene le informazioni di base del messaggio e il nome del modello.
content_block_start: inizio del blocco di contenuto.
content_block_delta: aggiornamento incrementale del blocco di contenuto, contiene nuovi frammenti di testo generati.
content_block_stop: fine del blocco di contenuto.
message_delta: aggiornamento incrementale a livello di messaggio, contiene informazioni su stop_reason e usage finale.
message_stop: fine del messaggio.

L’output appare come segue:

event: message_start
data: {"type":"message_start","message":{"id":"msg_01XFDUDYJgAACzvnptvVoYEL","type":"message","role":"assistant","content":[],"model":"claude-sonnet-4-20250514","stop_reason":null,"stop_sequence":null,"usage":{"input_tokens":12,"output_tokens":0}}}

event: content_block_start
data: {"type":"content_block_start","index":0,"content_block":{"type":"text","text":""}}

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"Ciao"}}

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"! Mi chiamo"}}

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":" Claude. Come posso aiutarti oggi?"}}

event: content_block_stop
data: {"type":"content_block_stop","index":0}

event: message_delta
data: {"type":"message_delta","delta":{"stop_reason":"end_turn","stop_sequence":null},"usage":{"output_tokens":15}}

event: message_stop
data: {"type":"message_stop"}

Come si può vedere, l’evento content_block_delta nella risposta in streaming contiene il contenuto del testo generato passo dopo passo, concatenando tutti i text_delta si può ottenere la risposta completa.

Esempio JavaScript

const options = {
  method: "POST",
  headers: {
    accept: "application/json",
    authorization: "Bearer {token}",
    "content-type": "application/json",
  },
  body: JSON.stringify({
    model: "claude-sonnet-4-20250514",
    max_tokens: 1024,
    stream: true,
    messages: [{ role: "user", content: "Ciao, Claude" }],
  }),
};

const response = await fetch("https://api.acedata.cloud/v1/messages", options);
const reader = response.body.getReader();
const decoder = new TextDecoder();

while (true) {
  const { done, value } = await reader.read();
  if (done) break;
  console.log(decoder.decode(value));
}

Conversazione multipla

Se desideri integrare la funzionalità di conversazione multipla, devi alternare i messaggi dei ruoli user e assistant nell’array messages, includendo la cronologia della conversazione precedente.

Esempio Python

import requests

url = "https://api.acedata.cloud/v1/messages"

headers = {
    "accept": "application/json",
    "authorization": "Bearer {token}",
    "content-type": "application/json"
}

payload = {
    "model": "claude-sonnet-4-20250514",
    "max_tokens": 1024,
    "messages": [
        {"role": "user", "content": "Ciao, mi chiamo Alice."},
        {"role": "assistant", "content": "Ciao Alice! Piacere di conoscerti. Come posso aiutarti oggi?"},
        {"role": "user", "content": "Qual è il mio nome?"}
    ]
}

response = requests.post(url, json=payload, headers=headers)
print(response.json())

Il risultato restituito è il seguente:

{
  "id": "msg_01Y1wfQmd89g968TVbFu57Yc",
  "type": "message",
  "role": "assistant",
  "content": [
    {
      "type": "text",
      "text": "Il tuo nome è Alice, come mi hai appena detto!"
    }
  ],
  "model": "claude-sonnet-4-20250514",
  "stop_reason": "end_turn",
  "stop_sequence": null,
  "usage": {
    "input_tokens": 40,
    "output_tokens": 14
  }
}

Passando la cronologia completa della conversazione in messages, Claude può fornire risposte accurate in base al contesto.

Modello di pensiero profondo

Il pensiero di Claude e il riassunto del pensiero sono due concetti diversi: il modello può effettuare ragionamenti interni, ma l’API non restituirà la catena di pensiero originale. Quando è necessario mostrare il processo di ragionamento, l’API restituisce un riassunto elaborato. Il modello attuale consiglia di utilizzare il pensiero adattivo e di controllare l’impegno complessivo di ragionamento tramite output_config.effort:

import requests

url = "https://api.acedata.cloud/v1/messages"
headers = {
    "accept": "application/json",
    "authorization": "Bearer {token}",
    "content-type": "application/json"
}
payload = {
    "model": "claude-opus-5",
    "max_tokens": 16000,
    "thinking": {
        "type": "adaptive",
        "display": "summarized"
    },
    "output_config": {
        "effort": "high"
    },
    "messages": [
        {"role": "user", "content": "Qual è il seno di 30 gradi?"}
    ]
}

response = requests.post(url, json=payload, headers=headers)
print(response.json())

Il blocco di pensiero nella risposta appare come:

{
  "type": "thinking",
  "thinking": "Il problema chiede un valore trigonometrico standard...",
  "signature": "opaque-signature"
}

display: "summarized" restituisce un riassunto di pensiero leggibile; non è la catena di pensiero originale.
display: "omitted" restituisce thinking: "", ma mantiene comunque la signature opaca per supportare le conversazioni successive.
I modelli Fable 5.1, Fable 5, Opus 5, Sonnet 5, Opus 4.8 e Opus 4.7 hanno come valore predefinito omitted per il display; i modelli Opus 4.6, Sonnet 4.6 e precedenti che supportano il pensiero utilizzano per default summarized.
Il display influisce solo sul contenuto restituito e sulla latenza in streaming, non disabilita il ragionamento e non riduce la fatturazione dei token di pensiero.
Se il pensiero è abilitato per default e il valore di display predefinito sono due questioni indipendenti. Opus 5 e Sonnet 5 abilitano per default il pensiero adattivo; Opus 4.8, 4.7 e 4.6 devono essere esplicitamente abilitati.
budget_tokens è utilizzato solo per i vecchi modelli che supportano ancora un budget di pensiero fisso. I nuovi modelli dovrebbero utilizzare thinking.type=adaptive e output_config.effort; il pensiero di Fable 5.1 è sempre attivo e non può essere disabilitato esplicitamente.
Durante le conversazioni multiple e le chiamate agli strumenti, il blocco di pensiero completo restituito dall’assistente e la signature devono essere restituiti così come sono; non modificare o generare autonomamente la signature.
Alcuni router compatibili non possono gestire senza perdita redacted_thinking o disabilitare esplicitamente il pensiero, in tal caso restituiranno un errore di parametro, senza silenziosamente scartare o modificare il significato della richiesta.

Nella richiesta in streaming, summarized genererà thinking_delta; omitted non genererà thinking_delta, mantenendo solo il ciclo di vita del blocco di pensiero e signature_delta.

Modello visivo

Claude supporta input multimodali, in grado di gestire contemporaneamente testo e immagini. Nell'API Messages, è possibile utilizzare le capacità visive impostando `content` come formato array e passando i blocchi di contenuto dell'immagine.

### Utilizzo di immagini codificate in Base64

```python
import base64
import requests

url = "https://api.acedata.cloud/v1/messages"

headers = {
    "accept": "application/json",
    "authorization": "Bearer {token}",
    "content-type": "application/json"
}

# Leggi e codifica l'immagine
with open("image.png", "rb") as f:
    image_data = base64.standard_b64encode(f.read()).decode("utf-8")

payload = {
    "model": "claude-sonnet-4-20250514",
    "max_tokens": 1024,
    "messages": [
        {
            "role": "user",
            "content": [
                {
                    "type": "image",
                    "source": {
                        "type": "base64",
                        "media_type": "image/png",
                        "data": image_data
                    }
                },
                {
                    "type": "text",
                    "text": "Cosa c'è in questa immagine?"
                }
            ]
        }
    ]
}

response = requests.post(url, json=payload, headers=headers)
print(response.json())

Utilizzo di immagini URL

import requests

url = "https://api.acedata.cloud/v1/messages"

headers = {
    "accept": "application/json",
    "authorization": "Bearer {token}",
    "content-type": "application/json"
}

payload = {
    "model": "claude-sonnet-4-20250514",
    "max_tokens": 1024,
    "messages": [
        {
            "role": "user",
            "content": [
                {
                    "type": "image",
                    "source": {
                        "type": "url",
                        "url": "https://cdn.acedata.cloud/ueugot.png"
                    }
                },
                {
                    "type": "text",
                    "text": "Cosa c'è in questa immagine?"
                }
            ]
        }
    ]
}

response = requests.post(url, json=payload, headers=headers)
print(response.json())

Esempio cURL

curl -X POST 'https://api.acedata.cloud/v1/messages' \
  -H 'accept: application/json' \
  -H 'authorization: Bearer {token}' \
  -H 'content-type: application/json' \
  -d '{
    "model": "claude-sonnet-4-20250514",
    "max_tokens": 1024,
    "messages": [
      {
        "role": "user",
        "content": [
          {
            "type": "image",
            "source": {
              "type": "url",
              "url": "https://cdn.acedata.cloud/ueugot.png"
            }
          },
          {
            "type": "text",
            "text": "Cosa c'è in questa immagine?"
          }
        ]
      }
    ]
  }'

I formati di immagine supportati includono: image/jpeg, image/png, image/gif, image/webp.

Documenti e PDF

I PDF utilizzano il blocco di contenuto document, supportando due fonti stabili: Base64 e URL. La fonte Base64 deve utilizzare application/pdf:

import base64

with open("report.pdf", "rb") as f:
    pdf_data = base64.standard_b64encode(f.read()).decode("utf-8")

payload = {
    "model": "claude-fable-5-1",
    "max_tokens": 1024,
    "messages": [{
        "role": "user",
        "content": [
            {
                "type": "document",
                "source": {
                    "type": "base64",
                    "media_type": "application/pdf",
                    "data": pdf_data
                },
                "title": "Rapporto trimestrale"
            },
            {"type": "text", "text": "Riassumi questo PDF."}
        ]
    }]
}

La fonte URL è scritta come {"type":"url","url":"https://example.com/report.pdf"}. Il document supporta anche text/plain e fonti content composte da blocchi di testo/immagine; i campi opzionali includono title, context e citations. La fonte file_id dell’API Files è una funzionalità beta indipendente e non rientra nel contratto stabile di questa interfaccia.

Cache dei suggerimenti

Il cache_control di alto livello posizionerà automaticamente i punti di interruzione della cache all’ultimo blocco memorizzabile:

payload = {
    "model": "claude-fable-5-1",
    "max_tokens": 1024,
    "cache_control": {"type": "ephemeral", "ttl": "5m"},
    "system": "Sei un esperto su questo materiale di riferimento.",
    "messages": [{"role": "user", "content": "Riassumi i punti chiave."}]
}

Quando è necessario controllare con precisione la posizione, è possibile scrivere lo stesso cache_control nei blocchi di contenuto text, image, document, tool_use, tool_result o definizioni di strumenti. ttl supporta 5m (predefinito) e 1h; si prega di controllare usage.cache_creation_input_tokens e usage.cache_read_input_tokens per determinare la scrittura e il colpo della cache. Esempio di risultato restituito:

{
  "id": "msg_01NCrxpZmV17bhQJJRQEFEb9",
  "type": "message",
  "role": "assistant",
  "content": [
    {
      "type": "text",
      "text": "Questa immagine mostra un'interfaccia di configurazione della richiesta API per quello che sembra essere un servizio di completamento chat AI. L'interfaccia include parametri per la selezione del modello, messaggi, modalità stream e impostazioni massime di token."
    }
  ],
  "model": "claude-sonnet-4-20250514",
  "stop_reason": "end_turn",
  "stop_sequence": null,
  "usage": {
    "input_tokens": 1570,
    "output_tokens": 52
  }
}

Chiamata agli strumenti (Tool Use)

L’API Messages di Claude supporta nativamente la funzionalità di chiamata agli strumenti, consentendo al modello di chiamare strumenti/funzioni predefiniti quando necessario.

Esempio Python

import requests

url = "https://api.acedata.cloud/v1/messages"

headers = {
    "accept": "application/json",
    "authorization": "Bearer {token}",
    "content-type": "application/json"
}

payload = {
    "model": "claude-sonnet-4-20250514",
    "max_tokens": 1024,
    "tools": [
        {
            "name": "get_weather",
            "description": "Ottieni il meteo attuale in una determinata posizione",
            "input_schema": {
                "type": "object",
                "properties": {
                    "location": {
                        "type": "string",
                        "description": "La città e lo stato, ad esempio San Francisco, CA"
                    }
                },
                "required": ["location"]
            }
        }
    ],
    "messages": [
        {"role": "user", "content": "Com'è il tempo a San Francisco?"}
    ]
}

response = requests.post(url, json=payload, headers=headers)
print(response.json())

Quando il modello decide di chiamare uno strumento, il risultato restituito conterrà un blocco di contenuto di tipo tool_use:

{
  "id": "msg_01Aq9w938a90dw8q",
  "type": "message",
  "role": "assistant",
  "content": [
    {
      "type": "text",
      "text": "Fammi controllare il meteo a San Francisco per te."
    },
    {
      "type": "tool_use",
      "id": "toolu_01A09q90qw90lq917835lgs",
      "name": "get_weather",
      "input": {
        "location": "San Francisco, CA"
      }
    }
  ],
  "model": "claude-sonnet-4-20250514",
  "stop_reason": "tool_use",
  "stop_sequence": null,
  "usage": {
    "input_tokens": 120,
    "output_tokens": 68
  }
}

Nota che stop_reason è tool_use, il che indica che il modello ha bisogno di chiamare uno strumento. Dopo aver ricevuto questo risultato, è necessario eseguire la funzione dello strumento e restituire il risultato sotto forma di tool_result al modello:

payload = {
    "model": "claude-sonnet-4-20250514",
    "max_tokens": 1024,
    "tools": [
        {
            "name": "get_weather",
            "description": "Ottieni il meteo attuale in una determinata posizione",
            "input_schema": {
                "type": "object",
                "properties": {
                    "location": {
                        "type": "string",
                        "description": "La città e lo stato, ad esempio San Francisco, CA"
                    }
                },
                "required": ["location"]
            }
        }
    ],
    "messages": [
        {"role": "user", "content": "Com'è il meteo a San Francisco?"},
        {
            "role": "assistant",
            "content": [
                {"type": "text", "text": "Fammi controllare il meteo a San Francisco per te."},
                {"type": "tool_use", "id": "toolu_01A09q90qw90lq917835lgs", "name": "get_weather", "input": {"location": "San Francisco, CA"}}
            ]
        },
        {
            "role": "user",
            "content": [
                {
                    "type": "tool_result",
                    "tool_use_id": "toolu_01A09q90qw90lq917835lgs",
                    "content": "Soleggiato, 72°F"
                }
            ]
        }
    ]
}

response = requests.post(url, json=payload, headers=headers)
print(response.json())

Il modello genererà una risposta finale in linguaggio naturale basata sui risultati restituiti dagli strumenti.

Differenze con l’API di Chat Completion

Ace Data Cloud offre due formati di API Claude, le principali differenze sono le seguenti: L’usage.input_tokens dell’API Messages indica solo l’input non memorizzato, cache_read_input_tokens e cache_creation_input_tokens sono fatturati in modo indipendente; i tre verranno calcolati separatamente secondo i rispettivi prezzi.

Caratteristica	API Messages (`/v1/messages`)	API Chat Completion (`/v1/chat/completions`)
Formato	Formato nativo di Anthropic	Formato compatibile con OpenAI
Prompt di sistema	Campo `system` indipendente	Trasmetto tramite `role: "system"` in `messages`
Struttura della risposta	Array `content` (supporta vari tipi)	Array `choices` (contiene `message`)
Formato in streaming	Eventi SSE (vari tipi di eventi)	Riga SSE `data`
Pensiero profondo	Parametro `thinking` nativo	Attivato tramite nomi di modelli speciali (es. suffisso `-thinking`)
Chiamata agli strumenti	`tools` nativi + `input_schema`	Formato `functions` compatibile con OpenAI
Statistiche sui Token	`input_tokens` / `output_tokens`	`prompt_tokens` / `completion_tokens`

Se il tuo sistema è già integrato con l’API in formato OpenAI, puoi utilizzare l’API Chat Completion per un passaggio senza soluzione di continuità. Se hai bisogno di utilizzare tutte le capacità native di Claude, si consiglia di utilizzare l’API Messages.

Gestione degli errori

Le risposte di errore dell’interfaccia pubblica utilizzano l’involucro della piattaforma Ace Data Cloud: error.code è un codice di errore stabile, error.message è una descrizione, trace_id è utilizzato per il debug delle richieste. Gli stati HTTP comuni includono:

400: Parametri della richiesta o contenuto del protocollo non validi.
401: Token di autorizzazione non valido, mancante o scaduto.
403: Accesso vietato, saldo insufficiente o quota limitata.
404: API o modello non esistente.
413: Corpo della richiesta troppo grande.
429: Troppe richieste.
500 / 503 / 504: Errore del servizio, temporaneamente non disponibile o timeout di elaborazione.

Esempio di risposta di errore

{
  "error": {
    "code": "api_error",
    "message": "fetch failed"
  },
  "trace_id": "2cf86e86-22a4-46e1-ac2f-032c0f2a4e89"
}

Questa struttura di errore è il contratto di runtime di Ace Data Cloud, non è equivalente all’involucro di errore ufficiale di Anthropic; si prega di gestire in base allo stato HTTP e a error.code.

Conclusione

Attraverso questo documento, hai appreso come utilizzare l’API Messages di Claude in formato nativo di Anthropic per richiamare le funzionalità di conversazione di Claude. L’API Messages supporta una gamma di funzionalità ricche come conversazioni di base, prompt di sistema, risposte in streaming, conversazioni multi-turno, pensiero profondo, comprensione visiva, PDF, caching dei prompt e chiamate agli strumenti. Se hai domande, non esitare a contattare il nostro team di supporto tecnico.

Inizia

Chat AI

Immagine AI

Video AI

Audio AI

Web e Dati

CAPTCHA

Identità

Proxy

Avanzato

Coding

Claude Messages API richiesta e utilizzo

Processo di richiesta

Utilizzo di base

Esempio cURL

Esempio Python

Prompt di sistema

Esempio Python

Risposta in streaming

Esempio Python

Esempio JavaScript

Conversazione multipla

Esempio Python

Modello di pensiero profondo

Modello visivo

Utilizzo di immagini URL

Esempio cURL

Documenti e PDF

Cache dei suggerimenti

Chiamata agli strumenti (Tool Use)

Esempio Python

Differenze con l’API di Chat Completion

Gestione degli errori

Esempio di risposta di errore

Conclusione

​Processo di richiesta

​Utilizzo di base

​Esempio cURL

​Esempio Python

​Prompt di sistema

​Esempio Python

​Risposta in streaming

​Esempio Python

​Esempio JavaScript

​Conversazione multipla

​Esempio Python

​Modello di pensiero profondo

​Modello visivo

​Utilizzo di immagini URL

​Esempio cURL

​Documenti e PDF

​Cache dei suggerimenti

​Chiamata agli strumenti (Tool Use)

​Esempio Python

​Differenze con l’API di Chat Completion

​Gestione degli errori

​Esempio di risposta di errore

​Conclusione

Processo di richiesta

Utilizzo di base

Esempio cURL

Esempio Python

Prompt di sistema

Esempio Python

Risposta in streaming

Esempio Python

Esempio JavaScript

Conversazione multipla

Esempio Python

Modello di pensiero profondo

Modello visivo

Utilizzo di immagini URL

Esempio cURL

Documenti e PDF

Cache dei suggerimenti

Chiamata agli strumenti (Tool Use)

Esempio Python

Differenze con l’API di Chat Completion

Gestione degli errori

Esempio di risposta di errore

Conclusione