Cómo utilizar DSPy con FXMacroData: REST, MCP y agentes FX optimizados

DSPy es útil para flujos de trabajo de investigación de FX cuando se quiere programar y medir un canal de IA en lugar de ajustar manualmente un largo aviso. calendarios de lanzamiento, el historial de anuncios, El valor de la moneda de referencia contexto, El COT el posicionamiento, productos básicos, y Sesión de divisas datos.

El límite clave es simple. DSPy debe organizar el programa de modelo de lenguaje: firmas, módulos, herramientas, evaluación y optimizadores. FXMacroData debe responder a las preguntas de datos de mercado: qué se imprimió, cuándo se imprimía, cuál fue el valor anterior, qué filas se programan a continuación y qué panel de control puede inspeccionar un humano. Eso importa para Indicador de precios de los Estados Unidos¿ Qué ? Pago de los trabajadores no agrícolas¿ Qué ? Tasa de política de la Reserva Federal decisión, o una El valor de las pérdidas Nota de riesgo de liberación.

Por qué DSPy se ajusta a los agentes macro FX

DSPy está construido alrededor de primitivos reutilizables. Las firmas declaran entradas y salidas escritas. Los módulos deciden cómo se ejecuta una firma. ReAct agrega un bucle de uso de herramientas. Los optimizadores compilan un programa contra ejemplos y una métrica. Eso se adapta bien a las finanzas porque un flujo de trabajo macro no es solo un aviso; es una secuencia de recuperación, interpretación, puntuación y revisión de datos.

Para FX, la pregunta útil no es "¿puede el modelo escribir una nota convincente?" La pregunta útil es "¿Puede el programa buscar consistentemente la evidencia macro actual, citar las rutas de origen, revelar los datos faltantes y producir el tipo de informe que un analista humano puede revisar?" DSPy le da una manera de medir ese comportamiento.

REST, ReAct, MCP u optimizadores: qué camino utilizar

React es útil cuando el modelo debe elegir qué función de datos estrecha llamar. MCP es útil quando DSPy debe consumir una superficie de herramienta alojada estándar. Los optimizadores vienen por último, una vez que se puede calificar la calidad.

Los requisitos previos

Para usar MCP, instale DSPy con sus extras MCP.

pip install -U dspy requests
pip install -U "dspy[mcp]"

Para las comprobaciones directas de REST, utilizar los puntos finales de producción FXMacroData y la autenticación de parámetros de consulta:

curl "https://api.fxmacrodata.com/v1/calendar/usd?api_key=YOUR_API_KEY"
curl "https://api.fxmacrodata.com/v1/announcements/usd/inflation?api_key=YOUR_API_KEY"
curl "https://api.fxmacrodata.com/v1/forex/eur/usd?api_key=YOUR_API_KEY"
curl "https://api.fxmacrodata.com/v1/commodities/latest?api_key=YOUR_API_KEY"

Mantenga la clave de la API en el lado del servidor. El modelo debe recibir evidencia y rutas de origen, no credenciales.

Paso 1: Define la firma DSPy

Qué hacer: Esto mantiene el programa centrado en la evidencia, no en la prosa general del mercado.

import dspy

class FxMacroBrief(dspy.Signature):
    """Brief an FX macro event using supplied evidence only."""
    question: str = dspy.InputField()
    evidence: dict = dspy.InputField()
    answer: str = dspy.OutputField()
    sources: list[str] = dspy.OutputField()
    data_gaps: list[str] = dspy.OutputField()
    review_required: bool = dspy.OutputField()

La firma es deliberadamente pequeña. Una primera versión debe demostrar que el programa puede separar la evidencia de la interpretación y nombrar lo que utilizó. Agregue campos de cartera, par, escenario o riesgo más tarde cuando el flujo de trabajo los necesite.

Paso 2: Añadir herramientas REST de FXMacroData

Qué hacer: Mantenga la autenticación y el comportamiento HTTP en el código de aplicación normal. Las herramientas DSPy pueden llamar a ese código, pero las solicitudes no deben contener credenciales, políticas de reintento o reglas de limpieza de datos.

import os
import requests

API_ROOT = "https://api.fxmacrodata.com/v1"

def fxmd_get(path: str, params: dict | None = None) -> dict:
    query = {"api_key": os.environ["FXMD_API_KEY"], **(params or {})}
    response = requests.get(f"{API_ROOT}/{path}", params=query, timeout=10)
    response.raise_for_status()
    return {
        "endpoint": f"/v1/{path}",
        "payload": response.json(),
    }

Una amplia herramienta de "obtener cualquier cosa" hace que la evaluación sea más difícil porque el modelo puede llamar a puntos finales irrelevantes y aún así escribir una respuesta plausible.

def fxmacrodata_calendar(currency: str) -> dict:
    """Fetch confirmed macro calendar rows for a 3-letter currency."""
    code = currency.lower().strip()
    return fxmd_get(f"calendar/{code}")

def fxmacrodata_announcement(currency: str, indicator: str) -> dict:
    """Fetch historical announcement rows for one indicator."""
    code = currency.lower().strip()
    slug = indicator.lower().strip()
    return fxmd_get(f"announcements/{code}/{slug}")

Paso 3: Utilice ReAct cuando el programa necesite herramientas

Qué hacer: el uso dspy.ReAct Cuando el programa necesita decidir si llama a una herramienta. La documentación de DSPy describe herramientas como funciones normales de Python con parámetros y cadenas de datos de tipo, y ReAct como un bucle de razonamiento y acción que puede decidir cuándo llamar herramientos y cuándo terminar.

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

class FxMacroAgent(dspy.Signature):
    """Answer only after checking FXMacroData when facts are current."""
    question: str = dspy.InputField()
    answer: str = dspy.OutputField()
    sources: list[str] = dspy.OutputField()
    data_gaps: list[str] = dspy.OutputField()

agent = dspy.ReAct(
    FxMacroAgent,
    tools=[fxmacrodata_calendar, fxmacrodata_announcement],
    max_iters=4,
)

result = agent(question="What USD release risk matters next?")
print(result.answer)

No lo pierdas . max_iters Un agente financiero no debe vagar por las herramientas hasta que encuentre una narrativa, debe recuperar el conjunto de pruebas más pequeño que responda a la pregunta.

Paso 4: Utilice MCP para una superficie de herramienta estándar

Qué hacer: utilizar MCP cuando la superficie de la herramienta debe ser reutilizable en DSPy y otros hosts de agentes. https://mcp.fxmacrodata.comEn los hosts que utilizan la forma de estilo VS Code, la configuración es:

{
  "servers": {
    "FXMacroData": {
      "type": "http",
      "url": "https://mcp.fxmacrodata.com"
    }
  }
}

DSPy puede consumir herramientas MCP a través de la sesión de cliente Python MCP y convertir herramienta MCP descubiertas en dspy.Tool El tutorial de DSPy MCP demuestra ese patrón con dspy.Tool.from_mcp_tool(session, tool). El transporte que utiliza debe coincidir con su cliente y host MCP; el servidor de producción FXMacroData es HTTP remoto.

# Sketch: convert discovered MCP tools into DSPy tools.
dspy_tools = []
for tool in tools.tools:
    dspy_tools.append(dspy.Tool.from_mcp_tool(session, tool))

react = dspy.ReAct(FxMacroAgent, tools=dspy_tools)
result = await react.acall(
    question="Summarize the next USD macro events."
)

Para los equipos que prefieren un envoltorio local explícito, mantenga el contrato de la herramienta MCP pequeño y específico para las finanzas.

{
  "name": "fxmacrodata_calendar",
  "description": "Fetch confirmed macro calendar rows for a currency.",
  "input_schema": {
    "type": "object",
    "properties": {
      "currency": {
        "type": "string",
        "description": "Three-letter currency code, such as USD"
      }
    },
    "required": ["currency"]
  }
}

Paso 5: Optimiza en función de los criterios financieros

Qué hacer: No optimice por estilo primero. Optimice por evidencia. Los optimizadores DSPy necesitan ejemplos y una métrica. Para las macro FX, una métricas básica puede recompensar las rutas de origen, los huecos explícitos y una respuesta concisa basada en las filas obtenidas.

def macro_brief_metric(example, pred, trace=None) -> float:
    sources = " ".join(getattr(pred, "sources", []) or [])
    answer = getattr(pred, "answer", "") or ""
    gaps = getattr(pred, "data_gaps", []) or []

    has_source_path = "/v1/" in sources
    has_answer = len(answer) >= 80
    names_gaps = isinstance(gaps, list)
    avoids_trade_order = "buy " not in answer.lower()

    return float(has_source_path and has_answer and names_gaps and avoids_trade_order)

Una vez que la métrica es significativa, compilemos el programa en un pequeño conjunto de ejemplos reales. Mantenga un conjunto de validación separado para que pueda saber si la optimización mejoró el flujo de trabajo o simplemente encaja en sus ejemplares.

optimizer = dspy.GEPA(
    metric=macro_brief_metric,
    auto="light",
    num_threads=2,
)

optimized_agent = optimizer.compile(
    agent,
    trainset=train_examples,
    valset=validation_examples,
)

optimized_agent.save("fxmacrodata_dspy_agent.json")

Paso 6: Añadir barreras de seguridad financieras

Mantenga la primera integración de DSPy y FXMacroData solo de lectura. El programa debe recuperar, resumir, comparar y marcar. No debe colocar operaciones, alterar los límites de riesgo o ocultar datos faltantes detrás de un lenguaje seguro.

• Requiere pruebas antes que prosa. Las afirmaciones de macro actuales deben venir después de una llamada de la herramienta REST o MCP.
• Mantenga las herramientas estrechas. Prefiere calendario separado, anuncio, FX, COT, materias primas y funciones de sesión.
• - No hay nada. La recompensa sale que el nombre de datos faltantes o obsoletos en lugar de suavizar sobre él.
• Cap ReAct bucles. Evite el encadenamiento de herramientas sin control para las instrucciones de liberación simples.
• Separar la investigación de la ejecución. El primer flujo de trabajo de producción debe ser revisado por humanos y solo se puede leer.

Preguntas frecuentes

¿Puede DSPy usar FXMacroData?

Sí. DSPy puede usar FXMacroData a través de envolturas REST directas, herramientas Python normales pasadas a dspy.ReAct, o herramientas de MCP convertidas en dspy.Tool las instancias.

¿Debería DSPy reemplazar una fuente de datos macro?

No. DSPy debe organizar y optimizar el programa de modelo. FXMacroData debe seguir siendo la fuente de calendarios de lanzamiento, filas de anuncios, historial de FX, COT, productos básicos, sesiones, marcas de tiempo y brechas de datos.

¿Debería usar REST o MCP con DSPy?

Utilice REST cuando su aplicación posee credenciales, intentos de reutilización, política de caché, validación y registros.

¿Cuándo debo usar optimizadores DSPy?

Para las finanzas, la métrica debe recompensar la evidencia, las rutas de origen, la divulgación de lagunas y la redacción conservadora antes de recompensarse con el estilo.

Fuentes de información

• Resumen de DSPy
• Herramientas DSPy con documentación ReAct
• Tutorial de MCP de DSPy
• Guía de optimización de DSPy GEPA
• Documentación de la API de FXMacroData
• Documentación de la MCP de FXMacroData
• Esquema de producción de FXMacroData y OpenAPI