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

# Connect and Call Tools

> Connect a trusted host to Sports MCP Server over HTTP and make bounded, source-aware tool calls.

# Connect and Call Tools

Sports MCP Server uses standard MCP JSON-RPC over HTTP. The safest first-call pattern is still:

1. resolve scope when the prompt is ambiguous
2. choose the right source family for the job
3. deepen only if the user still needs more context

## Connection model

<Tabs>
  <Tab title="Server-side or trusted host">
    This is the intended deployment model.

    Good fits:

    * application backends
    * orchestration workers
    * trusted MCP hosts
    * internal services that preserve product-scoped auth and telemetry
  </Tab>

  <Tab title="Direct browser access">
    Do not treat the MCP server as a public browser API.

    Route browser experiences through your own trusted backend so you keep:

    * bearer key handling
    * product-scoped auth
    * rate limiting and quota behavior
    * controlled shaping of partials and ambiguity
  </Tab>
</Tabs>

## First request pattern

<CodeGroup>
  ```json JSON-RPC theme={null}
  {
    "jsonrpc": "2.0",
    "id": "req-1",
    "method": "tools/call",
    "params": {
      "name": "resolve_entities",
      "arguments": {
        "query": "Premier League",
        "entityType": "competition",
        "limit": 5
      }
    }
  }
  ```

  ```bash curl theme={null}
  curl "https://sports-mcp-server.etonecarg.com/" \
    -X POST \
    -H "Authorization: Bearer $SPORTS_MCP_API_KEY" \
    -H "Accept: application/json, text/event-stream" \
    -H "Content-Type: application/json" \
    -H "mcp-protocol-version: 2025-03-26" \
    -d '{
    "jsonrpc": "2.0",
    "id": "req-1",
    "method": "tools/call",
    "params": {
      "name": "resolve_entities",
      "arguments": {
        "query": "Premier League",
        "entityType": "competition",
        "limit": 5
      }
    }
  }'
  ```

  ```ts TypeScript theme={null}
  const payload = {
    jsonrpc: "2.0",
    id: "req-1",
    method: "tools/call",
    params: {
      name: "resolve_entities",
      arguments: {
        query: "Premier League",
        entityType: "competition",
        limit: 5,
      },
    },
  };

  const response = await fetch("https://sports-mcp-server.etonecarg.com/", {
    method: "POST",
    headers: {
      Authorization: `Bearer ${process.env.SPORTS_MCP_API_KEY!}`,
      Accept: "application/json, text/event-stream",
      "Content-Type": "application/json",
      "mcp-protocol-version": "2025-03-26",
    },
    body: JSON.stringify(payload),
  });

  const data = await response.json();
  console.log(JSON.stringify(data, null, 2));
  ```

  ```python Python theme={null}
  import json
  import os

  import requests

  payload = {
      "jsonrpc": "2.0",
      "id": "req-1",
      "method": "tools/call",
      "params": {
          "name": "resolve_entities",
          "arguments": {
              "query": "Premier League",
              "entityType": "competition",
              "limit": 5,
          },
      },
  }

  response = requests.post(
      "https://sports-mcp-server.etonecarg.com/",
      headers={
          "Authorization": f"Bearer {os.environ['SPORTS_MCP_API_KEY']}",
          "Accept": "application/json, text/event-stream",
          "Content-Type": "application/json",
          "mcp-protocol-version": "2025-03-26",
      },
      json=payload,
      timeout=30,
  )

  response.raise_for_status()
  print(json.dumps(response.json(), indent=2))
  ```
</CodeGroup>

## Follow-on call patterns

<Tabs>
  <Tab title="Competition-first flow">
    Use this when the product needs sports truth first.

    Typical sequence:

    1. [`resolve_entities`](/sports-mcp-server/tool-reference/resolve_entities)
    2. [`list_schedule`](/sports-mcp-server/tool-reference/list_schedule) or [`get_competition_hub`](/sports-mcp-server/tool-reference/get_competition_hub)
    3. [`get_event_summary`](/sports-mcp-server/tool-reference/get_event_summary) or another atomic deep-sports tool
  </Tab>

  <Tab title="Availability-first flow">
    Use this when the product needs what can be watched.

    Typical sequence:

    1. [`resolve_entities`](/sports-mcp-server/tool-reference/resolve_entities) when needed
    2. [`list_watchable_schedule`](/sports-mcp-server/tool-reference/list_watchable_schedule) or [`list_live_slate`](/sports-mcp-server/tool-reference/list_live_slate)
    3. [`get_watch_availability`](/sports-mcp-server/tool-reference/get_watch_availability) for a selected row
  </Tab>

  <Tab title="Program-first flow">
    Use this when your product starts from a program row or guide entry.

    Typical sequence:

    1. [`get_program_context`](/sports-mcp-server/tool-reference/get_program_context)
    2. [`list_entities_for_program`](/sports-mcp-server/tool-reference/list_entities_for_program) if you need raw linkage evidence
    3. Branch into [`get_watch_availability`](/sports-mcp-server/tool-reference/get_watch_availability) for a selected linked event, or back into a host-side ranking flow if the product should branch into related viewing
  </Tab>
</Tabs>

## Working rules

* Keep `timeFrom` and `timeTo` bounded anywhere the workflow is schedule-like or watchability-like.
* Preserve the provider namespace of every ref you keep.
* Use GSD-first tools for deep sports truth.
* Use watchability and program-context tools for watchability jobs; they will use the supported availability contract when provisioned and otherwise degrade through the stateless fallback.
* Read `partial`, `missingSections`, and `limitations` before deepening.

## Read this next

* [Quickstart](/sports-mcp-server/getting-started/quickstart)
* [MCP Basics](/sports-mcp-server/reference/mcp-basics)
* [IDs, Crosswalks, and Bounded Windows](/sports-mcp-server/concepts/ids-crosswalks-and-bounded-windows)