Ollama para Programación

Qué cubre este artículo sobre Ollama y programación

• Qué modelos funcionan bien para generar código.
• Cómo conectar Ollama con editores e IDEs.
• Consejos para escribir prompts de tareas de programación.
• FIM y Fill-In-the-Middle para autocompletado.
• Casos de uso como refactoring, tests y explicaciones.

Introducción: Ollama para programación

Los asistentes de programación locales hoy en día son muy prácticos con Ollama. Los modelos especializados en código pueden generar funciones, explicar código, encontrar errores, sugerir refactorings y escribir tests. Como todo funciona localmente, tu código fuente permanece en tu entorno. Esto es especialmente importante para código comercial o sensible.

Este artículo muestra qué modelos de Ollama son adecuados para programación, cómo configurarlos y cómo usarlos de forma efectiva.

Términos clave

• Modelo de código: Modelo de lenguaje especializado en código de programación.
• FIM: Fill-In-the-Middle, rellenar huecos en código.
• Completion: Autocompletado de código.
• Refactoring: Mejorar código sin cambiar su comportamiento.
• Unit-Test: Prueba pequeña para una función individual.
• Prompt Engineering: Formulación dirigida de tareas.
• IDE: Entorno de desarrollo integrado.

Modelos recomendados

Para programación, estos modelos funcionan bien:

• qwen2.5-coder: Modelo fuerte para código, buen soporte en español.
• codellama: Variantes optimizadas para código basadas en Llama.
• codegemma: Modelos pequeños y rápidos de Google.
• starcoder2: Especializado en código fuente.
• deepseek-coder: Buen rendimiento en modelos más grandes.

Descarga:

ollama pull qwen2.5-coder:14b
ollama pull codellama:13b

Integración con la IDE

Continue

Continue es una extensión popular para VS Code y JetBrains que puede conectarse a Ollama:

{
  "models": [
    {
      "title": "Ollama Qwen",
      "model": "qwen2.5-coder:14b",
      "provider": "ollama"
    }
  ]
}

Open WebUI para programación

Open WebUI también funciona con modelos de código de Ollama. Es especialmente práctica para explicaciones más largas o refactorings.

Prompts para programación

Los buenos prompts son concretos y contienen contexto:

Escribir una función

Escribe una función Python que ordene una lista de números y devuelva los 10 valores más grandes.

Explicar código

Explica este código en tres oraciones:

```python
def fibonacci(n):
    a, b = 0, 1
    for _ in range(n):
        a, b = b, a + b
    return a

### Refactoring

```text
Refactoriza este código para que sea más legible y menos propenso a errores.

Escribir tests

Escribe tests unitarios para la siguiente función usando pytest.

FIM y Fill-In-the-Middle

Algunos modelos soportan FIM para completar código en un lugar específico. Esto es útil para autocompletado en la IDE. La solicitud contiene prefijo y sufijo:

<FIM_PREFIX>
def greet(name):
    print(<FIM_SUFFIX>)
<FIM_MIDDLE>

No todos los modelos soportan FIM nativamente. La extensión de la IDE también debe tener este soporte.

Flujos de trabajo útiles

1. Autocompletado de código: El modelo complementa líneas abiertas.
2. Generación de funciones: Prompt con entradas, salidas y ejemplos.
3. Explicación: Comprender secciones de código complejo.
4. Refactoring: Mejorar la calidad del código.
5. Tests: Generar casos de prueba automáticamente.
6. Documentación: Escribir comentarios y docstrings.

Consejos para mejores resultados

• Menciona el lenguaje de programación específico.
• Proporciona entradas, salidas y ejemplos.
• Indica las librerías y convenciones deseadas.
• Incluye contexto de archivos cuando sea posible.
• Usa modelos más grandes para tareas complejas.
• Siempre revisa manualmente el código generado.

Trampas comunes

• Modelo inadecuado: Los modelos de chat general suelen ser peores que modelos especializados en código.
• Contexto insuficiente: El modelo no conoce el archivo.
• FIM no soportado: Falta en el modelo o la IDE.
• Calidad del código: El código generado debe ser revisado.
• Brechas de seguridad: El código generado puede tener errores o ser inseguro.
• Inferencia lenta: Los modelos grandes requieren más VRAM.

Enlaces y recursos adicionales

• BotServ.de Comandos Ollama
• BotServ.de Rendimiento Ollama
• BotServ.de Ciclo de vida de modelos Ollama
• BotServ.de Continue
• BotServ.de Modelos locales de programación

FAQ: Ollama para programación

¿Cuál es el mejor modelo para programación? qwen2.5-coder y codellama son buenos modelos para empezar.

¿Puedo usar Ollama en VS Code? Sí, a través de extensiones como Continue.

¿Es seguro el código generado? No, siempre revisa y prueba el código generado.

¿Qué tamaño debe tener el modelo? Modelos de 13B a 34B ofrecen buenos resultados para programación. Modelos más pequeños son suficientes para tareas simples.

¿Qué es FIM? Fill-In-the-Middle, una técnica para completar huecos en código.

Fuentes y referencias

• Qwen2.5 Coder: https://qwenlm.github.io/
• Code Llama: https://ai.meta.com/blog/code-llama-large-language-models-coding/
• Continue: https://continue.dev/

Resumen: Ollama para programación

Ollama es excelente para ejecutar asistentes de programación locales. Modelos especializados en código como qwen2.5-coder o codellama ofrecen buenos resultados para generación de código, explicaciones, refactoring y tests. Con extensiones como Continue, puedes integrar Ollama directamente en tu IDE. Lo importante es usar prompts concretos, proporcionar suficiente contexto y revisar manualmente el código generado. Si lo usas correctamente, obtendrás un asistente respetuoso con la privacidad que puede mejorar significativamente tu flujo de trabajo.