Aether Developer

io.github.EvidInvestPublished by GitHub account EvidInvestv0.3.4Updated Oct 24, 2026

Cited search over SEC filings, earnings transcripts and EU regulation, with fetch mode. 14 tools.

VerifiedStreamable HTTPWeb executableWeb Search & ScrapingFinanceBusiness & Commerce

Overview

AI-generated overview

Cited search over SEC filings, earnings-call transcripts and EU financial regulation, plus a partner marketplace for research documents and paid API queries.

What you can do
  • Search SEC filings, non-US annual reports, earnings transcripts and EU regulation, with citation-complete results and a fetch mode that returns a filing's sections in order
  • Look up who owns a stock or what a fund holds from SEC Form 13F, with quarter-over-quarter changes
  • Browse marketplace partners and search their published documents with per-document attribution and license terms
  • Route queries to partner APIs, which consumes prepaid credits
  • Manage a seller account: sign up, publish documents, register proxy endpoints, and list your own documents and endpoints
When to use it
Useful when an assistant must answer finance and regulatory questions with quotable, linkable sources instead of recalled numbers — for example quoting a 10-K risk factor, a CFO remark on an earnings call, or a MiCA article. Also relevant if you want to sell research documents or an API through the Aether marketplace.
Requirements
Remote MCP endpoint with OAuth sign-in, or the npm package @evidinvest/aether-mcp run via npx for stdio clients. An optional AETHER_API_KEY (ak_…) can be supplied; if unset, the package runs an OAuth 2.0 device flow on first run. The Authorization header takes a bearer key. Anonymous calls are allowed at 5 per hour. Network access required.
Before you install
The Authorization header carries a secret API key, and seller_signup returns an API key shown only once. partner_proxy_search spends prepaid Aether credits on every call regardless of results, and seller_register_endpoint stores an auth secret for your endpoint and sets a per-call price. Seller tools create accounts, publish or replace documents, and register endpoints that route traffic. Queries and documents are sent to Aether's servers and, for proxy mode, to partner endpoints.

Installation

In SourceWeft

  1. Open Aether Developer in the dashboard and add it to a workspace.
  2. Enable the server for the chats that should use its tools.

Web executable via Streamable HTTP. Remote servers run from the web runtime once configured in a workspace.

Use with an agent

Paste this prompt into Claude Code, Codex, Cursor or another agent — or into SourceWeft chat. The agent reads this server's install guide, shows you its publisher, endpoint and sign-in, and adds it to your client once you agree. Keys never go into a command.

Read https://sourceweft.com/mcp/io.github.EvidInvest%2Faether-developer/install.md and connect the MCP server it describes to my client. Before changing any config, show me its publisher, endpoint and sign-in method and wait for my OK. Never put an API key in a command or in a file I would commit; ask me where it should come from.

Read the install guide the agent follows

Other MCP clients

Add this to your client's mcpServers config.

{
  "mcpServers": {
    "aether-developer": {
      "type": "http",
      "url": "https://aether.evidinvest.com/mcp"
    }
  }
}

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
Cursor[Add to Cursor]docs/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:

bash
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

bash
pnpm add @evidinvest/aether-sdk
ts
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 orderconst 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

bash
pip install evidinvest-aether-sdk
python
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

bash
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.

Source: README.md at commit d1ee068

Tools

14

holdings_by_security

Institutional holders of a stock (13F)

Who owns a stock: institutional holders of a security from SEC Form 13F, ranked by position value, with quarter-over-quarter share changes. Answers 'who are the largest holders of NVDA', 'which funds added or trimmed this quarter', 'did anyone initiate a new position'. Give a ticker (resolved via CUSIP) or a CUSIP directly. Each holder row carries its accession number and an EDGAR source_url so the figure is verifiable against the primary filing. Coverage: quarter ends from 2024-12-31 through 2026-06-30, all ~10,000 filing managers, not just large ones; the newest quarter is still filling in as filers submit, so its holder_count is lower than a settled quarter's. Positions are aggregated per filer CIK — a single 13F contains one line per sub-manager (BlackRock's carries 42 separate NVDA lines), so per-line reading understates holders badly. One book per filer: the original 13F-HR, or the 13F-HR/A RESTATEMENT that replaced it (add-on amendments are excluded); values are USD even where the filer reported in thousands. Note total_value_usd is the sum across filers and may double-count where combination reports include other managers' holdings; coverage_caveat flags this when relevant. 13F covers US-listed long equity and options only — it does not show shorts, cash, bonds, or non-US listings, and is filed 45 days after quarter end.

Parameterscusiplimitissuerperiodticker

holdings_by_manager

A fund's reported equity book (13F)

What a fund owns: an institutional manager's reported equity book from SEC Form 13F — top positions by value, with quarter-over-quarter share changes and new/increased/decreased flags. Answers 'what does Bridgewater hold', 'what did this fund buy last quarter', 'show me their largest positions'. Look up by manager name (partial match; the largest matching filer wins, since names like 'Vanguard' map to several distinct CIKs) or by exact CIK. Also returns the filer's published contact details — signatory, title, phone, and business address from the filing's cover page and signature block, each citable to the accession number. EDGAR publishes no email address for 13F filers, so none is returned and none should be inferred. Coverage: quarter ends from 2024-12-31 through 2026-06-30; the newest quarter is still filling in as filers submit, and a manager who has not filed it yet falls back to their most recent quarter, named in coverage_caveat. 13F covers US-listed long equity and options only — no shorts, cash, bonds or non-US listings — and is filed 45 days after quarter end, so it is a lagged snapshot, not a live portfolio.

Parametersciklimitissuerperiodmanager

list_partners

List data partners

List active marketplace partners (sellers) and what each offers. Each partner has zero or more 'modes': `indexed` (free queries via partner_search against published documents) and/or `proxy` (queries routed server-to-server to the seller's own API via partner_proxy_search, consuming prepaid Aether credits per call). Use the returned per-call credit costs to budget calls before invoking partner_proxy_search.

Parametersmodelimitticker

seller_signup

Register as a data seller

Create a new marketplace seller account. Returns an API key (shown once). New accounts default to status='pending_review' — they can publish documents and register endpoints, but content is not surfaced in search until ops approves the account. Use the `invite_code` arg if the operator gave you one to bypass review.

Parametersslugrequiredorg_namerequireddescriptioninvite_codecontact_emailrequired

seller_publish_document

Publish a seller document

Publish (or update) a document into the marketplace. The content is chunked + embedded + indexed by a background worker; status moves from `pending` to `indexed` once that completes. Re-publishing the same external_doc_id replaces the prior version. Account must be status='active' for the worker to index; pending_review accounts queue indefinitely.

Parameterstitlecontentrequiredlicensedoc_typemetadatasource_urlseller_api_keyrequiredexternal_doc_idrequiredticker_coverage

seller_register_endpoint

Register a seller endpoint

Register a proxy endpoint (Mode B). Aether stores your auth secret encrypted at rest (AES-256-GCM) and routes agent queries server-to-server — agents never see your URL or token. Charge per call via the `price_per_call_usd_cents` field. Account must be status='active' for traffic to be routed.

Parametersurlrequiredslugrequiredsecretauth_methoddescriptionhttp_methoddisplay_namerequiredpricing_modeltaxonomy_tagsseller_api_keyrequiredticker_coverageauth_header_name+4 more

seller_list_my_documents

List my published documents

List documents this seller has published. Returns status (pending / indexed / failed / revoked) and the indexed chunk count (`indexed_chunk_count`; the legacy alias `vespa_chunk_count` carries the same value for one release).

Parametersseller_api_keyrequired

seller_list_my_endpoints

List my registered endpoints

List proxy endpoints this seller has registered. Secrets are never returned — only a `secret_configured` boolean.

Parametersseller_api_keyrequired

Version history

1
  1. v0.3.4LatestSep 16, 2026

Score

100% of the applicable checks met

How complete this listing is, computed from the registry entry, the endpoint and public sources. Not a rating of the server and not a statement that it is safe or working today: reachability is a dated check, and no installs or reviews go into the score.

  • Reached in the last 30 daysRequired25 pts
  • Auth declaredRequired10 pts
  • Tools listedRequired15 pts
  • DescriptionRequired15 pts
  • Logo10 pts
  • Documentation15 pts
  • License10 pts