Flux de travail de données avec Code Interpreter
Nesta página
Lição atualizada em 2 de novembro de 2026 com base na documentação da OpenAI: a ferramenta Code Interpreter requer um parâmetro
container(adicionado a todos os exemplos), as partes de texto da entrada são do tipoinput_texte a pesquisa na web utiliza a ferramentaweb_search(web_search_previewé agora uma ferramenta legada sem filtros de domínio). Os ficheiros gerados são recuperados através das funçõesfichiers_generesetelechargerda Lição 10. Os ficheiros anexados à mensagem são carregados com o propósitouser_data, que a OpenAI recomenda para entradas do modelo (File inputs). Fontes: Code Interpreter · Web search.
Fluxos de trabalho de dados com Code Interpreter
As lições anteriores abordaram tarefas individuais uma a uma. A análise real encadeia-as: importa, limpa, calcula, visualiza e exporta. É a cadeia — e não cada passo isolado — que consome tempo quando feita manualmente.
Os quatro fluxos de trabalho abaixo são casos reais, deliberadamente variados: relatórios periódicos, análise comportamental ao longo do tempo, segmentação e previsão. Leia-os menos pelo código e mais pela estrutura do prompt — numerada, explícita quanto aos resultados esperados e precisa quanto ao formato. Esta estrutura transforma um pedido vago num relatório acionável, que pode aplicar diretamente aos seus próprios dados.
Fluxo de trabalho 1: Relatório financeiro automatizado
O relatório periódico é o melhor candidato para automação por uma razão simples: os ficheiros mudam, mas a estrutura do relatório não. Assim que escrever e validar o prompt para um mês, este funcionará para os onze seguintes. Note a instrução final, que solicita uma exportação Excel por secção. Isto torna o resultado diretamente partilhável, em vez de o deixar com texto que necessita de reformatação.
from openai import OpenAI
client = OpenAI()
# Carregar ficheiros de origem
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": (
"Generate a complete financial report from these 3 files: "
"1. SUMMARY: Total revenue, gross margin, net income "
"2. MONTHLY ANALYSIS: Month-over-month evolution with variations "
"3. BUDGET VARIANCES: Actual vs. forecast comparison, significant variances "
"4. CHARTS: "
" - Revenue and expenses evolution (dual axis) "
" - Budget variance waterfall "
" - Expense breakdown by category "
"5. EXPORT: Excel file with one tab per section"
)}
]
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=(
"Produce a professional report. "
"Display figures with thousands separators. "
"Use European format (decimal comma). "
"Comment on each significant variance (> 5%)."
)
)
# Recuperar todos os ficheiros gerados
for ann in fichiers_generes(response):
telecharger(client, ann, f"sortie_{ann.filename}")
print(f"Generated: {ann.filename}")
Fluxo de trabalho 2: Análise de coortes
A análise de coortes acompanha grupos formados na mesma data de entrada ao longo do tempo. Poucas equipas realizam este cálculo regularmente porque a sua configuração é tediosa. É precisamente por isso que vale a pena delegá-lo: a lógica é padrão; apenas os dados mudam.
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": (
"Perform a cohort analysis on this user data: "
"1. Define cohorts by signup month "
"2. Calculate retention rate per cohort (month 1, 2, ..., 12) "
"3. Create a retention heatmap "
"4. Identify the cohort with the best retention "
"5. Estimate LTV per cohort "
"6. Export the retention table as CSV"
)},
{"type": "input_file", "file_id": file_obj.id}
]
}],
tools=[{"type": "code_interpreter", "container": {"type": "auto"}}],
instructions=(
"Show the code step by step. "
"Display intermediate results. "
"For the heatmap, use a green palette (dark = good, light = low). "
"Annotate each cell with the percentage."
)
)
Fluxo de trabalho 3: Pontuação e segmentação
Aqui, o modelo não se limita a descrever os dados; constrói uma pontuação e forma grupos. Isto requer uma precaução: peça sempre o método além do resultado. Um segmento como «clientes em risco» sem os critérios que o produziram é inutilizável: ninguém o pode contestar, reproduzir ou corrigir.
def segmenter_clients(file_path: str) -> dict:
"""Segmenta clientes usando 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": (
"Perform RFM customer segmentation: "
"1. Calculate Recency, Frequency, Monetary for each customer "
"2. Assign an RFM score from 1 to 5 for each dimension "
"3. Create segments: Champions, Loyal, At Risk, Lost "
"4. Apply K-Means (k=4 to 8, choose the best k using elbow method) "
"5. Visualize segments in 2D (PCA or t-SNE) "
"6. Profile each segment: size, average revenue, frequency "
"7. Export: CSV with segment per customer + PDF-like report"
)},
{"type": "input_file", "file_id": file_obj.id}
]
}],
tools=[{"type": "code_interpreter", "container": {"type": "auto"}}],
instructions=(
"Use sklearn for clustering. "
"Normalize variables before clustering. "
"Display the elbow plot to justify the choice of k. "
"Create a radar chart per segment."
)
)
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
}
Fluxo de trabalho 4: Previsão e tendências
A previsão é o fluxo de trabalho onde a cautela é mais importante. O contentor pode executar uma regressão ou uma decomposição sazonal, e fá-lo-á mesmo quando os seus dados não forem adequados — vinte pontos de dados são suficientes para produzir uma curva perfeitamente apresentável que é completamente sem sentido. Exija o intervalo de confiança e as premissas do modelo: é isto que distingue uma projeção de uma extrapolação.
response = client.responses.create(
model="gpt-5.6-terra",
input=[{
"role": "user",
"content": [
{"type": "input_text", "text": (
"Based on this monthly sales data: "
"1. Decompose the time series (trend, seasonality, residual) "
"2. Apply exponential smoothing (Holt-Winters) "
"3. Forecast the next 6 months with a 95% confidence interval "
"4. Compare with a simple linear regression "
"5. Generate a chart with history + forecasts "
"6. Calculate error metrics (MAE, RMSE, MAPE)"
)},
{"type": "input_file", "file_id": file_obj.id}
]
}],
tools=[{"type": "code_interpreter", "container": {"type": "auto"}}],
instructions=(
"Use statsmodels for decomposition and forecasting. "
"Color the confidence interval in transparent blue. "
"Clearly mark the separation between history and forecasts."
)
)
Orquestração de um fluxo de trabalho em várias etapas
Além de um certo tamanho, um único prompt atinge os seus limites: a análise desvia-se, uma instrução intermédia é esquecida e perde-se a noção da etapa em que se encontra. Dividir o processo em chamadas sucessivas, todas a trabalhar no mesmo contentor onde os ficheiros da etapa anterior permanecem disponíveis, restaura o que perdeu — um ponto de verificação após cada etapa e a capacidade de retomar a partir da etapa defeituosa em vez de reiniciar tudo.
class WorkflowData:
def __init__(self):
self.client = OpenAI()
# Um contentor explícito: os ficheiros produzidos permanecem disponíveis de uma etapa para a outra
self.container = self.client.containers.create(name="workflow-data")
self.intermediate_files = []
def step(self, instruction: str, file_ids: list[str] | None = None) -> str:
"""Executa uma etapa do fluxo de trabalho no contentor partilhado."""
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}],
)
# Memorizar ficheiros gerados para descarregar no final
self.intermediate_files.extend(fichiers_generes(response))
return response.output_text
def download_results(self, output_folder: str):
"""Descarrega os ficheiros gerados antes da expiração do contentor."""
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))
# Utilização
wf = WorkflowData()
# Etapa 1: Importar e limpar
with open("donnees_brutes.csv", "rb") as f:
file_obj = client.files.create(file=f, purpose="user_data")
wf.step(
"Clean this CSV: remove duplicates, handle missing values, "
"normalize types. Export the result.",
[file_obj.id]
)
# Etapa 2: Análise
wf.step("Calculate key KPIs and identify trends.")
# Etapa 3: Visualização
wf.step("Create 4 key charts for an executive report.")
# Etapa 4: Exportação
wf.step("Compile everything into an Excel file with tabs and embedded charts.")
wf.download_results("./sortie_workflow/")
Pontos-chave
- Divida fluxos de trabalho complexos em etapas com passagem de ficheiros
- Utilize instruções detalhadas para cada etapa
- O modelo gere nativamente análise estatística e aprendizagem automática básica
- Recupere sistematicamente ficheiros intermédios para rastreabilidade
- Combine análise de dados e visualização numa única chamada para relatórios completos