DSPy: Ingeniería de prompts programática

Qué cubre este artículo

• Qué es DSPy y cómo transforma la ingeniería de prompts.
• Signatures, Modules y Teleprompters como conceptos centrales.
• Cómo construir predicciones simples y flujos de razonamiento paso a paso.
• Creación de un programa RAG con DSPy.
• Optimización automática de prompts mediante ejemplos.
• Errores comunes y obstáculos al trabajar con DSPy.

Introducción

DSPy es un framework de Python para la llamada ingeniería de prompts programática. En lugar de escribir prompts a mano e iterar dolorosamente, defines qué debe hacer un modelo y dejas que DSPy encuentre los mejores prompts y ejemplos de pocas instancias. La gran diferencia respecto al enfoque tradicional: optimizas programas, no cadenas de prompts individuales.

El framework fue desarrollado por el Stanford NLP Group y está dirigido a usuarios avanzados. Integra modelos de lenguaje, retrieval y optimización en una estructura común. Si estás familiarizado con LangChain, LlamaIndex o Haystack, reconocerás muchos patrones, aunque con un enfoque más fuerte en optimización automática.

¿Por qué necesito DSPy?

La ingeniería de prompts consume tiempo. Un pequeño cambio en el prompt puede tener grandes repercusiones en la salida. Con varios modelos y tareas, pierdes fácilmente el control. DSPy separa la tarea deseada, es decir, la firma, del prompt concreto. Describes entradas y salidas, y DSPy busca la mejor formulación.

Esto hace que tu código sea más mantenible. Si cambias de modelo, no necesitas reescribir el prompt completamente. DSPy adapta el prompt y los ejemplos al nuevo modelo. Esto es especialmente valioso para sistemas RAG complejos, agentes o pipelines de preguntas y respuestas.

DSPy en pocas palabras

DSPy se basa en cuatro pilares:

• Signature: Una especie de contrato que describe entradas, salidas y la tarea.
• Module: Bloques reutilizables como Predict, ChainOfThought o ReAct.
• Programa: Una cadena de módulos que juntos resuelven una tarea.
• Teleprompter: Un optimizador que ajusta prompts y ejemplos de pocas instancias automáticamente.
• LM: El modelo de lenguaje que DSPy usa para las llamadas.
• RM: Un modelo de retrieval que proporciona documentos de contexto.

La firma es la idea central. Describe qué recibe el modelo y qué debe devolver. A partir de la firma, DSPy genera el prompt apropiado. Puedes sobrescribir el prompt manualmente, pero no es necesario.

¿Para quién está pensado este artículo?

Este artículo está dirigido a desarrolladores de Python avanzados. Debes estar familiarizado con programación orientada a objetos y entender cómo funcionan los modelos de lenguaje. Los conocimientos básicos en ingeniería de prompts y RAG son útiles, pero no obligatorios.

Si recién empiezas, te recomendamos LangChain o LlamaIndex. DSPy tiene sentido cuando quieres automatizar y mejorar sistemáticamente prompts recurrentes.

Términos importantes

Término	Significado
Signature	Describe la tarea, entradas y salidas de un módulo.
InputField	Un campo de entrada en una firma.
OutputField	Un campo de salida en una firma.
Module	Un bloque reutilizable de DSPy como Predict o ChainOfThought.
Predict	Un módulo que realiza una predicción directa.
ChainOfThought	Módulo que instruye al modelo a pensar paso a paso.
Teleprompter	Optimizador para prompts y ejemplos de pocas instancias.
LM	El modelo de lenguaje que DSPy ha configurado.
RM	El modelo de retrieval o retriever para contexto.
Compile	Proceso en el que se optimiza un programa con Teleprompter.

Instalación

Instala DSPy en un entorno virtual:

pip install dspy

Para ejecutar localmente con Ollama no necesitas una clave de API. Asegúrate de que Ollama esté en ejecución y que haya un modelo disponible como llama3.2:

ollama pull llama3.2

Opcionalmente, instala paquetes adicionales si trabajas con ColBERT, ChromaDB o Weaviate como retrievers.

Primeros pasos: Signaturas y Predicciones

Todo programa DSPy comienza con una firma. Define la tarea en lenguaje natural y establece los campos.

import dspy

lm = dspy.LM(
    model='ollama_chat/llama3.2',
    api_base='http://localhost:11434',
    api_key='',
    max_tokens=512,
)
dspy.configure(lm=lm)

class GenerateAnswer(dspy.Signature):
    """Answer questions with short factoid answers."""

    context = dspy.InputField(desc="may contain relevant facts")
    question = dspy.InputField()
    answer = dspy.OutputField(desc="often between 1 and 5 words")

qa = dspy.Predict(GenerateAnswer)

antwort = qa(
    context="Das Paris befindet sich in Frankreich.",
    question="In welchem Land liegt Paris?"
)
print(antwort.answer)

dspy.Predict es el tipo de módulo más simple. Toma la firma y genera una llamada al LM configurado. La salida es un objeto que accede a los campos de la firma.

Razonar con Chain of Thought

Para tareas más complejas, ChainOfThought es la opción adecuada. Obliga al modelo a generar pasos intermedios antes de proporcionar la respuesta final.

cot = dspy.ChainOfThought(GenerateAnswer)

antwort = cot(
    context="Die Hauptstadt von Frankreich ist Paris. Paris liegt am Fluss Seine.",
    question="An welchem Fluss liegt die Hauptstadt von Frankreich?"
)
print(antwort.answer)
print(antwort.rationale)

El campo rationale contiene el proceso de pensamiento que el modelo generó internamente. Esto mejora la calidad en preguntas que requieren cálculo o lógica.

Construir un programa RAG

DSPy es especialmente adecuado para RAG. Combinas un módulo para retrieval con un módulo para generación de respuestas. En este ejemplo, usamos un modelo de retrieval preconfigurado. Para el despliegue local, puedes intercambiarlo por tu propio retriever como ChromaDB o Weaviate.

import dspy

class GenerateAnswer(dspy.Signature):
    """Answer questions based on the provided context."""

    context = dspy.InputField(desc="relevant passages for the question")
    question = dspy.InputField()
    answer = dspy.OutputField()

class RAG(dspy.Module):
    def __init__(self, num_passages=3):
        super().__init__()
        self.num_passages = num_passages
        self.generate_answer = dspy.ChainOfThought(GenerateAnswer)

    def forward(self, question):
        # Aquí normalmente usarías un retriever real.
        context = "Dies ist ein Beispielkontext, der in einer echten Anwendung aus einem Retriever kommt."
        return self.generate_answer(context=context, question=question)

rag = RAG()
antwort = rag("Was ist DSPy?")
print(antwort.answer)

El módulo RAG encapsula el flujo. La parte del retriever está simplificada aquí. En la práctica, configuras dspy.settings.configure(rm=retriever) y usas dspy.Retrieve(k=3).

Encontrarás más información sobre RAG en Fundamentos de RAG y RAG local. Para embeddings y almacenes de vectores, consulta Modelos de embedding y Bases de datos vectoriales.

Optimización automática de prompts

Lo interesante de DSPy es el Teleprompter. Creas un conjunto de entrenamiento y dejas que DSPy encuentre los mejores ejemplos Few-Shot y la mejor instrucción.

from dspy.teleprompt import BootstrapFewShot

trainset = [
    dspy.Example(
        question="Wer entwickelte die Relativitätstheorie?",
        answer="Albert Einstein",
    ).with_inputs("question"),
    dspy.Example(
        question="Welches ist das größte Tier?",
        answer="Blauwal",
    ).with_inputs("question"),
]

def metrik(gold, pred, trace=None):
    return gold.answer.lower() == pred.answer.lower()

teleprompter = BootstrapFewShot(metric=metrik, max_bootstrapped_demos=4)
compiled_rag = teleprompter.compile(student=RAG(), train=trainset)

antwort = compiled_rag("Was ist DSPy?")
print(antwort.answer)

BootstrapFewShot selecciona ejemplos del conjunto de entrenamiento que funcionan mejor según tu métrica. El resultado es un programa optimizado que utiliza prompts y ejemplos mejorados.

Otros optimizadores

Además de BootstrapFewShot, existen otros Teleprompters. MIPROv2 combina optimización de prompts con selección de ejemplos y es adecuado para tareas complejas. BootstrapFewShotWithRandomSearch prueba subconjuntos aleatorios. Para empezar, BootstrapFewShot es suficiente.

No necesitas un conjunto de entrenamiento gigantesco. DSPy funciona a menudo con pocas decenas de ejemplos. Lo más importante es una buena métrica que mida el comportamiento deseado.

Problemas comunes

• Sintaxis desactualizada: DSPy evoluciona rápidamente. Los tutoriales antiguos utilizan clases OpenAI o ColBERTv2 que tienen otros nombres en versiones más recientes. Verifica la versión.
• Especificación incorrecta del modelo: Para Ollama, usa ollama_chat/model y establece api_base, no api_base_url o base_url.
• Entradas faltantes: with_inputs es necesario para que DSPy sepa qué campos representan la pregunta.
• Métrica deficiente: Una métrica débil genera prompts optimizados inútiles. Invierte tiempo en el criterio de evaluación.
• Muy pocos ejemplos de entrenamiento: BootstrapFewShot necesita algunos ejemplos positivos. Con un solo ejemplo, la optimización no funciona bien.
• Retrieval olvidado: Un programa RAG sin un Retriever real solo produce alucinaciones. Configura dspy.settings.configure(rm=...).
• Signaturas incorrectas: Las descripciones en InputField y OutputField influyen en el prompt. Mantenlas precisas.
• Pruebas sin compilar: Muchas comparaciones entre prompts manuales y DSPy funcionan solo después del paso compile.

Hardware, costes y seguridad

DSPy en sí es gratuito. Los costes provienen de los modelos de lenguaje que utilices. Con Ollama, las llamadas permanecen locales. El paso de optimización compile puede generar muchas llamadas a modelos porque DSPy prueba diferentes prompts y ejemplos. Planifica suficiente tiempo de computación para ello.

Para ejecuciones de entrenamiento mayores, es recomendable un modelo que responda de forma confiable y rápida. Los modelos más potentes producen prompts optimizados mejores, pero requieren más memoria. Un modelo de 7B cuantizado funciona en 8 GB de VRAM.

La seguridad es importante cuando usas ejemplos de entrenamiento sensibles o fuentes de Retrieval. Mantén los datos locales y evita puntos finales públicos para contenido confidencial. DSPy almacena las llamadas en caché internamente, así que verifica la configuración de almacenamiento en caché si procesas información sensible.

Enlaces útiles

• Descripción general de herramientas de desarrollo para marcos relacionados.
• LangChain para cadenas y agentes.
• LlamaIndex para RAG e indexación.
• Haystack para canalizaciones y NLP.
• RAG local para el contexto general.
• Fundamentos de RAG para la teoría.
• Bases de datos vectoriales para elegir un Retriever adecuado.
• Modelos de Embedding para información sobre Embeddings.
• Ollama para ejecución local de modelos.
• Qué es un agente de IA para conceptos de agentes.

Preguntas frecuentes

¿Es DSPy gratuito?

Sí, el framework es Open Source. Los costes surgen solo para APIs de modelos o hardware propio.

¿Qué es la ingeniería programática de prompts?

Significa controlar prompts y ejemplos a través de código y optimización, en lugar de cambiarlos manualmente.

¿Necesito DSPy si ya uso LangChain?

No necesariamente. DSPy complementa otros frameworks cuando deseas optimizar prompts automáticamente.

¿Qué es una firma DSPy?

Una firma describe qué entradas recibe un módulo y qué salidas produce.

¿Cuál es la diferencia entre Predict y ChainOfThought?

Predict es directo. ChainOfThought pide al modelo que genere un razonamiento antes de dar la respuesta.

¿Qué es un Teleprompter?

Un Teleprompter optimiza prompts y ejemplos Few-Shot basándose en datos de entrenamiento y una métrica.

¿Puedo usar DSPy con Ollama?

Sí. Configuras dspy.LM con un punto final de Ollama.

¿Qué necesito para BootstrapFewShot?

Algunos ejemplos con entradas y salidas esperadas, además de una función que evalúe predicciones.

¿Es DSPy solo para RAG?

No. DSPy también es adecuado para clasificación, resumen, preguntas y respuestas, y agentes.

¿Qué tamaño debe tener el conjunto de entrenamiento?

Generalmente, de 20 a 100 ejemplos es suficiente. La calidad de la métrica importa más que la cantidad.

¿Qué sucede con compile?

DSPy prueba diferentes prompts y ejemplos en el conjunto de entrenamiento y genera un programa optimizado.

¿Puedo conectar DSPy con bases de datos locales de Retriever?

Sí. DSPy es agnóstico respecto al Retriever. Puedes usar ChromaDB, Weaviate, FAISS o implementaciones propias.

Fuentes

• DSPy Documentation: https://dspy.ai/
• DSPy GitHub: https://github.com/stanfordnlp/dspy
• DSPy API: https://dspy.ai/api/
• DSPy RAG Tutorial: https://dspy.ai/tutorials/rag/
• Stanford NLP Group: https://nlp.stanford.edu/