Pregúntale a un LLM sobre un CSV: envía el esquema, no la tabla

Tienes un sales.csv con 5.000 filas y una pregunta: ¿qué producto se vendió más en octubre? No pegues el archivo en un chat. Envía al modelo los nombres de las columnas, sus tipos y tres filas de ejemplo, pide una línea de pandas y ejecuta esa línea tú mismo sobre el archivo completo. El modelo nunca lee tus 5.000 filas, el prompt se mantiene diminuto y el número que obtienes proviene de código que puedes volver a ejecutar.

Aquí está por qué eso funciona mejor, cómo se ve el prompt, un script que puedes copiar y cuánto cuesta frente a la forma de pegarlo todo.

Por qué pegar la tabla entera sale mal#

Aquí hay una historia que quizá reconozcas. Alguien pega 200 filas de gastos en un chat y pide el total. La respuesta llega con seguridad, con céntimos y todo. También es incorrecta, y nada en la pantalla te lo indica.

El modelo predice texto pieza a pieza (esas piezas son tokens). Una suma de 200 números son 200 pequeños pasos sin calculadora dentro, y un dígito deslizado parece exactamente una respuesta correcta. El código se comporta distinto: df['amount'].sum() suma todas las filas, siempre, y da el mismo resultado en una segunda ejecución.

Hay un segundo problema, y es de tamaño. Una tabla consume la ventana de contexto rápido, y pagas por cada fila en cada pregunta. Diez preguntas sobre el mismo archivo significan diez copias de la tabla entera enviadas como entrada.

Envía la forma de la tabla, no la tabla#

El modelo no necesita tus datos para escribir el código. Necesita saber cómo es la tabla: qué columnas existen, qué tipo de valores contienen y cómo se escribe una fila. Eso es el esquema más unas pocas filas.

Digamos que tu sales.csv tiene cuatro columnas. Este es el prompt completo:

A pandas DataFrame named df has these columns and types:
date        object
product     object
units        int64
price      float64

First 3 rows (CSV):
date,product,units,price
2026-10-01,Oat latte mix,12,4.50
2026-10-01,Cocoa,7,3.20
2026-10-02,Oat latte mix,9,4.50

Question: Which product sold the most units in October 2026?

Reply with ONE line of pandas code that computes the answer from df.
No explanation, no markdown, no imports.

Espera una respuesta con forma de df[df['date'].str.startswith('2026-10')].groupby('product')['units'].sum().idxmax(). La redacción exacta varía de una ejecución a otra, así que lee la línea antes de ejecutarla.

¿Por qué tres filas y no solo los nombres de las columnas? Por la fecha. La columna de tipo dice object, que solo significa texto. Las filas de ejemplo muestran que la fecha está escrita 2026-10-01, así que el modelo sabe que debe coincidir con el texto 2026-10, no con 10/2026 ni con un nombre de mes. La mayoría de las líneas de pandas incorrectas vienen de adivinar un formato que la tabla nunca tuvo.

El script: pregunta, lee la línea, ejecútala#

El script de abajo construye ese prompt a partir de tu archivo, así no escribes el esquema a mano. Llama a la API de CheapTokens a través del SDK de OpenAI para Python: URL base https://api.cheaptokens.dev/v1, id de modelo deepseek-ai/DeepSeek-V4-Flash-0731. Guarda la clave en una variable de entorno, no en el archivo.

import os
import pandas as pd
from openai import OpenAI

client = OpenAI(
    base_url="https://api.cheaptokens.dev/v1",
    api_key=os.environ["CHEAPTOKENS_API_KEY"],
)

df = pd.read_csv("sales.csv")      # for .xlsx: pd.read_excel("sales.xlsx")

schema = df.dtypes.to_string()
sample = df.head(3).to_csv(index=False)
question = "Which product sold the most units in October 2026?"

prompt = f"""A pandas DataFrame named df has these columns and types:
{schema}

First 3 rows (CSV):
{sample}
Question: {question}

Reply with ONE line of pandas code that computes the answer from df.
No explanation, no markdown, no imports."""

resp = client.chat.completions.create(
    model="deepseek-ai/DeepSeek-V4-Flash-0731",
    messages=[{"role": "user", "content": prompt}],
    max_tokens=500,
)

text = resp.choices[0].message.content.strip()
code = text.removeprefix("```python").removeprefix("```").removesuffix("```").strip()
print("Model's line:", code)
print("Tokens in/out:", resp.usage.prompt_tokens, resp.usage.completion_tokens)

if resp.choices[0].finish_reason != "stop" or "import" in code or "__" in code:
    raise SystemExit("Not running this one. Read the line above and decide.")

print("Answer:", eval(code, {"df": df, "pd": pd}))

El último bloque es la parte que los principiantes se saltan. eval ejecuta el texto que sea que el modelo escribió, en tu máquina, así que el script rechaza líneas con import o __ y respuestas que se cortaron (finish_reason distinto de stop; mira por qué una respuesta se detiene a mitad de frase). Y aún así lees primero la línea impresa. Si toca archivos, la red o cualquier cosa que no pediste, no la ejecutes.

La primera ejecución imprime tres cosas: la línea del modelo, los conteos de tokens de esta única solicitud y la respuesta. Los conteos de tokens son tu medidor para la siguiente sección.

Cuánto cuesta: pegar todo frente a esquema + 3 filas#

Para comparar, necesitamos un tamaño para una fila. Digamos que una fila como 2026-10-01,Oat latte mix,12,4.50 ocupa unos 20 tokens. Eso es una suposición: depende del tokenizador del modelo y de tus columnas, y contar tokens antes de enviar muestra tu número real. Con 20 tokens por fila, 5.000 filas son 5.000 × 20 = 100.000 tokens de entrada. El prompt de esquema y tres filas ronda los 300 tokens, instrucciones incluidas. La respuesta es corta en ambos casos, digamos 60 tokens, así que la diferencia está enteramente del lado de la entrada, la que crece con tu tabla (más sobre eso en tokens de entrada vs salida).

Ambos números son pequeños en dólares, y eso es honesto: un modelo barato hace que incluso la forma derrochadora sea asequible. La brecha es lo que crece. Haz 20 preguntas al día y el prompt de pegar todo se envía 20 veces. Duplica la tabla y su costo se duplica, mientras que el prompt de esquema no se mueve. Y hay un muro duro: con una ventana de contexto de 380K tokens, 380.000 ÷ 20 = 19.000 filas es lo máximo que podrías pegar alguna vez, antes de dejar espacio para la respuesta. Una exportación de 50.000 filas simplemente no cabe. El prompt de esquema sí, sea cual sea el tamaño de la tabla.

Conecta tu propia tabla y mira el costo diario:

Cambia in a 300 para ver la forma de esquema. DeepSeek-V4-Flash en CheapTokens tiene un precio a cualquier hora, sin recargo en horas pico, y un saldo cubre todos los modelos, así que puedes cambiar el id de modelo por zai-org/GLM-5.3-Flash (390K de contexto) sin una segunda cuenta. Los precios actuales están en la página de precios.

Comprueba el número antes de confiar en él#

El bucle es siempre el mismo. Hazlo cada vez, y una respuesta incorrecta se detecta en el paso cuatro en lugar de en un informe.

El paso cuatro es barato. Filtra el archivo a un puñado de filas (df[df['product'] == 'Cocoa'].head(10)), súmalas mentalmente o en una hoja de cálculo, y compara. Si la línea del modelo está mal, normalmente lo está de forma obvia: contó filas en lugar de sumar units, o eligió el mes equivocado.

Para más hábitos como este, mira por qué la IA inventa cosas y 4 hábitos de prompt que lo reducen.

Si no funciona#

• KeyError: 'Date'. El modelo escribió un nombre de columna con mayúsculas distintas. Pega la fila de encabezado real en el prompt, que las tres filas de ejemplo ya hacen, y añade "usa los nombres de columna exactamente como se muestran".
• La respuesta tiene una frase antes del código. Tu eval falla con un SyntaxError. Repite "UNA línea de código pandas, sin explicación" al final del prompt, la última instrucción cuenta más.
• La respuesta es una tabla, no un número. Di qué forma quieres: "devuelve un único número" o "devuelve una Serie ordenada de forma descendente".
• Las fechas salen mal. Las filas de ejemplo muestran el formato real. Si tus fechas son 14/10/2026, el modelo necesita verlo; añade pd.to_datetime(df['date'], dayfirst=True) al prompt como la forma en que te gustaría que se leyeran las fechas.
• finish_reason es length. La respuesta fue cortada por max_tokens. Una sola línea cabe en 500 tokens, así que revisa el prompt: puede que el modelo esté explicando largamente.

La configuración completa para tu primera solicitud, desde la clave hasta la respuesta, está en la documentación de CheapTokens.