Ir al contenido principal
Español— Elegir un idioma
Menú

Casos de uso de Codestral

Lección 4 de 14 Actualizado el 2 de noviembre de 2026 Desarrollador
En esta página
  1. Los cuatro pilares del uso de Codestral
  2. Autocompletado en tiempo real en el IDE
  3. Generación completa de código
  4. Documentación automática
  5. Generación de pruebas unitarias
  6. Resumen de casos de uso
  7. Puntos clave

Los cuatro pilares del uso de Codestral

Reducir Codestral a una simple herramienta de autocompletado supone ignorar la mitad de su valor. Sus capacidades abarcan cuatro áreas clave del desarrollo de software: autocompletado en el IDE, generación de código, documentación automática y producción de pruebas. Cada área requiere configuraciones específicas. Distinguir claramente entre ellas evita los resultados decepcionantes de utilizar «el mismo prompt para todo».

Autocompletado en tiempo real en el IDE

Este es el caso de uso más natural del modelo y el que mejor aprovecha la función de relleno en medio del contexto (Fill-in-the-Middle, FIM). El escenario es siempre el mismo: escribes en VS Code o en un IDE de JetBrains, una extensión como Continue.dev o Tabnine detecta una pausa en tu tecleo, envía una solicitud FIM que contiene el contexto del archivo, recibe una sugerencia en menos de 500 ms y tú la aceptas con la tecla Tab o la rechazas con Esc. Todo el reto reside en ese presupuesto de 500 ms: si se supera, la sugerencia llega cuando ya has escrito la línea manualmente, convirtiendo la ayuda en una molestia.

La palanca principal es el tamaño del contexto enviado. Cuanto más proporciones, mejor será la relevancia, pero más lenta será la respuesta.

# Configuración optimizada para autocompletado
response = client.fim.complete(
    model="codestral-latest",
    prompt=context_before_cursor[-2000:],   # Limitar contexto
    suffix=context_after_cursor[:500],      # Sufijo corto
    temperature=0,
    max_tokens=80,                            # Finalizaciones cortas
    stop=["\n\n", "\ndef ", "\nclass "],
)

En la práctica, 2.000 caracteres para el prompt y 500 para el sufijo ofrecen una excelente relación calidad-velocidad. Observa la asimetría: mantenemos los últimos caracteres antes del cursor y los primeros después de él, porque la relevancia disminuye a medida que nos alejamos del punto de inserción.

Generación completa de código

Cuando necesitas una función, una clase o un módulo entero, el endpoint de chat resulta más adecuado. La calidad del resultado depende entonces directamente de la precisión de tu solicitud: una especificación explícita con restricciones técnicas enumeradas produce código utilizable; una solicitud vaga genera un esqueleto que tendrás que reescribir por completo.

response = client.chat.complete(
    model="codestral-latest",
    messages=[
        {
            "role": "system",
            "content": "Experto en Python. Código limpio, tipado y con gestión de errores."
        },
        {
            "role": "user",
            "content": """Crea una clase `CacheManager` en Python con:
            - Una caché LRU en memoria con TTL configurable
            - Métodos get, set, delete y clear
            - Un decorador @cached para funciones
            - Seguridad de hilos mediante threading.Lock"""
        }
    ],
    temperature=0.2,
    max_tokens=1500,
)

Este flujo de trabajo destaca en cuatro escenarios: iniciar un nuevo archivo o módulo vacío, implementar un algoritmo complejo descrito en lenguaje natural, crear rápidamente un prototipo de API o servicio para probar su estructura y convertir pseudocódigo en código funcional. El denominador común es la ausencia de código existente que deba respetarse. En cuanto interviene código existente, FIM vuelve a ser preferible.

Documentación automática

La documentación es la tarea que los equipos posponen hasta el día siguiente, pero Codestral la resuelve en segundos. Toma una función sin documentar con cuatro parámetros y comportamiento condicional en la cabecera:

code = """
def parse_csv_to_dict(filepath, delimiter=',', encoding='utf-8', skip_header=False):
    results = []
    with open(filepath, 'r', encoding=encoding) as f:
        reader = csv.reader(f, delimiter=delimiter)
        if skip_header:
            headers = next(reader)
        else:
            headers = [f'col_{i}' for i in range(len(next(reader)))]
        for row in reader:
            results.append(dict(zip(headers, row)))
    return results
"""

response = client.chat.complete(
    model="codestral-latest",
    messages=[
        {
            "role": "user",
            "content": f"Añade una docstring completa al estilo de Google a esta función:\n\n{code}"
        }
    ],
    temperature=0,
)

La docstring generada describe cada parámetro, su valor por defecto y la estructura devuelta. El mismo mecanismo, con una instrucción diferente, añade comentarios a las líneas que lo merecen; en este caso, la rama else que fabrica nombres de columna artificiales, lo cual podría sorprender al siguiente lector.

response = client.chat.complete(
    model="codestral-latest",
    messages=[
        {
            "role": "user",
            "content": f"Añade comentarios explicativos a las líneas complejas de este código:\n\n{code}"
        }
    ],
    temperature=0,
)

Mantén temperature=0 para ambas tareas: estás documentando lo que existe, no inventando nada.

Generación de pruebas unitarias

Codestral genera pruebas a partir del código fuente, y aquí es donde suele ahorrar más tiempo, ya que los casos límite son precisamente lo que un desarrollador con prisas olvida.

function_to_test = """
def validate_email(email: str) -> bool:
    import re
    pattern = r'^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$'
    return bool(re.match(pattern, email))
"""

response = client.chat.complete(
    model="codestral-latest",
    messages=[
        {
            "role": "system",
            "content": "Genera pruebas pytest exhaustivas. Incluye casos límite y casos de error."
        },
        {
            "role": "user",
            "content": f"Genera pruebas para esta función:\n\n{function_to_test}"
        }
    ],
    temperature=0.1,
    max_tokens=1000,
)

La cobertura resultante se divide en cuatro familias. Los casos nominales verifican direcciones válidas. Los casos límite llevan el formato al extremo con dominios largos o caracteres especiales permitidos. Los casos de error cubren formatos inválidos, cadenas vacías y None. Por último, los casos de regresión revisan lo que ha fallado en otros lugares: subdominios y TLD recientes. Revisa siempre estas pruebas antes de confirmarlas: una prueba generada a partir de código con errores documenta fielmente el error.

Resumen de casos de uso

Caso de usoEndpointTemperaturaMáx. tokens
Autocompletado en IDEFIM050-100
Generación de funcionesChat0,2500-1500
Docstrings / ComentariosChat0300-500
Pruebas unitariasChat0,1800-1500
RefactorizaciónChat01000-2000
Conversión de lenguajeChat01000-2000

Puntos clave

  • El autocompletado en el IDE utiliza FIM con parámetros optimizados para la latencia
  • La generación completa de código usa el endpoint de chat con un prompt estructurado
  • Codestral genera docstrings y comentarios de calidad profesional
  • La generación de pruebas cubre automáticamente casos límite y escenarios de error
  • Cada caso de uso tiene configuraciones óptimas de temperatura y tokens