Tuberías de código automatizadas
En esta página
- Automatización del desarrollo con Codestral y un modelo de propósito general
- Arquitectura de una tubería de código
- Paso 1: Búsqueda de código con Codestral Embed
- Paso 2: Generación de código con Codestral
- Paso 3: Revisión de código con Mistral Small 4
- Tubería completa: de la incidencia al PR
- Integración con CI/CD
- Variaciones comunes en producción
- Puntos clave
Lección actualizada el 2 de noviembre de 2026. El paso de revisión dependía anteriormente de Devstral, que se eliminó de la API el 31 de julio de 2026. Ahora utiliza Mistral Small 4 (
mistral-small-2603). Fuente: Modelos.
Automatización del desarrollo con Codestral y un modelo de propósito general
Hasta ahora, hemos presentado cada herramienta de Mistral AI por separado, operando frente a un usuario humano. Su verdadero valor surge cuando las encadenas. Codestral Embed, Codestral y un modelo de propósito general como Mistral Small 4 forman una tubería de desarrollo automatizada capaz de buscar, generar y revisar código sin intervención manual en cada paso.
Arquitectura de una tubería de código
Una tubería completa se divide en tres etapas, cada una asignada al modelo que sobresale en esa tarea específica.
- Búsqueda de código: encontrar código relevante en la base de código (Codestral Embed).
- Generación de código: generar o modificar código (Codestral).
- Revisión de código: verificar y validar los cambios (Mistral Small 4).
Lee el flujo de datos de arriba a abajo; cada bloque consume la salida del anterior.
Solicitud del usuario
|
[Codestral Embed] -> Archivos relevantes
|
[Codestral] -> Código generado/modificado
|
[Mistral Small 4] -> Revisión automatizada
|
Pull Request / Commit
Paso 1: Búsqueda de código con Codestral Embed
Generar código sin conocimiento de la base de código existente produce resultados que no se parecen en nada al resto del proyecto. Por tanto, el primer paso es localizar los archivos relevantes utilizando el índice de incrustaciones creado en la lección anterior. La función siguiente convierte la descripción de la tarea en un vector, lo compara con cada archivo indexado y devuelve las cinco coincidencias más cercanas.
from mistralai.client import Mistral
import numpy as np
client = Mistral(api_key=os.environ["MISTRAL_API_KEY"])
def search_context(task_description: str, codebase_index: list) -> list:
"""Encuentra archivos relevantes para una tarea dada."""
response = client.embeddings.create(
model="codestral-embed-latest",
inputs=[task_description],
)
vector = np.array(response.data[0].embedding)
scores = []
for file in codebase_index:
file_vec = np.array(file["embedding"])
score = np.dot(vector, file_vec) / (
np.linalg.norm(vector) * np.linalg.norm(file_vec)
)
scores.append((file, score))
scores.sort(key=lambda x: x[1], reverse=True)
return [f for f, s in scores[:5]]
Paso 2: Generación de código con Codestral
Una vez que tienes el contexto, Codestral puede generar código. La calidad de la salida depende de cómo presentes ese contexto: concatena los archivos recuperados en el mensaje del sistema, acompañado de una instrucción explícita para respetar las convenciones existentes. Establecer temperature=0.1 mantiene la salida cerca de lo determinista, algo deseable cuando el código generado debe integrarse perfectamente en un proyecto en lugar de sorprender a su autor.
def generate_code(task: str, context: list[dict]) -> str:
"""Genera código teniendo en cuenta el contexto existente."""
context_files = "\n\n---\n\n".join([
f"# {f['path']}\n{f['content']}"
for f in context
])
response = client.chat.complete(
model="codestral-latest",
messages=[
{
"role": "system",
"content": f"""Eres un desarrollador senior. Aquí tienes el código existente del proyecto:
{context_files}
Respeta las convenciones de código existentes (nomenclatura, estilo, patrones)."""
},
{
"role": "user",
"content": task
}
],
temperature=0.1,
max_tokens=2000,
)
return response.choices[0].message.content
Paso 3: Revisión de código con Mistral Small 4
El control llega al final. Mistral Small 4 recibe el estado anterior, el estado posterior y la descripción de la tarea, y luego emite su veredicto en un formato JSON estricto. Esta elección es crítica: las revisiones en prosa libre no son utilizables por el código posterior, mientras que un campo booleano approved permite automatizar los siguientes pasos. Las categorías solicitadas separan deliberadamente los problemas bloqueantes, las sugerencias de mejora y las preocupaciones de seguridad, ya que requieren un tratamiento diferente.
def review_code(original_code: str, modified_code: str, description: str) -> dict:
"""Revisión automatizada de código."""
response = client.chat.complete(
model="mistral-small-2603",
messages=[
{
"role": "system",
"content": """Eres un revisor de código senior. Analiza el diff y devuelve JSON:
{
"approved": true/false,
"issues": ["lista de problemas encontrados"],
"suggestions": ["lista de posibles mejoras"],
"security": ["posibles problemas de seguridad"]
}"""
},
{
"role": "user",
"content": f"Tarea: {description}\n\nCódigo original:\n{original_code}\n\nCódigo modificado:\n{modified_code}"
}
],
temperature=0,
)
return response.choices[0].message.content
Tubería completa: de la incidencia al PR
Ahora puedes ensamblar estas tres funciones en una única cadena que comienza con una incidencia y produce código revisado. Mantén las sentencias print intercaladas: en una tubería automatizada, registrar lo que se ha encontrado, generado y revisado es tu única forma de entender más tarde por qué un resultado te ha decepcionado.
def ticket_to_code_pipeline(ticket: str, codebase_index: list) -> dict:
"""Tubería completa: incidencia -> código -> revisión."""
# 1. Búsqueda contextual
relevant_files = search_context(ticket, codebase_index)
print(f"Archivos encontrados: {[f['path'] for f in relevant_files]}")
# 2. Generación de código
generated_code = generate_code(ticket, relevant_files)
print(f"Código generado: {len(generated_code)} caracteres")
# 3. Revisión automatizada
review = review_code(
original_code=relevant_files[0]["content"],
modified_code=generated_code,
description=ticket,
)
print(f"Revisión: {review}")
return {
"ticket": ticket,
"modified_files": relevant_files,
"code": generated_code,
"review": review,
}
Integración con CI/CD
Este mecanismo alcanza su máximo potencial cuando se conecta a tu CI. Un flujo de trabajo de GitHub Actions activado en cada apertura y actualización de pull request es suficiente para ejecutar la revisión en cada cambio propuesto, sin necesidad de intervención humana.
name: Revisión de código con IA
on:
pull_request:
types: [opened, synchronize]
jobs:
ai-review:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v4
- name: Ejecutar revisión con IA
env:
MISTRAL_API_KEY: ${{ secrets.MISTRAL_API_KEY }}
run: |
python scripts/ai_review.py --pr ${{ github.event.pull_request.number }}
El script llamado recupera el diff, pasa cada archivo modificado a review_code y comenta el PR solo cuando la revisión no lo aprueba. Esta condición es esencial: un bot que comenta en todo se convierte en ruido que el equipo aprende a ignorar en pocos días.
# scripts/ai_review.py
def review_pull_request(pr_number: int):
"""Revisión automatizada de PR con Mistral Small 4."""
# 1. Recuperar el diff del PR
diff = get_pr_diff(pr_number)
# 2. Analizar cada archivo modificado
for file in diff.files:
review = review_code(
original_code=file.before,
modified_code=file.after,
description=diff.title,
)
# 3. Publicar comentario en el PR
if not review["approved"]:
post_pr_comment(pr_number, file.path, review)
Variaciones comunes en producción
Los equipos que adoptan este patrón lo adaptan a varios casos de uso recurrentes. Primero, la generación automática de pruebas: para cada nuevo archivo, la tubería produce las pruebas correspondientes, desplazando la carga sin eliminar la revisión. Luego, la documentación continua, donde los docstrings se generan y actualizan con cada commit en lugar de durante una auditoría. Después, la detección de regresiones, donde el modelo de revisión analiza los diffs en busca de efectos secundarios probables. Finalmente, la migración de código, que automatiza la conversión entre frameworks o versiones; aquí es donde el ahorro de tiempo es más significativo, porque la transformación es repetitiva y el resultado es verificable mediante pruebas existentes.
Una advertencia se aplica a los cuatro casos: la revisión automatizada no sustituye a la revisión humana. Detecta despistes mecánicos y deja el juicio sobre lo que realmente importa en manos de tus desarrolladores.
Puntos clave
- Una tubería de código con IA combina búsqueda (Embed), generación (Codestral) y revisión (Mistral Small 4).
- Codestral Embed encuentra el contexto, Codestral genera y un modelo de propósito general verifica.
- La integración con CI/CD permite revisiones automatizadas y generación de pruebas.
- El patrón buscar -> generar -> revisar se aplica a muchos flujos de trabajo.
- La revisión automatizada no sustituye a la revisión humana; la complementa.