API Grok 3: guida passo passo con esempi

Che cos'è Grok 3?

Grok 3 è l'ultimo large language model di xAI, creato appositamente per il ragionamento passo dopo passo, la coerenza logica e gli output strutturati. A differenza dei classici modelli di chat che danno priorità al flusso della conversazione, Grok 3 "pensa" prima di rispondere, il che lo rende ideale per compiti che richiedono logica profonda, come decisioni complesse, ragionamento matematico e analisi quantitativa.

Grok 3 è disponibile in due varianti: il modello standard e un mini model. Mentre il mini model è completamente focalizzato sull'aspetto del ragionamento e consente di accedere alle sue tracce di ragionamento, il modello standard viene presentato come dotato di una notevole conoscenza di dominio in campi come finanza, sanità, diritto e scienza.

Entrambe le versioni supportano funzionalità avanzate come il function calling nativo e la generazione di risposte strutturate, aiutando gli sviluppatori a creare workflow di AI affidabili e prevedibili con facilità.

Se vuoi saperne di più sull'architettura e le prestazioni di Grok 3, dai un'occhiata a questa panoramica su Grok 3.

Preparazione: ottenere l'accesso all'API di Grok 3

In questa sezione spiegherò come creare una chiave API, configurare un ambiente Python per connetterti all'API di Grok e inviare la tua prima richiesta utente.

Creare una chiave API

Per autenticare il client Python con l'API, dobbiamo creare una chiave API. Il processo è il seguente:

1. Vai alla pagina della documentazione di xAI.
2. Accedi con il tuo account X, xAI o Google, oppure crea un account xAI.
3. Clicca su “Create an API key”, assegnale un nome e clicca su “save”.
4. Quando la chiave è visibile, copiala. Non potrai più vederla in seguito, ma potrai sempre crearne una nuova se la perdi.
5. Crea un file chiamato .env nella directory del progetto e incolla la chiave nel seguente formato:

XAI_API_KEY=<your_api_key>Offerto da

Prezzi dell'API Grok 3

Anche se usare l'API è spesso associato a costi inferiori rispetto a un abbonamento premium, non è gratuita. Invece di un canone fisso mensile, che parte da 30 $ per l'abbonamento SuperGrok, il costo dipende interamente dall'uso. Per avere una panoramica dei costi potenziali, visita la pagina dei prezzi di xAI.

I prezzi elencati sono per milione di token che, secondo una regola pratica corrisponde a circa 750.000 parole di input o output in inglese.

Il mini model è significativamente più economico rispetto al modello standard. Le versioni fast sia di Grok 3 sia di Grok 3 mini usano gli stessi modelli sottostanti, ma sono servite su un'infrastruttura più veloce, con tempi di risposta migliori.

Per usare l'API, dobbiamo acquistare crediti. All'inizio è consigliabile usare crediti prepagati piuttosto che la fatturazione automatica a consuntivo, perché rappresentano una buona protezione contro costi imprevisti. Puoi acquistare token e avere una panoramica del tuo utilizzo nella console xAI in Invoices > Credits.

Configurare l'ambiente Python

Ora che abbiamo ottenuto una chiave API e acquistato crediti, è il momento di configurare il client Python. Dobbiamo installare due dipendenze per eseguire correttamente le richieste all'API:

• python-dotenv per caricare la chiave API come variabile d'ambiente dal file .env, e
• il client openai come interfaccia per inviare richieste a Grok 3.

Per configurare l'ambiente del nostro progetto, ti consiglio di usare Anaconda per evitare potenziali conflitti tra diversi pacchetti Python. Dopo aver installato Anaconda, creiamo un ambiente chiamato grok3 usando Python 3.10 e lo attiviamo con i seguenti comandi nel terminale:

conda create -n grok3 python=3.10
conda activate grok3Offerto da

Infine, installiamo le dipendenze:

pip install python-dotenv openaiOfferto da

Inviare la prima richiesta utente

È ora di iniziare con il nostro primo script! Per prima cosa dobbiamo importare le funzioni che useremo dai pacchetti installati in precedenza, oltre a os per leggere la chiave API.

import os
from dotenv import load_dotenv
from openai import OpenAIOfferto da

La variabile d'ambiente che fa riferimento alla chiave API viene resa disponibile eseguendo la funzione load_dotenv() importata dal pacchetto dotenv.

# Load environment variables
load_dotenv()Offerto da

Il passo successivo è inizializzare il client. Chiamiamo la funzione OpenAI con la nostra chiave API dal file .env e l'URL del server di Grok, e la assegniamo alla variabile client.

client = OpenAI(
    api_key=os.getenv("XAI_API_KEY"),
    base_url="https://api.x.ai/v1",
)Offerto da

Chiediamo a Grok un consiglio su cosa fare a San Francisco se piove. Dobbiamo specificare il model e i nostri messages, e passarli come argomenti alla funzione client.chat.completions.create. Facoltativamente possiamo anche regolare parametri come max_tokens per controllare la lunghezza della risposta o temperature per influenzare la casualità.

# Send a basic reasoning query
response = client.chat.completions.create(
    model="grok-3",
    messages=[
        {"role": "user", "content": "What kind of activity would you suggest, if it rains in San Francisco? Answer in one sentence."}
    ],
    max_tokens=1000,
    temperature=0.2,  # lower temperature for more deterministic answers
)Offerto da

Per stampare la risposta di Grok, dobbiamo estrarla dall'oggetto risultante. Dato che abbiamo chiamato response la variabile che contiene il risultato, la risposta si trova in response.choices[0].message.content.

print(response.choices[0].message.content) # Print the responseOfferto da

If it rains in San Francisco, I suggest visiting indoor attractions like the San Francisco Museum of Modern Art or the California Academy of Sciences for an enriching and dry experience.Offerto da

Ragionare con Grok 3 Mini

Per vedere lo stile di ragionamento di Grok, poniamo una domanda di base che richiede un po' di logica. Useremo Grok 3 Mini per questa prima richiesta perché garantisce una traccia di ragionamento completa in ogni risposta dell'API, rendendo più facile seguire passo dopo passo il processo mentale del modello senza dover ricorrere a prompt engineering specifici.

Il parametro che determina la profondità del ragionamento del modello si chiama reasoning_effort. È esclusivo di Grok 3 Mini ed è impostato di default sull'opzione più veloce "low". Impostare reasoning_effort="high" aiuta il modello a scomporre con cura il problema passo dopo passo prima di fornire la risposta finale, ed è perfetto per compiti come pianificazione, presa di decisioni o ragionamento matematico.

Immagina di voler usare Grok per capire cosa fare in un giorno libero, a seconda del meteo. Possiamo passare a Grok delle premesse che definiscono un'attività per le giornate di sole e di pioggia, e una premessa basata sul meteo effettivo.

response = client.chat.completions.create(
    model="grok-3-mini-beta",
    reasoning_effort="high",
    messages=[
        {"role": "user", "content": (
            "Premises:\n"
            "- If it is raining, the weather is suitable for indoor activities.\n"
        	"- Visiting a museum is an indoor activity.\n"
        	"- Today, it is raining.\n"
            "Question: What should we do today?"    	
        )}
    ],
    max_tokens=1000,
    temperature=0.2,
)Offerto da

Per lavorare con la traccia di ragionamento, dobbiamo prima effettuare il parsing della risposta dell'API ed estrarre l'attributo reasoning_content dall'oggetto message. Il codice seguente mostra come stampare sia i passaggi di ragionamento dettagliati sia la risposta finale, in modo simile a come apparirebbero in un'interfaccia web.

# Print the reasoning trace if available
reasoning = getattr(response.choices[0].message, "reasoning_content", None)
 
if reasoning:
    print("Reasoning steps:\n")
    print(reasoning)
else:
    print("No detailed reasoning trace found.")
 
# Print the final answer
print("\nFinal Answer:\n")
print(response.choices[0].message.content)Offerto da

Il risultato è il seguente:

Reasoning steps:
First, the premises are:
1. If it is raining, the weather is suitable for indoor activities.
2. Visiting a museum is an indoor activity.
3. Today, it is raining.
The question is: What should we do today?
I need to reason step by step based on the given premises.
From premise 3, today it is raining.
From premise 1, if it is raining, then the weather is suitable for indoor activities. Since it's raining today, the weather is suitable for indoor activities today.  	
From premise 2, visiting a museum is an indoor activity. So, if the weather is suitable for indoor activities, and visiting a museum is an indoor activity, it makes sense that visiting a museum would be a good choice today.
The conclusion should be that we should visit a museum or engage in some indoor activity. But the question is "What should we do today?" and the premises point towards indoor activities, with a specific example given.
Let me chain the logic:
- It is raining (premise 3).
- Therefore, weather is suitable for indoor activities (from premise 1).
- Visiting a museum is an indoor activity (premise 2).
- So, since the weather is suitable for indoor activities, and museum visiting is an indoor activity, it should be suitable to visit a museum.
The premises don't explicitly say that we should do the most suitable activity or anything like that. They just provide conditions and facts.
However, the question implies a recommendation based on the premises. Given that it's raining and indoor activities are suitable, and a museum is mentioned, it's logical to suggest visiting a museum.
I should stick to what's given. The premises don't suggest any other activities or constraints, so based on the information, visiting a museum is a reasonable suggestion.
Final answer should be something like: "We should visit a museum today."
To make it clear, I can phrase it as: "Since it is raining and the weather is suitable for indoor activities, and visiting a museum is an indoor activity, we should visit a museum today."
But since the instruction is to put the final answer in a box, probably a concise statement.
Looking back at the user's message, it's a reasoning exercise, so the answer should be direct.
Final Answer:
Based on the given premises:
- It is raining today (premise 3).
- If it is raining, the weather is suitable for indoor activities (premise 1).   	
- Therefore, the weather is suitable for indoor activities today.
- Visiting a museum is an indoor activity (premise 2).
A suitable activity for today would be an indoor one, such as visiting a museum. 	
**Recommendation:** We should visit a museum today.Offerto da

Anche se questo è un esempio piuttosto semplice, possiamo vedere come grok-3-mini proceda con attenzione attraverso ogni premessa, concatenando la logica passo dopo passo prima di arrivare a una raccomandazione. Il suo ragionamento è metodico e trasparente, il che rende facile seguire come il modello passi dai fatti al suggerimento finale.

Function calling con Grok 3

Una delle funzionalità che rendono Grok 3 interessante è il function calling, che gli permette di collegarsi a strumenti e sistemi esterni. Questo consente al modello non solo di generare testo, ma anche di innescare azioni come recuperare previsioni meteo, consultare calendari di eventi, analizzare voci di database o persino controllare dispositivi smart.

Quando inviamo una richiesta utente, Grok 3 può riconoscere di aver bisogno di informazioni aggiuntive e richiedere la chiamata di una funzione con argomenti specifici. Il client Python quindi esegue la funzione in locale, invia il risultato a Grok 3 e riceve la risposta finale, completamente ragionata.

Fonte: xAI

Preparazione

Avremo bisogno del pacchetto json per accedere alla struttura degli argomenti di una funzione chiamata da Grok, quindi dobbiamo importarlo.

import jsonOfferto da

Per provare il function calling, dobbiamo definire una funzione di callback che venga chiamata quando Grok la richiede nella sua risposta. Nel nostro caso, la funzione get_weather_forecast è una semplice funzione Python che restituisce una previsione meteo hard-coded. L'ho resa hard-coded a scopo dimostrativo per mantenere la spiegazione lineare ed evitare di dipendere da servizi esterni.

# Define the dummy function
def get_weather_forecast(location: str, date: str) -> dict:
    """Simulated function to always return rainy weather."""
    return {
        "location": location,
        "date": “this weekend”, # hardcoded for demo purposes
        "forecast": "rainy"  # hardcoded for demo purposes
    }Offerto da

Dobbiamo inoltre definire lo strumento disponibile specificandone nome, scopo e parametri richiesti in uno schema JSON, che verrà inviato a Grok insieme alla nostra richiesta. Questa configurazione consente a Grok 3 di sapere che può chiamare questo tool ogni volta che ha bisogno di informazioni meteo per il suo ragionamento.

tools = [
    {
        "type": "function",
        "function": {
            "name": "get_weather_forecast",
            "description": "Get a simulated weather forecast for a given location and date.",
            "parameters": {
                "type": "object",
                "properties": {
                    "location": {
                        "type": "string",
                        "description": "The city where the activity will take place."
                    },
                    "date": {
                        "type": "string",
                        "description": "The date for which the weather is needed, in YYYY-MM-DD format."
                    }
            	    },
            	    "required": ["location", "date"]
            }
        }
    }
]Offerto da

Infine, il tools_map dictionary collega i nomi delle funzioni usati da Grok 3 alle effettive funzioni Python locali, permettendo al client di eseguire correttamente le chiamate agli strumenti richieste.

# Link the function names to the functions
tools_map = {
    "get_weather_forecast": get_weather_forecast
}Offerto da

Sebbene definire gli schemi degli strumenti manualmente vada benissimo per progetti semplici, usare un modulo di validazione dei dati come Pydantic diventa sempre più prezioso man mano che i progetti crescono in dimensioni e complessità. Consente la validazione automatica degli input delle funzioni, una gestione degli errori migliore e codice più pulito e manutenibile.

Esecuzione

Vediamo se Grok usa la nostra funzione di previsione meteo quando gli chiediamo un'attività consigliata a San Francisco questo weekend. Seguiamo la struttura del workflow di function calling:

1. Per prima cosa, inviamo la nostra richiesta utente iniziale contenente la domanda a Grok insieme ai tools disponibili.
2. Controlliamo la risposta di Grok per eventuali richieste di tool call e, se applicabile, chiamiamo la funzione locale corrispondente usando il tools_map. Se Grok non richiede una tool call, possiamo gestirlo restituendo la risposta iniziale del modello.
3. Successivamente, aggiungiamo il risultato alla cronologia dei messaggi; e
4. lo rimandiamo a Grok per completare il ragionamento e generare la risposta finale.

# Step 1: Send the initial user request
messages = [
    {"role": "user", "content": "What should I do this weekend in San Francisco?"}
]

response = client.chat.completions.create(
    model="grok-3",
    messages=messages,
    tools=tools,
    tool_choice="auto",
)
 
# Step 2: Check if a tool call was requested
tool_calls = getattr(response.choices[0].message, "tool_calls", [])
 
if tool_calls:
    for tool_call in tool_calls:
        function_name = tool_call.function.name
        function_args = json.loads(tool_call.function.arguments)
 
        # Find and call the matching local function
        if function_name in tools_map:
            function_result = tools_map[function_name](**function_args)
 
            # Step 3: Add the function result back to the message history
            messages.append(response.choices[0].message)  # Grok's tool call message
            messages.append({
                "role": "tool",
                "tool_call_id": tool_call.id,
                "content": json.dumps(function_result)
        	})
 
        	# Step 4: Send a new request including the tool response
            final_response = client.chat.completions.create(
                model="grok-3",
                messages=messages,
                tools=tools,
                tool_choice="auto"
        	)
 
        	# Print the final answer
            print("\nFinal Answer:")
            print(final_response.choices[0].message.content)
 
else:
    # No tool call: respond directly
    print("\nNo tool call was requested. Final Answer:")
    print(response.choices[0].message.content)Offerto da

La funzione è stata richiesta ed eseguita correttamente, come indica la risposta di Grok:

Thanks for the weather update. Since it's going to be rainy this weekend in San Francisco, I’ll suggest some indoor activities to keep you entertained and dry. Here are a few ideas for your weekend: (...)Offerto da

Potresti aver notato l'argomento tool_choice nella richiesta utente iniziale, che si riferisce alla modalità di function calling. Per impostazione predefinita, la modalità "auto" lascia decidere a Grok 3 se e quale funzione chiamare in base alla conversazione. In alternativa, possiamo controllarne il comportamento forzando una function call con "required", specificando una funzione esatta da chiamare, oppure disabilitando completamente il function calling con "none".

Output strutturati con Grok 3

Gli output strutturati consentono a Grok 3 di restituire risposte in un formato rigoroso e predefinito, come JSON, invece che in testo libero. Questo rende molto più semplice effettuare il parsing, la validazione e l'integrazione automatica delle risposte del modello in applicazioni o workflow.

Definendo uno schema in anticipo, possiamo garantire che gli output di Grok siano coerenti, leggibili dalle macchine e pronti per l'elaborazione a valle. È quindi una funzionalità molto utile per casi d'uso come l'estrazione di dati strutturati da documenti o l'invio di insight generati dall'AI a sistemi a valle come database, dashboard o pipeline di automazione senza dover ricorrere a parsing testuali fragili.

Usiamo Pydantic per definire lo schema di output perché offre un modo più pulito e leggibile per strutturare dati complessi. Sia BaseModel che Field da pydantic devono essere importati per far funzionare correttamente questa definizione di schema. Poiché il nostro output include un elenco di passaggi di ragionamento, importiamo anche List dal modulo typing di Python per specificare più precisamente il tipo degli elementi.

Sebbene sia possibile definire lo schema anche usando JSON semplice, nei test ho riscontrato che a volte Grok 3 restituiva output che non corrispondevano esattamente alla struttura attesa. Il JSON restituito era simile nel significato ma seguiva uno schema diverso, cosa che può mandare in errore applicazioni che si aspettano una struttura specifica. A causa di questa incoerenza, soprattutto con elementi annidati come le liste, consiglio vivamente di usare Pydantic per garantire che l'output strutturato venga validato e analizzato in modo affidabile.

from pydantic import BaseModel, Field
from typing import ListOfferto da

Il nostro schema, chiamato DecisionPlan, è composto dalla situation iniziale e da un elenco di DecisionSteps, definiti dal loro numero di step, dal reasoning e da un'azione action suggerita.

# Define the schema for the structured output
class DecisionStep(BaseModel):
    step: int = Field(description="Step number in the decision process")
    reasoning: str = Field(description="Reasoning behind this step")
    action: str = Field(description="Suggested action at this step")
 
class DecisionPlan(BaseModel):
    situation: str = Field(description="The initial situation to consider")
    steps: List[DecisionStep] = Field(description="List of reasoning steps leading to the final action")Offerto da

Ci sono alcune cose da considerare riguardo alla richiesta stessa. Anzitutto, dobbiamo usare client.beta.chat.completions.parse() invece di create(), così Grok sa che vogliamo un output con un formato specifico. Questo è lo schema che abbiamo appena definito e, di conseguenza, passiamo il nostro DecisionPlan come argomento response_format.

Può essere utile includere tutte le istruzioni importanti per un compito specifico nel prompt di sistema, perché aiuta Grok 3 a rimanere focalizzato sul compito per tutta la conversazione. In combinazione con lo schema definito separatamente, il prompt utente non deve specificare i campi richiesti nel JSON in output e può concentrarsi sul compito in sé.

Potremmo, ad esempio, scomporre facilmente il processo di pianificazione delle attività in tre passaggi ben definiti:

# Send a prompt and request structured output
completion = client.beta.chat.completions.parse(
    model="grok-3",
    messages=[
        {"role": "system", "content": (
        "You are an expert travel planner."
        "When asked about activities, always break down the decision process into exactly 3 logical reasoning steps."
        "Return the output in structured JSON format following the provided schema, without any extra text."
        )},
        {"role": "user", "content": (
        "It's raining today in San Francisco. What indoor activity would you recommend?"
        )}
    ],
    response_format=DecisionPlan,
)Offerto da

Dopo aver effettuato il parsing dell'output strutturato di Grok 3, possiamo agire sui risultati riassumendo le raccomandazioni chiave, attivando workflow automatizzati o persino prendendo ulteriori decisioni in modo programmatico.

Scegliamo il primo esempio e mostriamo solo la nostra situazione e la raccomandazione finale del nostro esperto di viaggi, Grok. Poiché il nostro output è nel formato JSON predefinito, possiamo accedere facilmente alla raccomandazione dell'ultimo passaggio:

# Access the parsed result
plan = completion.choices[0].message.parsed
 
# Use the final action to create a summary message
final_step = plan.steps[-1]
 
print(f"\nSummary:")
print(f"Situation: {plan.situation}")
print(f"Recommended Action: {final_step.action}")Offerto da

Summary:
Situation: It's raining today in San Francisco, and an indoor activity is needed to make the most of the day.
Recommended Action: Visiting the California Academy of Sciences in Golden Gate Park for an educational and entertaining indoor experience.Offerto da

Mettere tutto insieme: creare una semplice app di ragionamento con Grok 3

Possiamo combinare function calling e output strutturati per creare una semplice app che sfrutta il ragionamento di Grok. Possiamo copiare e incollare il codice per:

• Importare tutti i pacchetti e le funzioni menzionati prima;
• Inizializzare il client;
• Definire lo schema della funzione, la funzione fittizia e il tools_map; e
• Definire lo schema di output.

Iniziamo con una chiamata all'API usando la funzione create() per innescare la tool call. Per consentire all'utente di inserire la domanda nel terminale, sostituiamo la nostra domanda sull'attività a San Francisco con input(">> ").

Dopo aver aggiunto il function_result alla lista messages arriva il colpo di scena: invece di creare un'altra chiamata all'API che usa create(), we parse() e passiamo il nostro DecisionPlan come response_format`.

Ecco il codice completo della nostra piccola app:

import os
import json
from dotenv import load_dotenv
from openai import OpenAI
from pydantic import BaseModel, Field
from typing import List
 
# Load environment variables
load_dotenv()
 
# Initialize the client
client = OpenAI(
    api_key=os.getenv("XAI_API_KEY"),
    base_url="https://api.x.ai/v1",
)
 
# 1. Define the function schema (tool definition)
tools = [
    {
        "type": "function",
        "function": {
            "name": "get_weather_forecast",
            "description": "Get a simulated weather forecast for a given location and date.",
            "parameters": {
                "type": "object",
                "properties": {
                    "location": {
                        "type": "string",
                        "description": "The city where the activity will take place."
                	},
                    "date": {
                        "type": "string",
                        "description": "The date for which the weather is needed, in YYYY-MM-DD format."
                    }
            	    },
                "required": ["location", "date"]
        	}
        }
    }
]
 
# 2. Dummy weather function (hardcoded)
def get_weather_forecast(location: str, date: str) -> dict:
    return {
        "location": location,
        "date": "this weekend",
        "forecast": "rainy"
    }
 
# 3. Tool mapping
tools_map = {
    "get_weather_forecast": get_weather_forecast
}
 
# 4. Define structured output schema using Pydantic
class DecisionStep(BaseModel):
	step: int = Field(description="Step number in the decision process")
	reasoning: str = Field(description="Reasoning behind this step")
	action: str = Field(description="Suggested action at this step")
 
class DecisionPlan(BaseModel):
	situation: str = Field(description="The initial situation to consider")
	steps: List[DecisionStep] = Field(description="List of reasoning steps leading to the final action")
 
# 5. Defining messages: system prompt and input
messages = [
    {"role": "system", "content": (
        "You are an expert travel planner. When asked about weekend plans, "
        "first get the weather forecast via the tool provided. Then, based on the result, "
        "break down your reasoning into exactly 3 steps and return structured JSON only."
    )},
    {"role": "user", "content": input("> ")} # enter the question in the terminal
]
 
# 6. First API call to trigger the tool call
response = client.chat.completions.create(
    model="grok-3",
    messages=messages,
    tools=tools,
    tool_choice="auto",
)
 
tool_calls = getattr(response.choices[0].message, "tool_calls", [])
 
if tool_calls:
    for tool_call in tool_calls:
        function_name = tool_call.function.name
        function_args = json.loads(tool_call.function.arguments)
        if function_name in tools_map:
            function_result = tools_map[function_name](**function_args)
 
        	# Add the assistant's tool call message and the tool result to the message history
            messages.append(response.choices[0].message)
            messages.append({
                "role": "tool",
                "tool_call_id": tool_call.id,
                "content": json.dumps(function_result)
        	})
 
        	# 7. Second API call with parse() to get structured output
            final_response = client.beta.chat.completions.parse(
                model="grok-3",
                messages=messages,
                response_format=DecisionPlan
        	)
 
        	plan = final_response.choices[0].message.parsed
 
        	# 8. Use the output
            final_action = plan.steps[-1].action
 
            print(f"\nSummary:")
            print(f"Situation: {plan.situation}")
            print(f"Recommended Action: {final_action}")
 
else:
    print("No tool call was requested.")Offerto da

Esempio di esecuzione

Per provare l'app, navighiamo nella directory del progetto, carichiamo l'ambiente ed eseguiamo lo script:

cd <your/working/directory>
conda activate grok3
python app.pyOfferto da

Se chiediamo qualche consiglio per Helsinki, la nostra app Grok risponde così:

È un suggerimento niente male, te lo dico per esperienza!

Conclusione

Abbiamo coperto parecchio—concludiamo. Abbiamo visto come lavorare con l'API di Grok 3 per eseguire semplici query, gestire le tracce di ragionamento e utilizzare funzionalità avanzate come function calling e output strutturati.

Abbiamo combinato queste capacità in un piccolo progetto che ha mostrato come Grok possa usare strumenti esterni e restituire risposte strutturate e azionabili. In combinazione con le API—nel nostro caso, un'API meteo—si possono costruire applicazioni potenti che sfruttano appieno i punti di forza di Grok 3.

Se sei arrivato fin qui, probabilmente ti interessa approfondire gli LLM. Dai un'occhiata anche a queste risorse:

• API GPT-Image-1: guida passo passo con esempi
• Come configurare ed eseguire Qwen3 in locale con Ollama
• Fine-tuning di Qwen3: guida passo passo