Skip to content

Connect an AI app over MCP

Connect an MCP-compatible agent to https://mcp.argusfa.com/mcp with OAuth. A personal connection lists up to 20 consumer tools, depending on its grants, and every one of them returns the compact consumer-result-v1 envelope. Private research tools also require personal authorization and current consent for each data domain.

The public /mcp endpoint accepts OAuth only. The machine endpoint /mcp-machine serves internal callers; the public edge answers 404 for it.

Consumer connections

  • Sign-in: an unauthenticated request answers 401 and points to https://mcp.argusfa.com/.well-known/oauth-protected-resource/mcp. That document names the authorization server https://auth.argusfa.com and lists, in scopes_supported, the scopes of the 20 consumer tools. A host requests those scopes; a token with fewer scopes still connects and is offered fewer tools. A signed scope only lets a tool be listed: private data also needs the owner's consent for that app.
  • Discovery: tools/list shows a consumer tool when the principal holds its scopes and grants. Pass ticker symbols as arguments, and call get_my_context before working with the user's saved items. See discovery.
  • Server help: the server sends instructions, prompts and resources; see server instructions, prompts and resources.
  • Results: structuredContent holds the envelope and content[0].text holds the same JSON. isError is false for every envelope, including unavailable, restricted and error answers, so check status first. _meta.argus carries the request id and audit ids.
  • Registry tools: the core and personal registry tools and agent_tool_registry are neither listed nor callable on /mcp; a call answers Unknown tool. Discover them through argus tool-registry or GET /v1/tool-registry and call them through the CLI or REST; see registry tools below.

First calls

An MCP client calls a consumer tool with tools/call. Asked "Give me an overview of Apple, with sources.", an AI app makes these two calls:

{"jsonrpc": "2.0", "id": 1, "method": "tools/call",
 "params": {"name": "find_security", "arguments": {"query": "Apple"}}}
{"jsonrpc": "2.0", "id": 2, "method": "tools/call",
 "params": {"name": "get_overview", "arguments": {"symbol": "AAPL"}}}
  • find_security resolves a name, ticker or CIK. Each candidate in data.candidates has its symbol, name, type, exchange, cik and coverage: full for a security captured ahead of any request, on_request for one whose data is captured when first asked for, identity_only for one Argus can name but has no data for. With one strong match, next suggests get_overview. Pass symbols, not names, to the other tools.
  • get_overview for a company gives its identity, its key filed facts for the latest fiscal year (period and facts), the latest periodic report it filed (latest_report: form, period, filing date and accession number), and recent filings and events. Every value carries a src.
  • get_sources with those src refs expands each citation to its publisher, document, date and link; a filed value names its form, accession number, filing date and report period.

AAPL is captured ahead of any request, so it answers at once. The first request about a company outside that list can answer temporarily_unavailable with retry_after_s while Argus captures it for the first time, which takes about a minute. Call again after that many seconds.

Ordinary-user login and a Python client

Owned CLI connections may use a registered opaque Argus session from argus auth login --interface mcp. The resource server resolves it through its configured identity component using the fixed MCP audience; API sessions are rejected. Existing third-party OAuth uses its actual supported management granularity. See session protocol.

With the official client (1.1.26 or later), run argus auth login --interface mcp and complete sign-in and consent in the system browser. Then run argus auth status --interface mcp; its audience must be https://mcp.argusfa.com/mcp. This uses the pre-registered public Argus client, PKCE S256 and the registered loopback callback. It stores this MCP session separately from API credentials in the OS credential store. It does not enable dynamic registration. Use argus auth refresh --interface mcp to force refresh, or argus auth logout --interface mcp to remove only the local MCP session.

The following client uses the MCP SDK installed with the official wheel. Keep the opaque session credential in memory and use the same MCP resource for initialization and calls. Do not copy an API token into an MCP configuration; the CLI/API token has a separate audience.

import asyncio
import json
from datetime import timedelta
from argus.cli.oauth import CliOAuthProfile
from argus.cli.managed_oauth import managed_client
from mcp import ClientSession
from mcp.client.streamable_http import streamable_http_client
from mcp.shared._httpx_utils import create_mcp_http_client
from mcp.shared._httpx_utils import MCP_DEFAULT_TIMEOUT, MCP_DEFAULT_SSE_READ_TIMEOUT

async def main():
    profile = CliOAuthProfile.from_environment().for_interface("mcp")
    token = managed_client(profile, "mcp").access_token()
    if token is None:
        raise RuntimeError("Run argus auth login --interface mcp first")
    async with create_mcp_http_client(
        headers={"Authorization": f"Bearer {token}"}
    ) as http:
        async with streamable_http_client(profile.audience, http_client=http) as streams:
            async with ClientSession(
                streams[0], streams[1],
                read_timeout_seconds=timedelta(
                    seconds=MCP_DEFAULT_TIMEOUT + MCP_DEFAULT_SSE_READ_TIMEOUT
                ),
            ) as session:
                await session.initialize()
                listed = {tool.name for tool in (await session.list_tools()).tools}
                if "find_security" not in listed:
                    raise RuntimeError("find_security is not listed for this connection")
                response = await session.call_tool("find_security", {"query": "AAPL"})
                if response.isError:
                    raise RuntimeError(response.content)
                result = response.structuredContent
                if result is None:
                    result = json.loads(next(
                        block.text for block in response.content if block.type == "text"
                    ))
                # consumer-result-v1: ok, partial, empty and ambiguous are answers.
                if result["status"] in {"unavailable", "restricted", "error"}:
                    raise RuntimeError(result["error"])
                print(result["summary"])

asyncio.run(main())

Discovery and successful login do not establish business completion. Check the result status, notes, sources and freshness, and follow next calls for continuations before judging the promised data range.

Hosted AI apps

A user of a hosted AI app such as Claude never handles a Client ID: the user adds the MCP address in the app and signs in, and the app uses the registration Argus made for it. The website's Connect page has the steps for each app, and supported AI apps says what has been tested.

Only Claude is registered in advance today. Any other hosted app is refused at sign-in until Argus registers it; the user can write to [email protected] and name the app. An unregistered host must first be registered by the operator; substituting a redirect or enabling dynamic client registration is not a supported workaround. The Argus loopback client above is for local CLI and Python clients only.

The MCP resource can also accept a host that identifies itself by a client metadata document, but only from a list of reviewed hosts. The list is empty, so no such host is accepted today (ADR 0015).

A private tool answers needs_permission when the owner has not allowed its access group, Memory or Holdings, for the app that called. The error's fix then holds a link to that app's own switches in the Argus web app. The owner signs in if needed, reviews and confirms, and the same call then works.

Registry tools

The core, personal, advanced and diagnostic registry tools and agent_tool_registry are not served on the public /mcp endpoint. Use the CLI or REST for them, and read their contracts in Generated Interface Contracts, personal contracts and the personal examples. Their parameters are normalized: apply each binding's parameter_aliases and parameter_encodings. Legacy financial calls return success/result/audit_id, and the 67 personal tools return per-tool personal-result-v1 models with problem and payload. Discovery of a private tool grants no access.

Boundaries

Personal tools can mutate owner-authorized watchlists, research, subscriptions and manual asset records. Sensitive account revocation and deletion use trusted owner management. MCP does not generate recommendations, trading strategies, orders or agent orchestration; the filing workflow returns structured facts and calculations for an independent agent's answer.