mcpField
A
aether-developer

aether-developer

Remote
github.com/EvidInvestFinance0Updated 7w ago
Repository

About aether-developer

aether-developer provides search over SEC filings, earnings-call transcripts, and EU financial regulation for agents, IDEs, and code integrations. Results include cited source passages, links, and confidence scores, with a fetch mode for known documents.

Key features

  1. 01Search SEC filings and transcripts
  2. 02Search EU financial regulations
  3. 03Return cited source passages
  4. 04Scope results by issuer
  5. 05Fetch documents by identifier

Use cases

  1. 01Find risk disclosures in company filings
  2. 02Retrieve transcript remarks and first mentions
  3. 03Locate EU regulatory provisions
  4. 04Fetch sections from a known filing

MCP support

It offers a remote MCP endpoint and a stdio MCP server for client connections. Its MCP tools cover financial filings, transcripts, and regulation search.

Configuration

Remote servers need no local install. Pick your client, then copy the config or install in one click.

Endpointhttps://aether.evidinvest.com/mcp
Copy install command
Claude CodeTerminal
Cursor.cursor/mcp.json
VS Code.vscode/mcp.json
Claude Desktopclaude_desktop_config.json
Windsurf~/.codeium/windsurf/mcp_config.json

Run commands in a terminal; paste JSON into the client’s MCP config and restart. Servers that need sign-in will prompt on first connect.

All endpoints
Streamable HTTPhttps://aether.evidinvest.com/mcpAuth required
Packages
npm@evidinvest/aether-mcp0.3.3

Tools

14
ParameterTypeRequiredDescription
limitintegerNoMax hits to return (1-50, default 10).
querystringNoNatural language search query. OPTIONAL — omit it (or pass an empty string) to select FETCH MODE, which ranks nothing and returns rows in filing order. Fetch mode REQUIRES an identifier: pass `issuer` (ticker, cik or company_name) or a single-element `tickers`, optionally narrowed with `fiscal_year`; a query-less call with no identifier is rejected. Fetch fans out to sec/jp/kr/transcripts only — EU regulation has no issuer, so "every article, newest first" answers nothing.
scopeenumNoissuer (default): every corpus is scoped to the named company. cross_company: search all issuers — for questions like "who names NVIDIA as a supplier". Cross-company results are slower, relevance-ranked only, and always carry `quality_caveat`.issuer | cross_company
issuerobjectNoThe company the question is about. Pass at least one of ticker (e.g. "NVDA"), cik (e.g. "1045810"), or company_name (required for non-US issuers, which have no US ticker). Forwarded to every corpus that can use it. Strongly recommended on every call.
issuer.cikstringNoSEC CIK, any padding.
issuer.tickerstringNoUS ticker symbol.
issuer.company_namestringNoLegal or common company name; the route for non-US issuers.
corporaarrayNoOptional corpus filter. Omit to search everything (recommended). Values: sec, jp, kr, regulation, transcripts. An explicit value always wins: a filing filter (form_type / accession_number / section) narrows an OMITTED fan-out to sec/jp/kr, but naming corpora here overrides that.
quarteranyNoFiscal quarter(s) — "Q2" or ["Q1","Q2"]. Exact, case-insensitive. Applies to the EARNINGS-CALL corpus only (with issuer.ticker and fiscal_year it names one call, the natural fetch-mode request); the filing and regulation corpora ignore it.
sectionanyNoFiling section(s), matched case-insensitively as a substring of the stored label — "Item 1A" matches "Item 1A. Risk Factors". In fetch mode this is how you ask for one part of a filing. Filing corpora only; it narrows an omitted `corpora` to sec/jp/kr.
tickersarrayNoLegacy alias of `issuer`, still accepted. One symbol (e.g. ["IBM"]) is read as issuer.ticker; several (e.g. ["IBM", "MU"]) is a cross-company question and is labelled scope=cross_company, though the filter to those companies still applies. Prefer `issuer`.
form_typearrayNoOnly return these filing forms, for example ["20-F"] or ["6-K"]. Forwarded to the filing corpora (sec/jp/kr). Because an earnings segment has no form type and an EU article has none either, setting this ALSO narrows an omitted `corpora` to sec/jp/kr rather than merging rows the filter could not reach.
fiscal_yearanyNoIssuer's fiscal year as the company labels it (NVIDIA FY2027 = year ending Jan 2027). Forwarded verbatim to every corpus: on filings it is resolved from XBRL DEI fiscal-year focus where available, else from the issuer's fiscal year-end; on earnings calls it is that corpus's own labelled fiscal year. An empty year widens ±1 with a caveat.
return_formatenumNoResponse shape for the filing corpora. "chunk" (the unified default) returns the matching window only — it keeps a five-corpus merge small. "section" returns the full SEC section the chunk belongs to, "both" returns both. The earnings-call and regulation corpora ignore it; their unit is a speaker turn / an article.section | chunk | both
accession_numberstringNoExact SEC accession number. When set, the filing corpora are hard-scoped to that filing, and an omitted `corpora` narrows to sec/jp/kr. It also counts as the identifier fetch mode requires, so `{accession_number}` with no `query` is a legal fetch.

Details

From the project README

aether-developer

Everything you need to connect Aether — the search engine built for agents, over SEC filings, earnings-call transcripts, and EU financial regulation — to your LLM, your IDE, or your own code.

Every result is a ready-to-cite evidence payload: the exact filed passage, an accession-numbered citation, the sec.gov / EUR-Lex link, and a confidence score. No filing, no answer — your agent stops inventing numbers.

aether-developer/
├── docs/                — connection guides + REST API reference
│   ├── chatgpt.md       — ChatGPT Developer Mode setup
│   ├── mcp.md           — Claude / Cursor / Cline / any MCP client
│   ├── cursor.md        — Cursor specifics (one-click install)
│   └── search.md        — REST API reference (/v1/tools/*), the issuer contract, fetch mode
├── skills/              — Agent Skills (drop into ~/.claude/skills)
├── mcp/                 — @evidinvest/aether-mcp (stdio MCP server, npm)
├── clients/
│   ├── typescript/      — @evidinvest/aether-sdk (npm)
│   └── python/          — evidinvest-aether-sdk (PyPI)
└── examples/            — runnable demos + config snippets

Connect your LLM (no code)

MCP endpoint: https://api.aether.evidinvest.com/mcp · Auth: OAuth (sign in when your client prompts — free account).

ClientHowGuide
ChatGPTSettings → Apps & Connectors → Developer mode → Create connector with the URL abovedocs/chatgpt.md
Claude (web/Desktop)Settings → Connectors → Add custom connector with the URL abovedocs/mcp.md
Claude Codeclaude mcp add --transport http aether https://api.aether.evidinvest.com/mcpdocs/mcp.md
CursorAdd to Cursordocs/cursor.md
Cline / Continue / other stdio MCPnpx -y @evidinvest/aether-mcp in the client's MCP configdocs/mcp.md

Then ask: "What does Apple's latest 10-K say about supply-chain risk? Quote the passage with the sec.gov link." Name the company in the question — every tool takes an issuer, and naming it is what makes the answer scoped rather than a relevance-ranked sweep of every filer.

Teach your agent the craft (skills)

MCP gives the agent the tools; the skills/ directory teaches it the craft — tool routing, citation discipline, point-in-time transcript retrieval:

cp -r skills/aether-research ~/.claude/skills/   # Claude Code, personal

See skills/README.md for Claude Desktop / other frameworks.

Call the API from code

Four REST endpoints — the same tools MCP exposes (full reference):

POST /v1/tools/search   ← start here (unified)
POST /v1/tools/financial_search    POST /v1/tools/transcript_search    POST /v1/tools/regulation_search

Name the company, then narrow. Pass issuer on every call and the answer is scoped to that filer: fast and precise. Omit it and the call searches every issuer at once — slower, relevance-ranked only, and the response carries a quality_caveat. scope: "issuer" with no caveat is the only guarantee you got a filtered answer, so read both fields.

And query is optional: omit it, pass an identifier plus form_type / fiscal_year / section, and you get fetch mode — that filing's sections in filing order, no ranking, mode: "fetch", tens of milliseconds. If you already know which document you want, don't rank it.

TypeScript / Node
pnpm add @evidinvest/aether-sdk
import { AetherClient } from "@evidinvest/aether-sdk";

const aether = new AetherClient({ apiKey: process.env.AETHER_API_KEY });

// search: the question in `query`, the company in `issuer`
const out = await aether.financialSearch({
  query: "supply-chain concentration risk",
  issuer: { ticker: "AAPL" },
  fiscal_year: 2025,
  limit: 5,
});
if (out.quality_caveat) console.warn(out.scope, out.quality_caveat);
for (const c of out.results) {
  const start = c.metadata?.retrieval?.body_offset ?? 0; // skip the EDGAR cover page
  console.log(c.citation, c.metadata?.source_url, c.text.slice(start, start + 200));
}

// fetch: no query — Apple's latest 10-K risk factors, in filing order
const risks = await aether.financialSearch({
  issuer: { ticker: "AAPL" },
  form_type: ["10-K"],
  section: "Item 1A",
  limit: 5,
});
console.log(risks.mode); // "fetch" — and no `confidence` on any hit
Python
pip install evidinvest-aether-sdk
from aether import AetherClient

with AetherClient(api_key="ak_...") as aether:
    out = aether.financial_search(
        query="supply-chain concentration risk",
        issuer={"ticker": "AAPL"},
        fiscal_year=2025,
        limit=5,
    )
    if out.quality_caveat:
        print(out.scope, out.quality_caveat)
    for c in out.results:
        start = c.body_offset or 0          # skip the EDGAR cover page
        print(c.citation, c.metadata.get("source_url"), c.text[start : start + 200])

    # fetch: no query — Apple's latest 10-K risk factors, in filing order
    risks = aether.financial_search(
        issuer={"ticker": "AAPL"}, form_type=["10-K"], section="Item 1A", limit=5
    )
    print(risks.mode)   # "fetch" — and `confidence` is None on every hit
curl / any language
curl -sS https://api.aether.evidinvest.com/v1/tools/search \
  -H "authorization: Bearer $AETHER_API_KEY" \
  -H "content-type: application/json" \
  -d '{"query":"supply chain risk Taiwan","issuer":{"ticker":"TSM"},"limit":5}' | jq .

Docs

Get an API key

https://aether.evidinvest.com/developer/keys — anonymous calls work but are rate-limited; keys are free.

What's in the corpus

  • SEC filings — 10-K / 10-Q / 8-K, registration statements, prospectuses, press exhibits; ~10 years of S&P 500 and beyond.
  • Non-US registries — Sweden (Bolagsverket), Japan (EDINET), Korea (DART) annual reports. Reach a non-US filer by name — issuer: {company_name: "Sivers Semiconductors"} — or scope a whole market with jurisdiction: ["SE"|"JP"|"KR"].
  • Earnings calls — speaker-attributed transcripts + furnished press exhibits, with point-in-time filters (order: "earliest" finds first mentions) and the issuer's own fiscal_year + quarter.
  • EU regulation — MiFID II, MiCA, DORA, the AML package; article-level citations.

3 months free. Verify your email when you sign up and you're on the trial tier automatically — up to 5,000 API calls/hour on Aether's search tools, free for 3 months. No card required; it reverts to the free tier (100 calls/hour + paid credits) when the trial ends.

Contribute a client library

The TypeScript and Python clients are intentionally tiny — one bearer-token fetch wrapper + typed shapes for the /v1/tools/* endpoints. Porting to Go, Rust, Java, etc. is ~150 lines. Open a PR under clients/<lang>/. Whatever you write, surface scope, quality_caveat, mode and each hit's body_offset: a client that drops them leaves its users unable to tell a precise answer from an approximate one. Response fixtures to test against live in clients/fixtures/.

License

Apache-2.0 — see LICENSE.

Comments

Markdown supported

New to MCP?

From what the protocol is to installing your first server, these answers cover most first questions.

An open protocol that defines how AI applications connect to external tools and data in a uniform way. Clients talk to the model; MCP servers provide tools, resources and prompt templates. They exchange standard messages, so one server can be reused by many clients.