Cómo utilizar smolagents con FXMacroData: CodeAgent, REST y MCP

Embrago Fácil de usar es una opción útil cuando un agente de macro FX necesita un uso compacto de herramientas Python, razonamiento de estilo de código o llamadas de herramentas JSON estándar sin una capa de orquestación pesada. 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 es simple. los agentes de smolagent deben decidir cómo el modelo utiliza herramientas. FXMacroData debe responder a las preguntas de hecho: lo que se imprimió, lo que fue antes, lo programado, qué serie está disponible, y qué panel de control puede inspeccionar un humano. 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 el resumen de riesgo de liberación.

Por qué los smolagentes encajan en los agentes macro FX

smolagents es deliberadamente pequeño: Hugging Face lo describe como una biblioteca Python de código abierto para la construcción de agentes con abstracciones mínimas. CodeAgent, donde el modelo escribe fragmentos de Python para llamar a herramientas y combinar resultados. ToolCallingAgent para la llamada de herramientas convencionales de estilo JSON.

Esta división es útil en finanzas. Un flujo de trabajo de riesgo de liberación a menudo necesita bucles, comparaciones, filtros de fecha y pequeñas transformaciones. El código puede expresarlo naturalmente, pero la ejecución de código también necesita un límite de confianza más estricto. Para el trabajo de finanzas de producción, mantenga las herramientas FXMacroData solo de lectura, mantén las credenciales fuera del prompt del modelo y valida la respuesta final antes de que llegue a un operador, panel de control o canal de alerta.

Forma del flujo de trabajo

REST, MCP, agente de código o agente de llamada de herramientas?

Los requisitos previos

• Una cuenta de Hugging Face y acceso a modelos si lo usas. InferenceClientModel- ¿ Qué ?
• Una clave de la API FXMacroData almacenada fuera de las solicitudes, por ejemplo, como una variable de entorno.
• Python 3.10 o posterior para el tiempo de ejecución del agente.
• Una regla clara es que estas herramientas sólo recuperan evidencia.

pip install "smolagents[toolkit,mcp]" requests
export HF_TOKEN="YOUR_HUGGING_FACE_TOKEN"
export FXMD_API_KEY="YOUR_FXMACRODATA_API_KEY"

Step 1: Wrap FXMacroData REST

Comience con un pequeño ayudante HTTP. Mantenga la clave de API en la configuración del proceso, no en el menú de tareas. Los ejemplos de API públicas utilizan autenticación de parámetros de consulta.

import os
import requests

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

def fxmd_get(path: str, **params):
    params["api_key"] = os.environ["FXMD_API_KEY"]
    response = requests.get(f"{BASE_URL}{path}", params=params, timeout=20)
    response.raise_for_status()
    return response.json()

Este ejemplo da al modelo de calendario acceso sin darle acceso HTTP arbitrario.

from smolagents import Tool

class FxCalendarTool(Tool):
    name = "fxmacrodata_calendar"
    description = "Return scheduled macro releases for a currency code."
    inputs = {
        "currency": {
            "type": "string",
            "description": "Three-letter currency code, such as usd or eur",
        }
    }
    output_type = "object"

    def forward(self, currency: str):
        return fxmd_get(f"/calendar/{currency.lower()}")

Añadir una segunda herramienta estrecha para el historial de anuncios. Mantenga sus argumentos explícitos para que el agente no pueda vagar por familias de datos no relacionadas.

class FxAnnouncementTool(Tool):
    name = "fxmacrodata_announcement_history"
    description = "Return historical announcement rows for one currency and indicator."
    inputs = {
        "currency": {"type": "string", "description": "Currency code"},
        "indicator": {"type": "string", "description": "Indicator slug"},
    }
    output_type = "object"

    def forward(self, currency: str, indicator: str):
        path = f"/announcements/{currency.lower()}/{indicator}"
        return fxmd_get(path)

Paso 2: Construye un agente de código

¿ Cómo ? CodeAgent Para un flujo de trabajo FX, eso podría significar verificar la próxima versión, extraer las últimas impresiones y comparar la configuración de eventos con el contexto de pares.

from smolagents import CodeAgent, InferenceClientModel

model = InferenceClientModel()

agent = CodeAgent(
    tools=[FxCalendarTool(), FxAnnouncementTool()],
    model=model,
    add_base_tools=False,
    max_steps=6,
    instructions="Use FXMacroData tools for factual macro data.",
)

agent.run(
    "Prepare a USD/JPY release-risk brief. "
    "Use USD calendar and CPI evidence before interpreting."
)

Mantenga la instrucción contundente. El modelo debe saber que la salida de la herramienta FXMacroData es la capa de evidencia y que los datos no disponibles deben ser nombrados como no disponibles, no adivinados.

Paso 3: Utilice ToolCallingAgent para llamadas más estrictas

¿ Cómo ? ToolCallingAgent Esto es a menudo más fácil de auditar porque cada acción es una llamada estructurada en lugar de código Python generado.

from smolagents import ToolCallingAgent, InferenceClientModel

agent = ToolCallingAgent(
    tools=[FxCalendarTool(), FxAnnouncementTool()],
    model=InferenceClientModel(),
    max_steps=4,
)

agent.run(
    "Find the next USD macro release and summarize "
    "which data row supports the answer."
)

Un esquema de herramientas como este también es útil cuando se refleja el mismo punto final en otro host de agente o se desea un artefacto de revisión clara para los permisos de herramenta.

{
  "name": "fxmacrodata_announcement_history",
  "description": "Return historical macro announcement rows.",
  "inputSchema": {
    "type": "object",
    "properties": {
      "currency": {"type": "string"},
      "indicator": {"type": "string"}
    },
    "required": ["currency", "indicator"]
  }
}

Paso 4: Conectar a través de MCP

para los servidores MCP, el punto final MCP alojado es https://mcp.fxmacrodata.com. Esta ruta es útil cuando se desea un contrato de herramienta compartida a través de diferentes hosts de agentes en lugar de REST manuscritos envolventes en cada proyecto.

from smolagents import MCPClient, CodeAgent, InferenceClientModel

server = {
    "url": "https://mcp.fxmacrodata.com",
    "transport": "streamable-http",
}

with MCPClient(server, structured_output=True) as tools:
    agent = CodeAgent(
        tools=tools,
        model=InferenceClientModel(),
        add_base_tools=False,
    )
    agent.run("Compare the next USD releases with EUR/USD context.")

Si su editor o agente espera una configuración JSON en lugar de código Python, el mismo servidor alojado puede ser representado como un servidor MCP HTTP remoto.

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

Paso 5: Añadir barreras de seguridad financieras

Los agentes de estilo código son poderosos, por lo que los barreras deben ser concretas.

def grounded_answer(answer: str, agent_memory=None) -> bool:
    required_terms = ["FXMacroData", "release", "source"]
    return all(term in answer for term in required_terms)

agent = CodeAgent(
    tools=[FxCalendarTool(), FxAnnouncementTool()],
    model=InferenceClientModel(),
    final_answer_checks=[grounded_answer],
    max_steps=6,
)

Ejemplo de forma de salida

La respuesta final debe parecerse a una nota de un analista con pruebas rastreables.

{
  "brief": "USD event risk is concentrated around the next scheduled release.",
  "evidence": [
    {
      "source": "FXMacroData calendar",
      "path": "/v1/calendar/usd",
      "used_for": "Next known release window"
    },
    {
      "source": "FXMacroData announcements",
      "path": "/v1/announcements/usd/inflation",
      "used_for": "Recent CPI history"
    }
  ],
  "data_gaps": []
}

Preguntas frecuentes

¿Pueden los agentes de smolagent usar FXMacroData?

Sí. Utilice REST wrappers para un estricto control de la aplicación, o conecte smolagents al servidor MCP FXMacroData alojado cuando desee la búsqueda de herramientas a través de una superficie MCP compartida.

¿Debería usar CodeAgent o ToolCallingAgent para las finanzas?

¿ Cómo ? CodeAgent Cuando el flujo de control de Python es valioso y puede ejecutar sandbox. ToolCallingAgent cuando las llamadas estructuradas predecibles son más importantes que la lógica Python generada.

¿Los smolagentes reemplazan una fuente de datos macro?

No. smolagents coordina el modelo y las herramientas. FXMacroData sigue siendo la capa de datos para las filas de macro, calendarios de lanzamiento, contexto FX, COT, productos básicos, tiempo de sesión, marcas de tiempo y manejo de datos.

¿Deberían los smolagentes utilizar REST o MCP con FXMacroData?

Utilice REST cuando su aplicación posee credenciales, intentos de reinstalación, validación y registro. https://mcp.fxmacrodata.com y comparten el mismo contrato de herramienta que otros hosts de agentes.

Guías de FXMacroData relacionadas

• Documentación de la API de FXMacroData
• Documentación del servidor MCP de FXMacroData
• Cómo utilizar Pydantic AI con FXMacroData
• Cómo utilizar DSPy con FXMacroData
• Cómo crear LangGraph FX Macro Agents con FXMacroData

Fuentes de información

• Encuentro de los smolantes de la cara
• Visita guiada de los smlagents
• - ¿Qué es eso?
• Referencia de las herramientas de los smolagentes
• Documentación de la API de FXMacroData
• Documentación de la MCP de FXMacroData