Mejor LLM local para programar en Python: ¿local o API alojada?

Empieza por tus restricciones, no por un nombre de modelo

La pregunta mejor LLM local para programar en Python no tiene una respuesta fija, porque los modelos cambian rápidamente y tu máquina es el límite real. Antes de comparar nombres, anota cuatro cosas:

• Memoria GPU. Esto decide qué tamaños de modelo puedes ejecutar.
• Necesidades de contexto. Editar una función es diferente de razonar sobre un paquete completo.
• Reglas de privacidad. Algún código no puede salir de tu máquina, lo cual es una razón legítima para permanecer local.
• Tolerancia a rechazos. Las herramientas de seguridad, scrapers, ingeniería inversa y fuzzers pueden activar rechazos en modelos altamente filtrados.

Si operar totalmente sin conexión es un requisito imprescindible, necesitas un modelo que ejecutes tú mismo. Si no lo es, una API alojada elimina la pregunta de hardware. Este sitio pertenece al segundo grupo: es una API alojada compatible con OpenAI, no un entorno de ejecución local, y vale la pena probarla junto a tu configuración local.

Cuánta memoria GPU necesitas

Una regla aproximada para los pesos: parámetros por bytes por parámetro. A precisión de 16 bits son 2 bytes por parámetro; a 8 bits, 1 byte; a 4 bits, aproximadamente 0,5 bytes.

Tamaño del modelo	16 bits	8 bits	4 bits
7B	14 GB	7 GB	3.5 GB
14B	28 GB	14 GB	7 GB
32B	64 GB	32 GB	16 GB

Estas cifras son solo los pesos. También necesitas memoria para la caché de contexto, que crece con el prompt, y para el propio entorno de ejecución. Deja un margen de unos pocos gigabytes, y más si planeas pegar archivos grandes. La cuantización más pesada ahorra memoria pero puede costar algo de precisión, lo cual importa en código donde un solo carácter incorrecto rompe el programa.

Cómo comparar modelos de codificación de forma justa

Los rankings públicos miden tareas de otros. Un método mejor toma una hora y usa tu propio código.

1. Reúne de 15 a 20 tareas reales: un error con una prueba que falla, una función para escribir a partir de una docstring, una refactorización, una petición para agregar anotaciones de tipo.
2. Ejecuta cada modelo con el mismo prompt, la misma temperatura (0,2 es un buen inicio para código) y la misma semilla donde sea compatible.
3. Evalúa ejecutando las pruebas, no leyendo la respuesta. ¿Importa módulos reales? ¿Pasa?
4. Anota los rechazos por separado. Un modelo que es un 5% mejor en código pero rechaza tu tarea de escáner de puertos es peor para ti.
5. Registra el tiempo por tarea y, para modelos alojados, el costo por tarea.

Mantén el harness en un archivo para poder volver a ejecutarlo cuando aparezca un nuevo modelo. Esa reutilización vale más que cualquier resultado único.

Probar una opción alojada en las mismas tareas

Como la API es compatible con OpenAI, tu harness solo necesita una base URL diferente. Este script solicita una función, extrae el primer bloque Python y lo ejecuta contra una prueba. El ID del modelo es uncensored.

Copyimport re
import subprocess
import tempfile
from openai import OpenAI

client = OpenAI(base_url="https://api.uncensoredlocalllm.com/v1", api_key="YOUR_API_KEY")

TASK = "Write a Python function parse_size(text) that converts '10KB' or '2 MB' to bytes."
TEST = "assert parse_size('10KB') == 10240\nassert parse_size('2 MB') == 2 * 1024 * 1024\nprint('ok')"

r = client.chat.completions.create(
    model="uncensored",
    temperature=0.2,
    seed=7,
    messages=[
        {"role": "system", "content": "You write correct Python 3. Reply with one fenced code block and no commentary."},
        {"role": "user", "content": TASK},
    ],
)
text = r.choices[0].message.content
m = re.search(r"```(?:python)?\n(.*?)```", text, re.S)
code = m.group(1) if m else text

with tempfile.NamedTemporaryFile("w", suffix=".py", delete=False) as f:
    f.write(code + "\n" + TEST)
out = subprocess.run(["python3", f.name], capture_output=True, text=True, timeout=20)
print(out.stdout.strip() or out.stderr.strip())

Ejecuta la misma lista de tareas contra tu modelo local y compara las tasas de aprobación. El código ejecuta la salida generada, así que usa un directorio desechable o un contenedor para cualquier cosa más allá de ejemplos simples.

Dónde un modelo alojado ayuda a un desarrollador Python

Un endpoint alojado no es mejor en todos los casos, pero algunas tareas se adaptan bien a él:

• Contexto grande. La ventana de contexto es de 100.000 tokens, incluyendo prompt y completion. Esto permite incluir un módulo considerable, sus pruebas y un stack trace en una sola petición.
• Llamadas a funciones. Puedes definir herramientas como run_tests o read_file y permitir que el modelo las llame en un bucle, enviando los resultados como mensajes con role: "tool".
• Modo JSON. Con response_format: {"type":"json_object"} puedes obtener una revisión de código estructurada, como una lista de problemas con números de línea.
• Menos rechazos en tareas de seguridad. El modelo está ajustado para responder sin rechazos por contenido para uso adulto lícito, lo que incluye pruebas de seguridad de sistemas que posees o estás autorizado para probar.

La compensación es clara: tu código sale de tu máquina y necesitas una conexión de red. Los prompts no se usan para entrenamiento, pero si tu política prohíbe enviar código a terceros, manténlo local.

Dejar que el modelo ejecute tus pruebas con llamadas a funciones

Las llamadas a funciones convierten una respuesta única en un bucle: el modelo pide ejecutar las pruebas, ve el fallo y corrige el código. Define una herramienta y gestiona la llamada tú mismo.

Copyimport json
import subprocess
from openai import OpenAI

client = OpenAI(base_url="https://api.uncensoredlocalllm.com/v1", api_key="YOUR_API_KEY")

tools = [{
    "type": "function",
    "function": {
        "name": "run_tests",
        "description": "Run pytest in the project and return the output",
        "parameters": {"type": "object", "properties": {}, "required": []},
    },
}]

messages = [
    {"role": "system", "content": "You fix Python bugs. Call run_tests to check your work."},
    {"role": "user", "content": "The tests in this project fail. Run them and tell me the first error."},
]

for _ in range(5):
    r = client.chat.completions.create(model="uncensored", messages=messages, tools=tools, temperature=0.2)
    msg = r.choices[0].message
    messages.append(msg)
    if not msg.tool_calls:
        print(msg.content)
        break
    for call in msg.tool_calls:
        out = subprocess.run(["pytest", "-x", "-q"], capture_output=True, text=True)
        messages.append({"role": "tool", "tool_call_id": call.id, "content": (out.stdout + out.stderr)[-4000:]})

El bucle se limita a cinco rondas para evitar que un modelo confundido se ejecute indefinidamente. Mantén la salida de la herramienta breve, porque todo lo que devuelves se factura como entrada en la siguiente ronda. Limitarlo a los últimos 4.000 caracteres mantiene cada turno económico.

Lo que cuesta el trabajo de programación

Los prompts de programación son intensivos en entrada: pegas código y obtienes una respuesta más corta. Considera una solicitud de refactorización con 6.000 tokens de entrada y 1.500 tokens de salida a $0,15 y $0,50 por 1M:

• Entrada: 6.000 / 1.000.000 x $0,15 = $0,0009
• Salida: 1.500 / 1.000.000 x $0,50 = $0,00075
• Total: $0,00165 por petición

Mil de estas peticiones cuestan $1,65. El crédito de prueba de $0,50 cubre aproximadamente 303 de ellas, suficiente para ejecutar un benchmark de 20 tareas varias veces. Una GPU local puede ser más económica por petición a gran volumen, pero tiene un coste inicial y no se reduce a cero cuando no la estás usando. La página de precios tiene la tabla completa.

Configuraciones prácticas para generación de código

• Temperatura de 0,1 a 0,3. Los valores más bajos reducen las APIs inventadas y los cambios aleatorios de estilo.
• Fija una semilla cuando compares prompts, para que las diferencias provengan del prompt y no del muestreo.
• Indica la versión de Python y las bibliotecas en el mensaje del sistema: "Python 3.11, solo biblioteca estándar" elimina muchas suposiciones.
• Pide pruebas junto con el código. Un modelo que escribe sus propias pruebas a menudo detecta sus propios errores de off-by-one cuando las ejecutas.
• Envía el traceback de fallo, no una descripción del mismo.

Para probarlo, reclama el crédito de prueba en la página de la clave de API y luego sigue la guía rápida. Para uso tipo chat, consulta la guía de chat LLM sin censura. El servicio está destinado a uso adulto lícito y no genera contenido sexual que involucre a menores de edad.

Errores comunes con modelos de programación

• Importaciones y nombres de funciones inventados. Ejecuta el código. Un modelo puede describir un método de biblioteca que no existe, por lo que la prueba es el único juez.
• Sintaxis obsoleta. Si necesitas características modernas como coincidencia de patrones estructurales, indica la versión de Python en el prompt.
• Demasiado contexto. Una ventana más grande no significa que debas pegar todo. Envía los archivos importantes, junto con el error.
• Confiar en el código de seguridad generado. Revisa manualmente cualquier cosa que toque autenticación, cripto o análisis de entrada.
• Ejecución ciega de la salida. El código generado puede eliminar archivos o realizar llamadas de red. Usa un entorno aislado.

Más guías

• ¿Cuánto cuesta un LLM? Matemáticas por token y ejemplos
• Chat LLM sin censura: Guía de integración y casos de uso