DSPy es un framework de Python que trata las llamadas a un modelo de lenguaje como si fueran código: declaras qué entra y qué sale, y un optimizador escribe los prompts por ti. Salió del grupo de PLN de Stanford y su promesa es dejar de pelearte con cadenas de texto frágiles para pasar a programar sistemas de IA que se compilan y mejoran solos. En esta guía verás qué es DSPy, sus tres piezas (firmas, módulos y optimizadores), por qué conviene compilar en vez de escribir prompts a mano, un ejemplo con métricas y cuándo compensa de verdad. La misma explicación está disponible en inglés.

Puntos clave

  • DSPy es un framework de código abierto (licencia MIT) del grupo de PLN de Stanford; supera las 36 200 estrellas en GitHub y va por la versión 3.2.1, publicada el 5 de mayo de 2026. Requiere Python 3.10 o superior.
  • Su idea central: no escribes prompts, escribes firmas (qué entra y qué sale) y módulos (cómo razona el modelo). Un optimizador genera y afina los prompts a partir de ejemplos y una métrica.
  • El artículo fundacional (arXiv:2310.03714, Khattab et al., 2023) mide mejoras de más del 25 % sobre GPT-3.5 y de en torno al 65 % sobre Llama 2 13B frente al prompting few-shot habitual.
  • Trae varios optimizadores: BootstrapFewShot, MIPROv2 (afina instrucciones y ejemplos con búsqueda bayesiana) y GEPA, que evoluciona los prompts leyendo las trazas de ejecución.
  • Es agnóstico del proveedor: por debajo usa LiteLLM, así que el mismo programa corre con OpenAI, Anthropic, Gemini o modelos que ejecutes en tu propia máquina con Ollama.

¿Qué es DSPy?

DSPy es un framework de Python para construir sistemas de IA en los que el modelo de lenguaje es un componente más, no el centro de todo. En lugar de redactar un prompt largo y rezar para que funcione, describes tu tarea como una firma con entradas y salidas tipadas, y dejas que el framework se encargue de convertir esa declaración en instrucciones concretas para el modelo. El nombre viene de «Declarative Self-improving Python».

El proyecto nació en el grupo de procesamiento de lenguaje natural de Stanford, de la mano de Omar Khattab, y es software libre bajo licencia MIT. Ha tenido una acogida notable: reúne más de 36 200 estrellas en GitHub y va por la versión 3.2.1, publicada el 5 de mayo de 2026. Se instala con una sola orden y requiere Python 3.10 o superior:

pip install dspy

La documentación oficial lo resume así: «Expresa tus tareas como firmas estructuradas, no como prompts, para producir programas mantenibles, modulares y optimizables». Esa es la diferencia de fondo con construir un agente a mano con el SDK del proveedor: en DSPy el prompt deja de ser texto que escribes tú y pasa a ser un artefacto que el framework genera y mejora.

Firmas, módulos y optimizadores

DSPy se apoya en tres abstracciones que conviene tener claras desde el principio.

Una firma (Signature) declara qué recibe y qué devuelve el modelo. Puede ser tan corta como una cadena, "pregunta -> respuesta", o una clase con campos tipados cuando necesitas más control:

import dspy

class Clasificar(dspy.Signature):
    """Clasifica el sentimiento de una frase."""
    frase: str = dspy.InputField()
    sentimiento: str = dspy.OutputField()

Un módulo decide cómo razona el modelo sobre esa firma, sin que tengas que reescribir la tarea. dspy.Predict pide la respuesta directa; dspy.ChainOfThought fuerza un razonamiento paso a paso; dspy.ReAct añade herramientas y un bucle de acción. Cambiar de estrategia es sustituir una clase por otra, igual que en LangGraph cambias la topología del grafo sin tocar los nodos.

Y un optimizador (antes llamado teleprompter) es la pieza que da nombre al framework: recibe tu programa, un puñado de ejemplos y una métrica, y busca los prompts y los ejemplos few-shot que maximizan esa métrica. Los más usados son BootstrapFewShot (genera demostraciones a partir del propio modelo), MIPROv2 (afina las instrucciones y los ejemplos con búsqueda bayesiana) y GEPA, del que hablamos más abajo.

Compilar en vez de escribir prompts a mano

Aquí está el cambio de mentalidad. Con la forma tradicional escribes un prompt, lo pruebas, ves que falla en un caso raro, lo retocas, se rompe otro, y así en un bucle manual que no escala. DSPy sustituye ese trabajo artesanal por una compilación: tú defines la lógica una vez y el optimizador se encarga de redactar y ajustar los prompts.

La configuración del modelo se hace una sola vez y vale para todo el programa, porque por debajo DSPy usa LiteLLM y habla con cualquier proveedor:

import dspy

lm = dspy.LM("openai/gpt-4o-mini")
dspy.configure(lm=lm)

razonar = dspy.ChainOfThought("pregunta -> respuesta")
salida = razonar(pregunta="Cuantos lados tiene un hexagono?")
print(salida.respuesta)

La ventaja no es solo comodidad. Cuando cambias de modelo (de GPT-4o a Claude, o a uno que sirves con vLLM en tu propia infraestructura), no reescribes prompts: vuelves a compilar y el optimizador adapta las instrucciones al modelo nuevo. El artículo fundacional (arXiv:2310.03714) cuantifica lo que se gana: las tuberías compiladas superan al prompting few-shot habitual en más del 25 % con GPT-3.5 y en torno al 65 % con Llama 2 13B, y baten incluso a los ejemplos escritos por expertos.

Un ejemplo con métricas

El optimizador necesita dos cosas: ejemplos de entrenamiento y una métrica, una función de Python que puntúa si una predicción es buena. Los ejemplos se envuelven en dspy.Example y se marca cuáles son las entradas con with_inputs. La métrica es tan simple como comparar la respuesta esperada con la del modelo:

trainset = [
    dspy.Example(pregunta="Capital de Francia?", respuesta="Paris").with_inputs("pregunta"),
    dspy.Example(pregunta="Capital de Japon?", respuesta="Tokio").with_inputs("pregunta"),
]

def acierto(ejemplo, prediccion, trace=None):
    return ejemplo.respuesta.lower() == prediccion.respuesta.lower()

optimizador = dspy.MIPROv2(metric=acierto, auto="light")
compilado = optimizador.compile(razonar, trainset=trainset)
compilado.save("programa.json")

Al llamar a compile, MIPROv2 propone varias instrucciones, prueba distintas combinaciones de ejemplos few-shot y se queda con la que mejor puntúa según tu métrica. El resultado se guarda en un JSON que puedes cargar en producción. La métrica es el corazón del sistema: define qué significa «bueno» para tu tarea, y por eso conviene invertir tiempo en ella igual que harías al evaluar salidas estructuradas o al medir la calidad de un agente. Sin una métrica honesta, el optimizador afina hacia el objetivo equivocado.

GEPA (Genetic-Pareto) es el optimizador más reciente y funciona distinto: en vez de una recompensa numérica, lee las trazas de ejecución, diagnostica los fallos en lenguaje natural y mantiene un frente de Pareto de prompts diversos. Su artículo (Agrawal et al., ICLR 2026) afirma que mejora a MIPROv2 en torno a un 13 % de media, y frente a métodos de aprendizaje por refuerzo como GRPO la ventaja llega al 20 % usando hasta 35 veces menos ejecuciones en esa comparación.

¿Cuándo merece la pena DSPy?

DSPy brilla cuando tienes una tarea repetible, un conjunto de ejemplos y una forma clara de puntuar el resultado: clasificación, extracción de datos, preguntas y respuestas sobre documentos o cualquier tubería con varios pasos de modelo encadenados. En esos casos, compilar te ahorra el ajuste manual de prompts y te da un sistema que se readapta cuando cambias de modelo.

No es la herramienta ideal para todo. Si solo quieres una llamada suelta y conversacional a un modelo, montar firmas, métricas y un conjunto de entrenamiento es demasiada ceremonia. También tiene una curva de aprendizaje: piensas en programas y compilación, no en texto, y eso desconcierta al principio. Y depende de que puedas definir una métrica; si tu tarea es puramente subjetiva y no sabes puntuarla, el optimizador se queda sin norte. Para orquestar flujos complejos con estado, un framework como LangGraph sigue siendo complementario: DSPy optimiza cada llamada, el grafo coordina el conjunto. Si aún estás decidiendo qué es un agente de IA y qué necesitas, empieza por ahí antes de añadir optimización.

Preguntas frecuentes

¿DSPy sustituye por completo a escribir prompts?

No del todo. Sigues describiendo la tarea (la firma, las instrucciones de la clase, la métrica), pero dejas de redactar y retocar a mano el texto exacto que ve el modelo. DSPy genera ese texto por ti y lo afina con el optimizador. Piensa en ello como pasar de escribir ensamblador a escribir en un lenguaje de alto nivel: sigues programando, pero a otro nivel de abstracción.

¿Con qué modelos y proveedores funciona DSPy?

Con prácticamente todos, porque por debajo usa LiteLLM. Configuras el modelo una vez con dspy.LM("openai/gpt-4o-mini") o el identificador que toque, y el mismo programa funciona con OpenAI, Anthropic, Google Gemini, Mistral o modelos que ejecutes en tu propia máquina con Ollama o sirvas con vLLM. Cambiar de proveedor es cambiar una línea y volver a compilar.

¿Qué diferencia hay entre MIPROv2 y GEPA?

MIPROv2 optimiza instrucciones y ejemplos few-shot mediante búsqueda bayesiana guiada por una métrica numérica. GEPA no usa una recompensa escalar: lee las trazas de ejecución, describe en lenguaje natural por qué falló cada caso y evoluciona los prompts manteniendo un frente de Pareto. Según su artículo de 2026, GEPA mejora a MIPROv2 en torno a un 13 % de media, y frente a métodos de refuerzo como GRPO la ventaja llega al 20 % con hasta 35 veces menos ejecuciones, así que compensa cuando cada llamada al modelo es cara o el presupuesto de pruebas es limitado.

Conclusión

DSPy propone un cambio de fondo: tratar los prompts como un artefacto compilado y no como texto que ajustas a mano una y otra vez. Con tres piezas (firmas, módulos y optimizadores) describes qué quieres y dejas que un optimizador como MIPROv2 o GEPA escriba las instrucciones a partir de tus ejemplos y tu métrica. En la versión 3.2.1, con licencia MIT y más de 36 200 estrellas, es una de las apuestas más sólidas para llevar tus sistemas de LLM de la artesanía a la ingeniería. El siguiente paso es instalarlo con pip install dspy, definir tu primera firma y compilar un módulo sencillo con una métrica de acierto sobre media docena de ejemplos.

Fuentes: [1] Documentación oficial de DSPy[1], [2] DSPy en GitHub[2], [3] Artículo fundacional en arXiv[3], [4] Paquete dspy en PyPI[4], [5] Análisis de los optimizadores de DSPy en Future AGI[5].

Visitas: 1

Fuentes

  1. Documentación oficial de DSPy
  2. DSPy en GitHub
  3. Artículo fundacional en arXiv
  4. Paquete dspy en PyPI
  5. Análisis de los optimizadores de DSPy en Future AGI

Ruta: Modelos agénticos self-hosted y tool calling