Vai al contenuto principale
Italiano— Scegli una lingua
Menu

Modelli disponibili

Lezione 12 di 14 Aggiornata il 29 luglio 2026 Sviluppatore
In questa pagina
  1. Scopri i modelli disponibili
  2. Elencare i modelli
  3. Utilizzo nella gestione delle chiavi
  4. Elencare gli endpoint ACL
  5. Scegliere il modello giusto
  6. Script di confronto modelli
  7. Monitorare i nuovi modelli
  8. Combinare modelli e analytics
  9. Punti chiave

Scopri i modelli disponibili

Questo endpoint risponde a una domanda che potresti erroneamente pensare di conoscere a memoria: quali modelli il tuo team può effettivamente chiamare e a quale prezzo oggi. La documentazione pubblica descrive il catalogo generale; l’API descrive il tuo catalogo, inclusi i prezzi correnti.

Il divario tra i due non è teorico. I livelli evolvono, i prezzi cambiano e un ID copiato da un post sul blog di sei mesi fa genera un errore di accesso difficile da diagnosticare. Prendi l’abitudine di interrogare questo endpoint invece di fare supposizioni: è anche ciò che mantiene affidabili nel tempo i tuoi script di confronto dei costi. Queste informazioni sono essenziali per scegliere il modello giusto per il tuo caso d’uso e il tuo budget.

Elencare i modelli

curl "https://management-api.x.ai/auth/teams/$TEAM_ID/models" \
  -H "Authorization: Bearer $MANAGEMENT_API_KEY"

La risposta contiene per ogni modello:

  • ID: il nome esatto da utilizzare nelle chiamate API (es: grok-4.20-0309-reasoning)
  • Cluster: il gruppo di server che ospita il modello
  • Pricing: prezzo per milione di token per input e output
  • Capabilities: dimensione del contesto, supporto multimodale, ecc.

Utilizzo nella gestione delle chiavi

È qui che l’endpoint diventa indispensabile piuttosto che semplicemente pratico. Un ACL che nomina un modello inesistente — perché il formato dell’ID è cambiato o il modello è stato ritirato — non genera un errore evidente: semplicemente non autorizza nulla, e ti ritrovi a cercare l’errore nel tuo codice. Verifica l’ID alla fonte prima di bloccarlo in una chiave.

{
  "acls": [
    "api-key:model:grok-4.20-0309-reasoning",
    "api-key:model:grok-4.3"
  ]
}

Se limiti una chiave a modelli specifici, verifica prima che siano disponibili per il tuo team tramite questo endpoint.

Elencare gli endpoint ACL

La stessa logica si applica agli endpoint: l’elenco seguente è quello autorevole per comporre i tuoi ACL. Fornisce anche una visione utile dello scope effettivo di una chiave: una chiave limitata a chat non può né generare embedding né elaborare immagini, indipendentemente dai modelli a cui altrimenti fa riferimento.

curl "https://management-api.x.ai/auth/teams/$TEAM_ID/endpoints" \
  -H "Authorization: Bearer $MANAGEMENT_API_KEY"

Gli endpoint disponibili sono:

  • chat: conversazioni testuali (completamenti chat)
  • embed: generazione di embedding
  • image: generazione e analisi di immagini
  • models: elenco dei modelli
  • sample: campionamento
  • tokenize: tokenizzazione del testo
  • documents: elaborazione documenti

Scegliere il modello giusto

Per caso d’uso

Caso d’usoModello consigliatoPerché
Ragionamento complessogrok-4.20-0309-reasoningCatena di pensiero avanzata
Compiti semplici, alto volumegrok-4.3Veloce, economico
Analisi immaginiModello multimodaleSupporto visione
Embedding / RAGModello di embeddingOttimizzato per la ricerca

Per budget

Confronta le tariffe restituite dall’API piuttosto che quelle che hai in mente. La logica di arbitraggio è sempre la stessa: un’attività di classificazione o estrazione non trae alcun beneficio da un modello di ragionamento, eppure ne paghi il prezzo a ogni chiamata — ed è proprio questo il tipo di attività che esegui migliaia di volte. Il modello di ragionamento è necessario per analisi complesse.

Script di confronto modelli

import requests
import json

MANAGEMENT_API = "https://management-api.x.ai"
MGMT_KEY = "xai-mgmt-..."
TEAM_ID = "team-..."

# Recupera i modelli
response = requests.get(
    f"{MANAGEMENT_API}/auth/teams/{TEAM_ID}/models",
    headers={"Authorization": f"Bearer {MGMT_KEY}"}
)

models = response.json().get("models", [])

print(f"{'Model':<35} {'Input ($/M)':<15} {'Output ($/M)':<15}")
print("-" * 65)

for model in models:
    name = model.get("id", "N/A")
    input_price = model.get("inputPrice", "N/A")
    output_price = model.get("outputPrice", "N/A")
    print(f"{name:<35} {input_price:<15} {output_price:<15}")

Monitorare i nuovi modelli

Il catalogo cambia più volte all’anno e le modifiche più interessanti non sono i nuovi modelli, ma i cali di prezzo su quelli vecchi. Un controllo periodico che confronta con il record precedente segnala entrambi, e costa poche righe di cron.

import requests
import json
import os

MANAGEMENT_API = "https://management-api.x.ai"
MGMT_KEY = "xai-mgmt-..."
TEAM_ID = "team-..."
CACHE_FILE = "/tmp/xai_models_cache.json"

# Recupera i modelli correnti
response = requests.get(
    f"{MANAGEMENT_API}/auth/teams/{TEAM_ID}/models",
    headers={"Authorization": f"Bearer {MGMT_KEY}"}
)
current_models = {m["id"] for m in response.json().get("models", [])}

# Confronta con la cache
if os.path.exists(CACHE_FILE):
    with open(CACHE_FILE) as f:
        cached_models = set(json.load(f))

    new_models = current_models - cached_models
    removed_models = cached_models - current_models

    if new_models:
        print(f"New models: {', '.join(new_models)}")
    if removed_models:
        print(f"Removed models: {', '.join(removed_models)}")

# Aggiorna la cache
with open(CACHE_FILE, "w") as f:
    json.dump(list(current_models), f)

Combinare modelli e analytics

Il riferimento incrociato finale è ciò che guida la decisione: da un lato quanto costa ogni modello, dall’altro quanto lo utilizzi. Un modello costoso e marginale non merita attenzione; un modello costoso che assorbe la maggior parte delle tue richieste è il primo candidato al cambiamento, ed è proprio questo che questo script mette in luce in una riga.

# 1. Elenca i modelli disponibili
curl -s "https://management-api.x.ai/auth/teams/$TEAM_ID/models" \
  -H "Authorization: Bearer $MANAGEMENT_API_KEY" > /tmp/models.json

# 2. Analizza l'utilizzo per modello
curl -s -X POST "https://management-api.x.ai/v1/billing/teams/$TEAM_ID/usage" \
  -H "Authorization: Bearer $MANAGEMENT_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "analyticsRequest": {
      "timeRange": {
        "startTime": "2026-03-01 00:00:00",
        "endTime": "2026-04-01 00:00:00",
        "timezone": "UTC"
      },
      "timeUnit": "MONTH",
      "values": [{"name": "tokens", "aggregation": "SUM"}],
      "groupBy": ["model"]
    }
  }' > /tmp/usage.json

# 3. Confronta
python3 -c "
import json
with open('/tmp/models.json') as f:
    available = {m['id'] for m in json.load(f).get('models', [])}
with open('/tmp/usage.json') as f:
    used = {p.get('model') for p in json.load(f).get('dataPoints', [])}
unused = available - used
if unused:
    print(f'Available models not used: {unused}')
"

Prezzi aggiornati al 5 agosto 2026 — i prezzi evolvono regolarmente: prima di qualsiasi calcolo di budget, verifica la griglia corrente sulla pagina ufficiale dei modelli e dei prezzi xAI.

Punti chiave

  • GET /auth/teams/{teamId}/models elenca i modelli con prezzi e capacità
  • GET /auth/teams/{teamId}/endpoints elenca gli endpoint per gli ACL
  • Usa queste informazioni per creare chiavi API con ACL precisi
  • Confronta le tariffe per scegliere il modello più economico adatto al tuo utilizzo
  • Monitora regolarmente i nuovi modelli disponibili