> ## Documentation Index
> Fetch the complete documentation index at: https://macrofeed.dsforge.co/docs/llms.txt
> Use this file to discover all available pages before exploring further.

# Connect in 60 seconds

> Connect Cursor, Claude Code, OpenClaw, or any Streamable HTTP MCP client to MacroFeed through the official CTX marketplace MCP.

Connect the official CTX marketplace MCP once, then use MacroFeed from any compatible agent. You do not install a separate MacroFeed server.

<Note>
  **MacroFeed is the product surface.** Its public methods include `get_next_release`, `get_upcoming_events`, and `get_event`. The CTX marketplace MCP is the client interface your agent uses to reach MacroFeed and other marketplace products.
</Note>

## Before you connect

Complete the one-time account setup in [Context](https://www.ctxprotocol.com?ref=gfx1u2ax):

1. Sign in to create your embedded wallet.
2. Set the USDC spending cap and fund the wallet.
3. Open [Settings](https://www.ctxprotocol.com/settings?ref=gfx1u2ax), create an API key, and copy the `sk_live_...` value.

The remote MCP uses this endpoint:

```text theme={null}
https://www.ctxprotocol.com/api/mcp
```

Transport is **Streamable HTTP**. Every request is authenticated with `Authorization: Bearer sk_live_...`.

## Cursor

Add the server to your project's `.cursor/mcp.json`, or use the same entry in Cursor's global MCP settings.

```json theme={null}
{
  "mcpServers": {
    "ctxprotocol": {
      "url": "https://www.ctxprotocol.com/api/mcp",
      "headers": {
        "Authorization": "Bearer sk_live_YOUR_KEY"
      }
    }
  }
}
```

Restart Cursor after saving the file.

## Claude Code

Run:

```bash theme={null}
claude mcp add --transport http ctxprotocol https://www.ctxprotocol.com/api/mcp \
  --header "Authorization: Bearer sk_live_YOUR_KEY"
```

## OpenClaw or Claw Code

Add this entry to the client's `mcp.json`:

```json theme={null}
{
  "mcpServers": {
    "ctxprotocol": {
      "transport": "streamable-http",
      "url": "https://www.ctxprotocol.com/api/mcp",
      "headers": {
        "Authorization": "Bearer sk_live_YOUR_KEY"
      }
    }
  }
}
```

## Any Streamable HTTP MCP client

Use these connection values:

| Setting   | Value                                    |
| --------- | ---------------------------------------- |
| URL       | `https://www.ctxprotocol.com/api/mcp`    |
| Transport | Streamable HTTP                          |
| Header    | `Authorization: Bearer sk_live_YOUR_KEY` |

The server returns an `Mcp-Session-Id` after initialization. Clients that persist sessions should send it on subsequent requests.

See the [official CTX marketplace MCP documentation](https://docs.ctxprotocol.com/sdk/mcp) for the current tool reference and troubleshooting guidance.

## Pin MacroFeed

MacroFeed is published in the marketplace as:

```text theme={null}
Listing: MacroFeed - Economic Calendar
Tool ID: ca9e2cc7-f389-4f64-a301-f7cdc1b50a0e
```

After connecting, the CTX server exposes `context_query`, `context_discover`, and `context_execute`, plus query-job helpers for longer requests.

For a natural-language answer constrained to MacroFeed, ask your agent to call `context_query` with:

```json theme={null}
{
  "question": "What is the next scheduled USD CPI release? Include its release time and official source.",
  "toolIds": [
    "ca9e2cc7-f389-4f64-a301-f7cdc1b50a0e"
  ],
  "responseShape": "answer_with_evidence"
}
```

`toolIds` is the remote MCP parameter. In the TypeScript and Python SDKs, the equivalent Query parameter is named `tools`.

## Call one MacroFeed method directly

Use `context_discover` with `mode: "execute"` before direct execution so the client confirms which methods are currently Execute-eligible.

```json theme={null}
{
  "query": "MacroFeed Economic Calendar",
  "mode": "execute",
  "limit": 10
}
```

Then call `context_execute` with the MacroFeed ID and method:

```json theme={null}
{
  "toolId": "ca9e2cc7-f389-4f64-a301-f7cdc1b50a0e",
  "toolName": "get_next_release",
  "args": {
    "currency": "USD",
    "indicatorKey": "us_cpi_headline"
  },
  "maxSpendUsd": "0.01",
  "closeSession": true
}
```

Use `context_query` when you want CTX to manage tool selection, grounding, and synthesis. Use `context_discover` followed by `context_execute` when your agent needs a specific MacroFeed method and raw structured output.

<CardGroup cols={2}>
  <Card title="Try MacroFeed in Context" icon="messages" href="https://www.ctxprotocol.com/?toolId=ca9e2cc7-f389-4f64-a301-f7cdc1b50a0e">
    Ask a macro question in the hosted Context interface.
  </Card>

  <Card title="Build with the SDK" icon="code" href="/docs/api-quickstart">
    Use Query or Execute from a TypeScript or Python service.
  </Card>
</CardGroup>