ES ▾
Obtener clave de API

Mejor LLM para programación en Python: cómo elegir y probar uno

No hay un único LLM mejor para programar en Python, porque la respuesta depende de tus tareas, el tamaño de tu ventana de contexto y lo que estés dispuesto a pagar por petición. Este artículo te da los criterios, código funcional para tres flujos de trabajo de programación y un pequeño harness para comparar modelos con tu propio trabajo.

Actualizado

Flujos de datos isométricos pasando por un engranaje y emergiendo como bloques de código apilados, para programación en Python con una API LLM

Puntos clave

  • Los rankings públicos son un punto de partida. Una prueba de 50 tareas en tu propia base de código te dice más.
  • Para uso de API, verifica el tamaño de la ventana de contexto, llamadas a funciones, modo JSON, ajustes deterministas y precio por petición.
  • Esta API sirve un modelo de pesos abiertos con una ventana de 100.000 tokens, llamadas a funciones y modo JSON, a $0,15 y $0,50 por 1M de tokens.
  • Una ejecución de evaluación de 150 llamadas cuesta unos 5 centavos, así que medir es más barato que adivinar.

Por qué ningún modelo es el mejor para todos

La programación en Python cubre trabajos muy diferentes. Escribir un ayudante de diez líneas, refactorizar un módulo de 2.000 líneas, leer un stack trace, generar pruebas, traducir un script de shell a Python y construir una herramienta que edite archivos son todas tareas de programación, y un modelo puede ser bueno en una y mediocre en otra. Los rankings promedian muchas tareas y muchos lenguajes. Tu repositorio, tus reglas de estilo y tus bibliotecas son una porción estrecha de eso.

Así que la respuesta práctica a la pregunta es un procedimiento. Decide qué necesitas, selecciona dos o tres modelos que cumplan los requisitos técnicos, ejecuta las mismas tareas en cada uno y cuenta cuántos pasan tus propias pruebas. El resto de este artículo cubre los requisitos y luego muestra cómo hacer las pruebas contra esta API.

Un punto más antes de los detalles. El servicio detrás de este sitio ejecuta un modelo de pesos abiertos, operado por un proveedor independiente y ajustado para responder sin rechazos de contenido para uso adulto lícito. No es la API oficial de ningún proveedor de modelos y no hay afirmaciones de benchmarks aquí. Trátalo como un candidato más para tu lista corta y mídelo como a cualquier otro.

Los criterios que importan para una API

Si llamas a un modelo desde código en lugar de chatear con él en un editor, algunas propiedades técnicas deciden si se adapta.

CriterioPor qué importa para tareas en PythonEsta API
Ventana de contextoMódulos completos, tracebacks largos y salida de pruebas deben caber con espacio para la respuesta100.000 tokens, prompt más completación
Llamadas a funcionesPermite al modelo ejecutar código, pruebas y linters, y luego reaccionar a la salidaSí: herramientas, tool_choice, tool_calls en streaming
Modo JSONRevisiones, informes de lint y planes de refactorización legibles por máquinaSí: response_format json_object
RepetibilidadTemperatura más baja y una semilla fija hacen que las ejecuciones de prueba sean comparablestemperature, top_p, stop, seed y penalizaciones se pasan directamente
TransmisiónHerramientas responsivas y generaciones largasSSE con uso al final
PrecioLos bucles de agente reenvían el contexto muchas veces$0,15 de entrada y $0,50 de salida por 1M de tokens
RechazosHerramientas de seguridad, scrapers y scripts de red teaming para sistemas que posees son lícitos pero a menudo rechazadosAjustado para responder sin rechazos de contenido para uso adulto legal

La tabla no dice nada sobre la calidad del código, porque las propiedades anteriores son hechos y la calidad es algo que pruebas. La calidad también cambia con el prompt. Un mensaje de sistema que fije la versión de Python, las librerías permitidas y el formato de respuesta suele importar tanto como el modelo.

Esta API es solo de texto. Envías código como texto en el prompt y recibes texto de vuelta. No hay generación de imágenes, audio o video, ni embeddings ni fine-tuning, así que un sistema de búsqueda de código que necesite embeddings tiene que obtenerlos por otro lado.

Flujo de trabajo 1: generar una función con un prompt estricto

Comienza con el caso más simple: pide una función y extrae el bloque de código. Una temperatura baja produce resultados estables. El mensaje del sistema fija la versión de lenguaje y el formato de respuesta, lo que convierte la extracción en una expresión regular de una línea. Obtén una clave de API desde la página clave y expórtala como LLM_API_KEY.

import os
import re

from openai import OpenAI

client = OpenAI(
    base_url="https://api.visionllmapi.com/v1",
    api_key=os.environ["LLM_API_KEY"],
)


def ask_for_code(task):
    resp = client.chat.completions.create(
        model="uncensored",
        temperature=0.2,
        messages=[
            {
                "role": "system",
                "content": (
                    "You are a senior Python developer. Use Python 3.11, the standard "
                    "library only unless told otherwise, and type hints. Reply with one "
                    "fenced python block and at most three sentences of explanation."
                ),
            },
            {"role": "user", "content": task},
        ],
    )
    text = resp.choices[0].message.content
    match = re.search(r"```(?:python)?\n(.*?)```", text, re.S)
    return match.group(1) if match else text


print(ask_for_code("Write parse_duration(s) that turns '1h30m' or '45s' into seconds."))

Tres hábitos de prompt ayudan aquí. Nombra la versión de Python, para que el modelo no busque sintaxis que no puedas ejecutar. Di "solo librería estándar" a menos que realmente quieras paquetes de terceros. Y pide una respuesta corta, ya que las explicaciones largas cuestan tokens de salida y rara vez cambian el código. Si el modelo sigue añadiendo texto después del bloque, pasa una secuencia stop, o elimina todo lo que esté fuera de la valla como hace la expresión regular.

Flujo de trabajo 2: permitir que el modelo ejecute y corrija su propio código

El mayor salto en fiabilidad suele venir de las llamadas a funciones. En lugar de pedir código y esperar, le das al modelo una función que ejecuta un script y devuelve la salida. Escribe código, lo ejecuta, lee el traceback y se corrige. Los resultados de las herramientas se devuelven como mensajes con role: "tool", emparejados por tool_call_id.

import json
import os
import subprocess
import sys
import tempfile

from openai import OpenAI

client = OpenAI(
    base_url="https://api.visionllmapi.com/v1",
    api_key=os.environ["LLM_API_KEY"],
)


def run_python(code):
    with tempfile.NamedTemporaryFile("w", suffix=".py", delete=False) as f:
        f.write(code)
    try:
        r = subprocess.run([sys.executable, f.name], capture_output=True, text=True, timeout=10)
        return (r.stdout + r.stderr)[-3000:] or "(no output)"
    except subprocess.TimeoutExpired:
        return "timeout after 10 seconds"


tools = [{
    "type": "function",
    "function": {
        "name": "run_python",
        "description": "Run a Python script and return stdout and stderr.",
        "parameters": {
            "type": "object",
            "properties": {"code": {"type": "string"}},
            "required": ["code"],
        },
    },
}]

messages = [
    {"role": "system", "content": "You write Python 3. Test your code with run_python before the final answer."},
    {"role": "user", "content": "Write parse_duration(s) for strings like '1h30m' or '45s'. Include asserts."},
]

for _ in range(5):
    resp = client.chat.completions.create(
        model="uncensored",
        messages=messages,
        tools=tools,
        tool_choice="auto",
        temperature=0.2,
    )
    msg = resp.choices[0].message
    messages.append(msg.model_dump(exclude_none=True))
    if not msg.tool_calls:
        print(msg.content)
        break
    for call in msg.tool_calls:
        args = json.loads(call.function.arguments)
        messages.append({
            "role": "tool",
            "tool_call_id": call.id,
            "content": run_python(args["code"]),
        })

Trata la función run_python con cuidado. Ejecuta código escrito por el modelo, en tu máquina, con tus permisos. Para algo más que un experimento desechable, ejecútalo en un contenedor o una máquina virtual desechable, sin red, con un límite de tiempo y sin acceso a tus credenciales. El tiempo de espera de diez segundos y la salida recortada en el ejemplo son el mínimo.

El bucle se limita a cinco rondas para que un modelo confundido no gire indefinidamente. En la práctica, la mayoría de las funciones simples necesitan una o dos ejecuciones. Si ves que el modelo repite la misma llamada fallida, añade el traceback al siguiente mensaje de usuario en texto, o reduce la temperatura. Ten en cuenta que una petición de llamadas a funciones en streaming mantiene su slot de concurrencia hasta que termina el streaming, y una clave completa permite 8 peticiones simultáneas, por lo que un equipo que comparte una clave debe hacer cola para las ejecuciones de agentes.

Flujo de trabajo 3: revisión estructurada de código con modo JSON

Las revisiones son útiles cuando un script puede leerlas. El modo JSON fuerza JSON válido, y el system message define la forma. Con temperature 0 y una seed fija, el mismo archivo produce la misma revisión en ejecuciones repetidas, lo que hace que las diferencias entre ejecuciones tengan sentido.

import json
import os

from openai import OpenAI

client = OpenAI(
    base_url="https://api.visionllmapi.com/v1",
    api_key=os.environ["LLM_API_KEY"],
)

source = open("service.py").read()

resp = client.chat.completions.create(
    model="uncensored",
    response_format={"type": "json_object"},
    temperature=0,
    seed=7,
    messages=[
        {
            "role": "system",
            "content": (
                "Review the Python file. Reply with a JSON object with the key issues, "
                "a list of objects with keys line, severity (low, medium or high), "
                "problem and fix. Return an empty list if you find nothing."
            ),
        },
        {"role": "user", "content": source},
    ],
)

for issue in json.loads(resp.choices[0].message.content)["issues"]:
    print(issue["severity"], issue["line"], issue["problem"])

Usa esto desde un hook pre-commit o un paso de CI, e imprime el resultado como anotaciones. Espera falsos positivos y falsos negativos. Un revisor de código es una segunda pareja de ojos que es rápida y nunca se cansa, pero no reemplaza pruebas, un verificador de tipos o un linter. Ejecuta esos primero y usa el modelo para lo que ellos no pueden ver, como nombres poco claros, casos límite faltantes y manejo de errores que traga excepciones.

La ventana de 100,000 tokens permite archivos completos y, a veces, paquetes pequeños en una sola petición. El límite del cuerpo es de 8 MB, lo cual no alcanzarás con código fuente. Si una revisión se corta, comprueba si has establecido max_tokens demasiado bajo; el parámetro es opcional y una respuesta puede usar lo que quede de la ventana.

Prueba modelos en tus propias tareas

Aquí tienes un pequeño harness que hace lo que un ranking no puede: ejecuta tus tareas contra tus pruebas. Cada tarea tiene un prompt y un fragmento de prueba. El script pide código al modelo varias veces, añade la prueba al código, ejecuta el resultado y cuenta los éxitos. Cambia la base URL y el nombre del modelo para comparar otro proveedor de la misma manera.

import os
import re
import subprocess
import sys
import tempfile

from openai import OpenAI

client = OpenAI(
    base_url="https://api.visionllmapi.com/v1",
    api_key=os.environ["LLM_API_KEY"],
)

TASKS = [
    {
        "prompt": "Write is_palindrome(s) that ignores case and non-alphanumeric characters.",
        "test": "assert is_palindrome('A man, a plan, a canal: Panama')\nassert not is_palindrome('abc')",
    },
    {
        "prompt": "Write chunk(items, n) that yields lists of at most n items.",
        "test": "assert list(chunk([1,2,3,4,5], 2)) == [[1,2],[3,4],[5]]",
    },
]
SAMPLES = 3


def extract(text):
    m = re.search(r"```(?:python)?\n(.*?)```", text, re.S)
    return m.group(1) if m else text


def passes(code, test):
    with tempfile.NamedTemporaryFile("w", suffix=".py", delete=False) as f:
        f.write(code + "\n\n" + test + "\n")
    try:
        r = subprocess.run([sys.executable, f.name], capture_output=True, timeout=10)
        return r.returncode == 0
    except subprocess.TimeoutExpired:
        return False


total = ok = 0
for task in TASKS:
    for _ in range(SAMPLES):
        resp = client.chat.completions.create(
            model="uncensored",
            temperature=0.4,
            messages=[
                {"role": "system", "content": "Reply with one fenced python block and nothing else."},
                {"role": "user", "content": task["prompt"]},
            ],
        )
        total += 1
        ok += passes(extract(resp.choices[0].message.content), task["test"])

print(f"{ok}/{total} passed")

Amplía la lista de tareas a 30 o 50 elementos tomados del trabajo real: un error que corregiste el mes pasado, un analizador que escribiste, una función con un caso límite complicado. Incluye algunas tareas que otras herramientas rechazaron o fueron cautelosas al abordar. Ejecuta cada tarea de tres a cinco veces, porque una sola muestra dice poco. Registra la tasa de éxito, la longitud media de la salida y el coste por tarea, y guarda los resultados en un archivo para poder volver a ejecutarlos tras cambiar los prompts. Ejecuta el código generado en un sandbox, como se indicó anteriormente.

Mira los fallos, no solo el porcentaje. Si la mayoría de los fallos vienen de una biblioteca, añade una pista al system message. Si vienen del modelo inventando nombres de funciones, dale las firmas relevantes en el prompt. Si vienen de entradas largas, prueba un prompt más corto antes de culpar al modelo.

Cuánto cuesta el trabajo de programación

Los precios son $0,15 por 1M de tokens de entrada y $0,50 por 1M de tokens de salida, y las peticiones fallidas o rechazadas no se cobran. Tres ejemplos con los cálculos:

  • Ejecución de evaluación. 50 tareas x 3 muestras son 150 llamadas. Con 400 tokens de entrada y 600 de salida cada una, la entrada son 60.000 tokens ($0.009) y la salida son 90.000 tokens ($0.045). Total: $0.054.
  • Revisión de archivo. Un archivo de unas 600 líneas son aproximadamente 8.000 tokens, con una revisión de 1.200 tokens. La entrada cuesta $0,0012, la salida cuesta $0,0006, total $0,0018. Quinientas revisiones cuestan $0,90.
  • Bucle de agente. Una corrección con seis rondas que envía 18.000 tokens de entrada en total y recibe 1.500 tokens de salida cuesta $0.0027 más $0.00075, es decir, $0.00345.

Los bucles de agentes dominan porque cada ronda reenvía la conversación en crecimiento. Recorta la salida de las herramientas, como hace el ejemplo, y controlas la mayor parte de la factura. Las recargas son cualquier cantidad entera desde $20 hasta $500 con +5% desde $50, +10% desde $100 y +15% desde $200, pagadas en USDT en TRC20 o USDC en Base, sin caducidad en el crédito. Consulta precios. Las cuentas nuevas también pueden reclamar $0,50 de crédito de prueba con un solo clic, que financia algunas ejecuciones de evaluación. Una clave de prueba permite 2 peticiones simultáneas y 60 por minuto.

Cuando otra opción es mejor

Sé honesto sobre los límites de cualquier endpoint único. Si quieres un plugin de editor con completado en línea, un agente de programación creado por el proveedor o una integración estrecha con las herramientas de una nube, un producto creado para ese propósito puede convenirte mejor, y deberías consultar sus precios y términos actuales. Si tu código nunca activa un rechazo, el comportamiento de rechazo de este modelo no te da ninguna ventaja, y los resultados de tus pruebas deben decidir. Si necesitas embeddings o entrada de imagen, necesitas otro servicio para esas partes. Esta API es una buena opción cuando quieres un endpoint compatible con OpenAI que puedas llamar desde scripts y herramientas, con una ventana grande, llamadas a funciones y un precio bajo. La documentación de API lista el conjunto completo de parámetros.

02

Preguntas y respuestas

¿Es este el modelo adecuado para Python?

Ningún modelo único es el mejor para todas las tareas. Esta API ofrece un modelo de pesos abiertos con llamadas a funciones, modo JSON y una ventana de 100.000 tokens, y el marco anterior te permite medirlo contra tus propias pruebas.

¿Puede el modelo ejecutar mi código Python?

No por sí solo. Defines una herramienta, como run_python, y tu código la ejecuta y devuelve la salida como un mensaje de herramienta. Ejecútalo en un entorno aislado.

¿Qué tamaño de base de código cabe en una petición?

La ventana es de 100.000 tokens para el prompt más la respuesta. Eso cubre muchos archivos a la vez, pero no un repositorio grande entero.

¿Funciona con el paquete Python de OpenAI?

Sí. Establece base_url a la URL de la API, pasa tu clave y usa el ID de modelo uncensored.

¿Cuánto cuesta una ejecución de prueba?

Una ejecución de 150 llamadas de codificación de 400 tokens de entrada y 600 tokens de salida cada una cuesta unos $0.054.

Tu clave está a un formulario de distancia

Crea una cuenta, copia la clave, cambia la URL base. Esa es toda la configuración.

URL basehttps://api.visionllmapi.com/v1

Obtener clave de API