Flussi di lavoro sui dati con Code Interpreter
In questa pagina
Lezione aggiornata il 2 novembre 2026 sulla base della documentazione OpenAI: lo strumento Code Interpreter richiede un parametro
container(aggiunto a tutti gli esempi), le parti testuali dell’input sono di tipoinput_texte la ricerca web utilizza lo strumentoweb_search(web_search_previewè ora uno strumento legacy senza filtri per dominio). I file generati vengono recuperati utilizzando le funzionifichiers_generesetelechargerdella Lezione 10. I file allegati al messaggio vengono caricati con lo scopouser_data, come raccomandato da OpenAI per gli input del modello (File inputs). Fonti: Code Interpreter · Ricerca web.
Flussi di lavoro sui dati con Code Interpreter
Le lezioni precedenti hanno trattato singoli compiti uno per uno. L’analisi reale li concatena: importi, pulisci, calcoli, visualizzi ed esporti. È la catena, non ogni singolo passo isolato, a far perdere tempo quando viene eseguita manualmente.
I quattro flussi di lavoro seguenti sono casi reali, volutamente vari: reportistica periodica, analisi comportamentale nel tempo, segmentazione e previsioni. Leggili meno per il codice e più per la struttura del prompt: numerata, esplicita sui deliverables attesi e precisa sul formato. Questa struttura trasforma una richiesta vaga in un report azionabile che puoi applicare direttamente ai tuoi dati.
Flusso di lavoro 1: Report finanziario automatizzato
La reportistica periodica è il candidato ideale per l’automazione per una semplice ragione: i file cambiano, ma la struttura del report no. Una volta scritto e validato il prompt per un mese, funziona per gli undici successivi. Nota l’istruzione finale, che richiede un’esportazione Excel per sezione. Questo rende il risultato direttamente condivisibile, invece di lasciarti con del testo che necessita di riformattazione.
from openai import OpenAI
client = OpenAI()
# Caricamento dei file sorgente
files = {}
for name in ["revenus_2025.xlsx", "depenses_2025.xlsx", "budget_previsionnel.xlsx"]:
with open(name, "rb") as f:
file_obj = client.files.create(file=f, purpose="user_data")
files[name] = file_obj.id
content = [
{"type": "input_text", "text": (
"Genera un report finanziario completo da questi 3 file: "
"1. RIEPILOGO: Ricavi totali, margine lordo, utile netto "
"2. ANALISI MENSILE: Evoluzione mese su mese con variazioni "
"3. SCOSTAMENTI DI BUDGET: Confronto effettivo vs previsto, scostamenti significativi "
"4. GRAFICI: "
" - Evoluzione ricavi e spese (asse doppio) "
" - Waterfall degli scostamenti di budget "
" - Ripartizione spese per categoria "
"5. ESPORTAZIONE: File Excel con una scheda per sezione"
)}
]
for fid in files.values():
content.append({"type": "input_file", "file_id": fid})
response = client.responses.create(
model="gpt-5.6-terra",
input=[{"role": "user", "content": content}],
tools=[{"type": "code_interpreter", "container": {"type": "auto"}}],
instructions=(
"Produci un report professionale. "
"Visualizza le cifre con separatori delle migliaia. "
"Usa il formato europeo (virgola decimale). "
"Commenta ogni scostamento significativo (> 5%)."
)
)
# Recupera tutti i file generati
for ann in fichiers_generes(response):
telecharger(client, ann, f"sortie_{ann.filename}")
print(f"Generato: {ann.filename}")
Flusso di lavoro 2: Analisi di coorte
L’analisi di coorte traccia gruppi formati alla stessa data di ingresso nel tempo. Pochi team eseguono regolarmente questo calcolo perché la configurazione è noiosa. È proprio per questo che vale la pena delegarlo: la logica è standard, cambiano solo i dati.
with open("utilisateurs.csv", "rb") as f:
file_obj = client.files.create(file=f, purpose="user_data")
response = client.responses.create(
model="gpt-5.6-terra",
input=[{
"role": "user",
"content": [
{"type": "input_text", "text": (
"Esegui un'analisi di coorte su questi dati utente: "
"1. Definisci le coorti per mese di iscrizione "
"2. Calcola il tasso di ritenzione per coorte (mese 1, 2, ..., 12) "
"3. Crea una mappa di calore della ritenzione "
"4. Identifica la coorte con la migliore ritenzione "
"5. Stima l'LTV per coorte "
"6. Esporta la tabella di ritenzione come CSV"
)},
{"type": "input_file", "file_id": file_obj.id}
]
}],
tools=[{"type": "code_interpreter", "container": {"type": "auto"}}],
instructions=(
"Mostra il codice passo dopo passo. "
"Visualizza i risultati intermedi. "
"Per la mappa di calore, usa una palette verde (scuro = buono, chiaro = basso). "
"Annota ogni cella con la percentuale."
)
)
Flusso di lavoro 3: Scoring e segmentazione
Qui il modello non si limita a descrivere i dati; costruisce un punteggio e forma gruppi. Questo richiede una precauzione: chiedi sempre il metodo oltre al risultato. Un segmento come «clienti a rischio» senza i criteri che lo hanno prodotto è inutilizzabile: nessuno può contestarlo, riprodurlo o correggerlo.
def segmenter_clients(file_path: str) -> dict:
"""Segmenta i clienti utilizzando RFM e clustering."""
with open(file_path, "rb") as f:
file_obj = client.files.create(file=f, purpose="user_data")
response = client.responses.create(
model="gpt-5.6-terra",
input=[{
"role": "user",
"content": [
{"type": "input_text", "text": (
"Esegui una segmentazione clienti RFM: "
"1. Calcola Recency, Frequency, Monetary per ogni cliente "
"2. Assegna un punteggio RFM da 1 a 5 per ogni dimensione "
"3. Crea segmenti: Campioni, Fedeli, A Rischio, Persi "
"4. Applica K-Means (k=4 a 8, scegli il miglior k usando il metodo del gomito) "
"5. Visualizza i segmenti in 2D (PCA o t-SNE) "
"6. Profila ogni segmento: dimensione, ricavo medio, frequenza "
"7. Esportazione: CSV con segmento per cliente + report simile a PDF"
)},
{"type": "input_file", "file_id": file_obj.id}
]
}],
tools=[{"type": "code_interpreter", "container": {"type": "auto"}}],
instructions=(
"Usa sklearn per il clustering. "
"Normalizza le variabili prima del clustering. "
"Visualizza il grafico del gomito per giustificare la scelta di k. "
"Crea un grafico a radar per segmento."
)
)
output_files = []
for ann in fichiers_generes(response):
telecharger(client, ann, ann.filename)
output_files.append(ann.filename)
return {
"analysis": response.output_text,
"files": output_files
}
Flusso di lavoro 4: Previsioni e trend
Le previsioni sono il flusso di lavoro in cui la cautela conta di più. Il container può eseguire una regressione o una decomposizione stagionale e lo farà anche quando i tuoi dati non sono adatti: bastano venti punti dati per produrre una curva perfettamente presentabile ma completamente priva di significato. Esigi l’intervallo di confidenza e le assunzioni del modello: è questo che distingue una proiezione da un’estrapolazione.
response = client.responses.create(
model="gpt-5.6-terra",
input=[{
"role": "user",
"content": [
{"type": "input_text", "text": (
"Sulla base di questi dati di vendita mensili: "
"1. Decomponi la serie temporale (trend, stagionalità, residuo) "
"2. Applica lo smoothing esponenziale (Holt-Winters) "
"3. Prevedi i prossimi 6 mesi con un intervallo di confidenza al 95% "
"4. Confronta con una semplice regressione lineare "
"5. Genera un grafico con storico + previsioni "
"6. Calcola le metriche di errore (MAE, RMSE, MAPE)"
)},
{"type": "input_file", "file_id": file_obj.id}
]
}],
tools=[{"type": "code_interpreter", "container": {"type": "auto"}}],
instructions=(
"Usa statsmodels per la decomposizione e le previsioni. "
"Colora l'intervallo di confidenza in blu trasparente. "
"Segna chiaramente la separazione tra storico e previsioni."
)
)
Orchestrazione di un flusso di lavoro multi-step
Oltre una certa dimensione, un singolo prompt raggiunge i suoi limiti: l’analisi devia, un’istruzione intermedia viene dimenticata e perdi il conto del passo in cui ti trovi. Scomporre il processo in chiamate successive, tutte operanti all’interno dello stesso container dove i file del passo precedente rimangono disponibili, ripristina ciò che hai perso: un checkpoint dopo ogni passo e la capacità di riprendere dal passo errato invece di ricominciare tutto da capo.
class WorkflowData:
def __init__(self):
self.client = OpenAI()
# Un container esplicito: i file prodotti rimangono disponibili da un passo all'altro
self.container = self.client.containers.create(name="workflow-data")
self.intermediate_files = []
def step(self, instruction: str, file_ids: list[str] | None = None) -> str:
"""Esegue un passo del flusso di lavoro nel container condiviso."""
content = [{"type": "input_text", "text": instruction}]
for fid in file_ids or []:
content.append({"type": "input_file", "file_id": fid})
response = self.client.responses.create(
model="gpt-5.6-terra",
input=[{"role": "user", "content": content}],
tools=[{"type": "code_interpreter", "container": self.container.id}],
)
# Memorizza i file generati da scaricare alla fine
self.intermediate_files.extend(fichiers_generes(response))
return response.output_text
def download_results(self, output_folder: str):
"""Scarica i file generati prima che il container scada."""
import os
os.makedirs(output_folder, exist_ok=True)
for ann in self.intermediate_files:
telecharger(self.client, ann, os.path.join(output_folder, ann.filename))
# Utilizzo
wf = WorkflowData()
# Passo 1: Importazione e pulizia
with open("donnees_brutes.csv", "rb") as f:
file_obj = client.files.create(file=f, purpose="user_data")
wf.step(
"Pulisci questo CSV: rimuovi i duplicati, gestisci i valori mancanti, "
"normalizza i tipi. Esporta il risultato.",
[file_obj.id]
)
# Passo 2: Analisi
wf.step("Calcola i KPI chiave e identifica i trend.")
# Passo 3: Visualizzazione
wf.step("Crea 4 grafici chiave per un report executive.")
# Passo 4: Esportazione
wf.step("Compila tutto in un file Excel con schede e grafici incorporati.")
wf.download_results("./sortie_workflow/")
Punti chiave
- Scomponi i flussi di lavoro complessi in passaggi con passaggio di file
- Usa istruzioni dettagliate per ogni passaggio
- Il modello gestisce nativamente l’analisi statistica e il machine learning di base
- Recupera sistematicamente i file intermedi per la tracciabilità
- Combina analisi dei dati e visualizzazione in un’unica chiamata per report completi