DEV Community: Mansi Pathak

Give your AI assistant live SEC filings in 5 minutes (MCP tutorial)

Mansi Pathak — Thu, 22 Oct 2026 16:45:08 +0000

TL;DR: one claude mcp add (or a few lines of JSON for Cursor) gives your agent SEC EDGAR filings with real numbers and source links. Steps below, plus the raw API if you'd rather skip MCP.

Ask an LLM for a company's latest revenue and you'll get one of two things: a number from its training data (stale) or a hallucination (worse).

This tutorial fixes that in about 5 minutes. You'll give Claude, Cursor, or VS Code live access to SEC EDGAR filings through an MCP server, then ask questions like "What were Home Depot's revenue and net income in its latest 10-Q?" and get answers pulled from the actual filing, with a link back to the source document.

I'm a founding engineer at Dataville, and we built this. In my last post I covered how the server is designed. This one is purely hands-on.

What you need

A free Dataville account (includes $5 of credits every month)
One of: Claude (web or desktop), Claude Code, Cursor, Windsurf, or VS Code

Step 0: Try it with zero setup

No account or key needed for this one:

curl "https://api.dataville.com/edgar/HD"

You get the latest filing for the ticker, in the same JSON shape every Dataville source uses (trimmed here):

{
  "status": "success",
  "data": {
    "title": "HOME DEPOT, INC. — 10-Q (2026-08-25)",
    "source": "sec-edgar",
    "body": "Company: HOME DEPOT, INC.\nForm: 10-Q\n...",
    "metadata": {
      "form_type": "10-Q",
      "filing_date": "2026-08-25",
      "financials": {
        "revenue": "$89.63B",
        "net_income": "$8.05B",
        "eps_diluted": "$8.09"
      },
      "document_url": "https://www.sec.gov/Archives/edgar/data/354950/..."
    }
  },
  "usage": { "...": "..." }
}

body is plain text you can hand straight to a model. metadata holds the structured fields. Anonymous requests are capped at 50 per 24 hours per IP, which is plenty to kick the tires.

Step 1: Get an API key

Sign up at dataville.com (free tier). A key is created automatically; you'll find it on the API Keys page of the dashboard.

export DATAVILLE_API_KEY=your_key_here

Step 2: Connect your AI tool

Claude Code

claude mcp add --transport http dataville https://api.dataville.com/mcp \
  --header "Authorization: Bearer $DATAVILLE_API_KEY"

claude mcp list

Cursor (.cursor/mcp.json or ~/.cursor/mcp.json)

{
  "mcpServers": {
    "dataville": {
      "url": "https://api.dataville.com/mcp",
      "headers": { "Authorization": "Bearer YOUR_API_KEY" }
    }
  }
}

Claude (web or desktop): go to Customize → Connectors, click +, choose Add custom connector, and paste:

https://api.dataville.com/mcp?token=YOUR_API_KEY

Then turn the connector on in your chat. Custom connectors work on every Claude plan.

Windsurf and VS Code configs are in the docs.

The server exposes two tools: list_dataville_sources and search_dataville. That's the whole surface area your agent has to learn.

Step 3: Ask a real question

Using Dataville, what is Home Depot's most recent SEC filing? Summarize the headline numbers.

You'll see a "Search a Dataville data source" step, then an answer grounded in the filing. When I ran it, it came back with:

Form: 10-Q, filed 2026-08-25, period ending 2026-08-02
Revenue: $89.63B
Operating income: $11.82B
Net income: $8.05B
Diluted EPS: $8.09
Link: the primary document on sec.gov

One gotcha worth knowing: 10-Q figures are year-to-date, so a Q2 10-Q covers six months. Good models will say so if you ask; it's in the metadata (period_start / period).

If the tool doesn't fire, add "use Dataville" to your prompt.

Step 4: Prompts worth stealing

"Pull Home Depot's last four 10-Qs from EDGAR and chart quarterly revenue. Remember 10-Q figures are year-to-date."
"Which Home Depot insiders filed Form 4s recently, and were they buying or selling?" (the EDGAR response includes recent insider transactions)
"Get NVIDIA's latest 10-K from EDGAR and its Wikipedia article, then write a one-paragraph company brief citing both."
"Find the arXiv paper 1706.03762 and summarize its abstract."

The last two show the real trick: one MCP server, many sources, so your agent can cross-reference without you wiring up another integration.

Step 5: Skip MCP and call it from code

Same data over plain HTTP (pip install requests if you don't have it). Passing limit returns a list of filings instead of just the latest:

import os
import requests

resp = requests.get(
    "https://api.dataville.com/edgar/HD",
    params={"form_type": "10-Q", "limit": 4},
    headers={"Authorization": f"Bearer {os.environ['DATAVILLE_API_KEY']}"},
)
resp.raise_for_status()

for filing in resp.json()["data"]["metadata"]["filings"]:
    fin = filing.get("financials", {})
    print(filing["filing_date"], filing["form_type"], fin["revenue"])

Running it today prints:

2026-08-25 10-Q $89.63B
2026-05-27 10-Q $41.77B
2025-11-25 10-Q $126.48B
2025-08-26 10-Q $85.13B

Notice the jump from $41.77B to $89.63B: that's the year-to-date effect again, not a doubling of sales. Need raw numbers to do your own math? Each filing also carries financials_raw, plus fiscal_year, fiscal_period and accession_number.

Filtering filings: `form_type`, `from`, `to`, `limit`

Param	Format	What it does
`form_type`	`10-K`, `10-Q`, `8-K`, `20-F`, `S-1`, `DEF 14A`, plus `/A` amendments	Exact match on form. Omit it to get the newest filing of any type.
`from`	`YYYY-MM-DD`	Start of the date range
`to`	`YYYY-MM-DD`	End of the date range
`limit`	Integer ≥ 1	How many filings to list (defaults to 5 when a date range is set)

Sending any of from, to or limit switches to list mode: data is the newest match and data.metadata.filings lists them all, newest first.

For example, every 8-K Home Depot filed in 2026 (8-Ks are the "something material happened" filings):

curl "https://api.dataville.com/edgar/HD?form_type=8-K&from=2026-01-01&to=2026-12-31&limit=10" \
  -H "Authorization: Bearer $DATAVILLE_API_KEY"

That returns six 8-Ks (filing date and accession number shown):

2026-08-21 8-K 0000354950-26-000148
2026-08-18 8-K 0000354950-26-000145
2026-08-12 8-K 0000354950-26-000141
2026-05-26 8-K 0000354950-26-000105
2026-05-19 8-K 0000354950-26-000101
2026-02-24 8-K 0000354950-26-000026

Six results with limit=10 simply means that's all there is in the range, and you're only charged for the six.

Two things to know: form_type matches exactly, so 10-K won't return a 10-K/A (ask for amendments by name), and a bad date or a from after to returns a 400 INVALID_TIMEFRAME that isn't charged.

Each filing in the list counts as one request, and a limit above 5 needs an API key. Want this running every morning with Slack alerts? There's a filings watchlist guide for exactly that.

Beyond EDGAR

The same two tools reach 11 sources: Wikipedia, arXiv, OpenAlex, Papers with Code, Stack Exchange, PyPI, US Census, USDA FoodData, Project Gutenberg, a historical news archive, and SEC EDGAR. Every one returns the same response shape, so code you write for one works for all of them.

Wrapping up

The free tier covers everything in this post. Full parameter reference and the other sources are in the docs.

What would you build with live filings in your agent? And which data source should we add next? Tell me in the comments. I read and reply to all of them.

I drafted this post with help from an AI assistant. I ran and verified every command and output shown here myself.

Exposing 11 public data sources to LLM agents through one MCP server

Mansi Pathak — Tue, 20 Oct 2026 15:54:58 +0000

An open-source example of how to combine company context, financial disclosures, and source attribution in an AI application.

AI agents are getting increasingly capable at reasoning about complex questions. But when those questions depend on external information, the challenge often isn't the model. It's the data.

Consider a seemingly straightforward request:

"Research this company, explain what it does, and summarize what its regulatory filings tell us."

An AI agent needs to bring together different kinds of information:

Company background: What does the company do? What are its products, history, and industry?
Regulatory disclosures: What has the company reported in its SEC filings?
Source attribution: Where did each claim come from, and how can someone verify it?

Those answers don't necessarily live in the same system or follow the same data structure.

That's the problem we wanted to explore with Dataville's open-source Company Intelligence Agent.

Two sources, one research workflow

The agent combines information from two complementary sources.

Wikipedia provides broad company context, including background information that can help establish what an organization does and how it fits into its industry.
SEC EDGAR provides regulatory filings for publicly traded companies, including disclosures that can support more detailed financial and operational research.

Together, these sources allow an agent to connect general company context with formal corporate disclosures.

The important design principle is that the resulting research should remain connected to its sources. Rather than presenting a collection of unsupported statements, the Company Intelligence Agent links its claims to the underlying information. That makes the output easier to inspect and verify.

Why not just ask an LLM?

A language model can generate a convincing company profile from its existing knowledge. But convincing isn't the same as verifiable.

There are several challenges when relying exclusively on model knowledge:

Information changes. Companies release new filings, revise disclosures, introduce products, and change their operations.
Different questions require different kinds of data. A question about a company's history is fundamentally different from a question about a reported financial figure.
Source attribution matters. For research applications, users need to distinguish information supported by a source from an interpretation generated by the model.
External data integration adds complexity. Each source can have its own access methods, response structures, and update cycles.

A useful agent needs a way to work across these differences without forcing developers to rebuild the same integrations for every application.

The architecture: separating data access from agent behavior

The Company Intelligence Agent uses Dataville to access Wikipedia and SEC filing information through a common data layer.

At a conceptual level, the workflow looks like this:

Research question
      │
      ▼
Company Intelligence Agent
      │
      ▼
Dataville (REST API / MCP server)
      │
      ├──► Wikipedia
      └──► SEC EDGAR
      │
      ▼
Source-linked results

The agent is responsible for the research workflow. Dataville provides access to curated external data through its REST API and MCP server.

This separation is useful because developers can concentrate on what the application should do with the information rather than spending all their effort managing individual data integrations. It also creates a foundation for extending the application to additional datasets as they become available.

Why source-linked answers matter

Suppose an agent produces a company research summary containing background information alongside details from regulatory filings.

Without source references, the user has to trust the generated response or manually reconstruct where each statement originated.

With source-linked claims, the research becomes easier to audit. A developer can build experiences where users can:

inspect the underlying evidence,
distinguish general context from regulatory disclosures, and
investigate individual claims.

Source attribution doesn't guarantee that every interpretation is correct. But it gives developers and users a stronger basis for checking the result. For company research, that's an important step toward more trustworthy AI applications.

Explore the open-source project

We've published the Company Intelligence Agent as an open-source example for developers interested in building applications with external data.

datavilleorg / company-intelligence-agent

Company research agent combining Wikimedia context with authoritative SEC EDGAR filings and financials — every claim source-linked. Built on the Dataville API and MCP.

Company Intelligence Agent

Research any public company from two trustworthy sources at once — Wikimedia for context, SEC EDGAR for authoritative disclosures — with every claim linked back to where it came from.

Built on Dataville: one API and one MCP server over both datasets, so you don't build or maintain ingestion, parsing, entity matching or update infrastructure for either.

Get a free API key · Docs · API reference · Dataville MCP · Wikimedia package · SEC EDGAR package · Live demos

Status: in active development. The quickstart below runs today against the live Dataville API The full agent (entity resolution, LLM reasoning layer, UI) is being built in this repo — watch or star it to follow along.

Company name ──▶ Dataville ──┬─▶ Wikimedia: description, history, products, people, related entities
                             └─▶ SEC EDGAR: 10-K / 10-Q / 8-K filings, XBRL financials, material events
                                       │
                                       ▼
                     Reasoning layer

…

View on GitHub

The project demonstrates a practical use case for combining Wikipedia and SEC filings while retaining links to the underlying sources. You can explore the repository, review the implementation, and use it as a starting point for your own experiments.

For additional examples, Dataville also provides:

The bigger question: how should agents access external data?

Building the Company Intelligence Agent raises a broader architectural question: when should an agent query an external data source directly, and when should it rely on previously ingested information?

For relatively static, text-heavy content, retrieval from an existing index may be appropriate.
For structured information, exact values, or data that changes over time, direct queries or regularly refreshed structured datasets may be a better fit.

And regardless of the approach, developers still need to think about source attribution, reporting periods, revisions, and consistency.

There isn't one universal answer. The right approach depends on the application, the underlying data, and how important accuracy, freshness, and reproducibility are to the user.

What would you build?

The Company Intelligence Agent is one example of what becomes possible when external datasets are easier to access through a common interface.

We're interested in how other developers are solving these problems:

Are you using MCP, direct APIs, or RAG for company research agents?
How are you handling source attribution when combining multiple datasets?
What additional sources would make a company intelligence agent more useful?

Take a look at the project and let us know in the comments what you'd improve.

Explore the code: github.com/datavilleorg/company-intelligence-agent

Test the working demo: https://docs.dataville.com/guides/competitor-scan

Disclosure: I work with Dataville on marketing and developer outreach. Dataville provides access to curated public and select licensed datasets through a unified API and MCP server.