How to Use Microsoft Agent Framework with FXMacroData: Agents, Workflows, REST and MCP

Microsoft Agent Framework is the current Microsoft SDK for building AI agents and graph-based multi-agent workflows across .NET, Python, and Go. For FX workflows, FXMacroData supplies the current market evidence those agents need: confirmed release calendars, announcement history, EUR/USD context, COT positioning, commodities, and FX session data.

Microsoft positions Agent Framework as the successor path for ideas from Semantic Kernel and AutoGen. That makes it a better starting point for a new Microsoft-oriented FX macro agent than building directly on older orchestration patterns. A model can explain US CPI, Non-Farm Payrolls, or a Federal Reserve policy rate setup, but FXMacroData should answer what printed, when it printed, what the prior value was, and what is scheduled next.

Why Microsoft Agent Framework Fits FX Macro Workflows

Agent Framework gives you three practical building blocks: agents that call models and tools, a harness for longer tasks, and graph-based workflows that coordinate agents and functions with typed routing, checkpoints, and human-in-the-loop support. That maps well to finance because the data call, analysis step, and review step should be separate.

The key boundary is source of truth. Agent Framework should coordinate the process. FXMacroData should supply the facts: release dates, actual values, prior values, revisions, forecast fields, FX context, commodities, positioning, and session timing.

REST, Function Tools, MCP, or Workflows: Which Path to Use

Start with the smallest integration that matches the job. Agent Framework can use function tools, hosted or local MCP tools, agent-as-tool patterns, and graph workflows. You do not need every path in the first version.

Prerequisites

You need Python, Microsoft Agent Framework, an LLM provider configured for the framework, an FXMacroData API key, and a first read-only workflow.

pip install agent-framework requests

For REST examples, use production FXMacroData endpoints and query-parameter authentication:

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"

Keep the API key server-side. The model should receive structured evidence and source paths, not credentials.

Step 1: Fetch FXMacroData Evidence First

What to do: create a small REST helper that every Agent Framework tool uses. This keeps authentication, retries, and logging in application code rather than in a prompt.

import os
import requests

API_ROOT = "https://api.fxmacrodata.com/v1"
FXMD_API_KEY = os.environ["FXMD_API_KEY"]

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

The helper should return both data and enough metadata for a later review step. At minimum, preserve the endpoint path, requested currency, indicator, fetch time, and returned fields used in the final answer.

Step 2: Expose FXMacroData as a Function Tool

What to do: expose narrow functions that Agent Framework can call as tools. The Microsoft tools documentation describes function tools as custom code that agents can call during conversations.

def fxmacrodata_calendar(currency: str) -> dict:
    """Fetch confirmed macro events for a 3-letter currency code."""
    code = currency.lower().strip()
    return {
        "source": "FXMacroData",
        "endpoint": f"/v1/calendar/{code}",
        "data": fxmd_get(f"calendar/{code}"),
    }

Attach that function to an Agent Framework agent alongside instructions that force evidence-first output. The provider client can be Microsoft Foundry, Azure OpenAI, OpenAI, Anthropic, Ollama, or another supported client; the important part is that the tool surface stays small.

from agent_framework.openai import OpenAIChatCompletionClient

client = OpenAIChatCompletionClient(model="gpt-5-mini")

agent = client.as_agent(
    name="FXMacroReleaseAnalyst",
    instructions=(
        "Use FXMacroData tools before writing. "
        "Return dates, values, endpoint paths, and gaps."
    ),
    tools=fxmacrodata_calendar,
)

result = await agent.run("Prepare a USD release-risk briefing.")
print(result.text)

For a first workflow, one tool is enough. Add more only when the prompt needs them: announcement history, FX spot history, COT positioning, commodities, or sessions.

Step 3: Add FXMacroData MCP When the Host Supports Tools

What to do: use MCP when the surrounding host or provider runtime should discover FXMacroData tools instead of calling your custom REST wrappers. Microsoft Agent Framework documents hosted and local MCP tools in its tool support matrix.

The canonical FXMacroData MCP server entry is:

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

For authenticated coverage, keep the key in the host's supported secret mechanism where possible. If a client only supports URL configuration, use the authenticated URL carefully:

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

Use direct REST wrappers when your service needs strict request validation, retries, and per-customer logs. Use MCP when Agent Framework, Foundry, or another compatible host should discover a curated tool surface from https://mcp.fxmacrodata.com.

Step 4: Wrap the Agent in a Checked Workflow

What to do: use a workflow when the process needs explicit order: fetch evidence, draft analysis, review evidence, then return. Agent Framework workflows are graph-based and can use checkpoints for long-running or auditable processes.

from agent_framework import InMemoryCheckpointStorage, WorkflowBuilder

checkpoint_storage = InMemoryCheckpointStorage()

builder = WorkflowBuilder(
    start_executor=fetch_evidence_executor,
    checkpoint_storage=checkpoint_storage,
)
builder.add_edge(fetch_evidence_executor, analyst_executor)
builder.add_edge(analyst_executor, review_executor)
builder.add_edge(review_executor, end_executor)

workflow = builder.build()

That sketch leaves the executor details to your app, but the shape is the point. The agent should not skip evidence retrieval, and the review step should be allowed to reject unsupported output.

Checkpointing is useful for scheduled release workflows because it lets you preserve process state around data fetches, review gates, and human approval. Treat checkpoint storage as private infrastructure, because it can contain conversation state and intermediate evidence.

Step 5: Add Finance Guardrails

Agent Framework has tool approval, middleware, sessions, workflows, MCP clients, and checkpointing. In a finance workflow, those controls should enforce evidence boundaries rather than just making the agent more autonomous.

• Read-only first: expose calendar, announcements, FX, COT, commodities, and session tools before anything else.
• Evidence before prose: require an FXMacroData call before the agent writes about current macro events.
• Tool approval for sensitive paths: gate any broad tool, remote MCP tool, or write-like action behind approval.
• Checkpoint storage security: store checkpoints only in trusted private infrastructure with access controls.
• No execution tools: keep broker actions, account changes, and order placement outside the first agent workflow.

Required briefing contract:
1. FXMacroData tools or endpoints used
2. Release dates and values
3. Prior and revised values where available
4. Market interpretation
5. Data gaps or stale-data warnings
6. No trade execution or account action

Common Questions

Can Microsoft Agent Framework use FXMacroData?

Yes. Use narrow REST function tools, FXMacroData MCP, or both. REST gives your application maximum control over credentials and logging. MCP is useful when an agent host should discover FXMacroData tools from https://mcp.fxmacrodata.com.

Should I use Agent Framework instead of Semantic Kernel or AutoGen?

For new Microsoft-oriented agent work, yes. Microsoft describes Agent Framework as the direct successor path that combines Semantic Kernel enterprise features and AutoGen agent patterns. Existing Semantic Kernel or AutoGen projects can still migrate deliberately, but new FX macro builds should start with the current framework.

Should Agent Framework replace a macro data feed?

No. Agent Framework coordinates agents, tools, workflows, and state. FXMacroData should remain the source for macro rows, release calendars, FX context, COT, commodities, session timing, timestamps, and data gaps.

Should I use REST or MCP with Agent Framework?

Use REST when your service owns credentials, validation, retries, cache policy, and logs. Use MCP when a compatible host or provider runtime should discover a curated FXMacroData tool surface through a standard server.

Sources and References

• Microsoft Agent Framework overview
• Microsoft Agent Framework agents overview
• Microsoft Agent Framework tools overview
• Microsoft Agent Framework hosted MCP tools
• Microsoft Agent Framework local MCP tools
• Microsoft Agent Framework workflows overview
• Microsoft Agent Framework workflow checkpoints
• Migration guide from Semantic Kernel to Agent Framework
• Migration guide from AutoGen to Agent Framework
• FXMacroData API documentation
• FXMacroData MCP documentation
• FXMacroData production OpenAPI schema