Turning SEC Filings into AI Fuel: Inside Moedim.Edgar’s MCP-Powered Gateway to EDGAR

If you’ve ever tried to build an AI system that reasons about public companies, you’ve probably run into the same brick wall: the SEC’s EDGAR database. It’s a goldmine of corporate disclosures, yet it feels like it was designed for humans with patience, not machines with tokens.

Moedim.Edgar steps directly into that gap. It’s a modern C#/.NET library—and a companion MCP server—that turns raw EDGAR APIs into type-safe, async-friendly building blocks for AI agents and financial applications.

In other words: this repo (https://github.com/kdcllc/Moedim.Edgar) is about turning SEC filings into AI-ready context.

---

From Legacy Feeds to AI-Native Infrastructure

At its core, [Moedim.Edgar](https://github.com/kdcllc/Moedim.Edgar) is a .NET 8 library that wraps the SEC EDGAR APIs with:

• A modern IHttpClientFactory-based HTTP client

• Strongly-typed C# models for EDGAR data structures

• Full async/await support

• Dependency injection extensions via Microsoft.Extensions.DependencyInjection

• Configurable options via a clean options pattern

The goal is not just “yet another HTTP wrapper,” but a library that feels native in contemporary .NET backends and can be dropped into real systems: microservices, data pipelines, and—most interestingly—AI assistants.

The project structure reflects that intent:

• Moedim.Edgar – the core EDGAR client: services, models, query types.

• Moedim.Edgar.Sample – a comprehensive sample app walking through all main services.

• Moedim.Edgar.Mcp – an MCP server that exposes EDGAR as tools for AI agents.

That last project is where things shift from “API client” to “AI infrastructure.”

---

Why EDGAR Matters for AI

If you’re building AI for:

• Equity research

• Corporate credit analysis

• Competitive intel

• Regulatory/compliance workflows

…you quickly realize you need structured, reliable access to:

• Company facts (revenues, assets, liabilities, etc.)

• Specific financial concepts over time

• Filings history and search by form types (10-K, 10-Q, 8-K, etc.)

• Latest filings for monitoring and alerts

• Filing-level details and document structures

Moedim.Edgar’s models and services map almost exactly onto this mental model:

• Company Lookup – resolve companies to CIKs and metadata.

• Company Facts – explore the full universe of reported facts.

• Company Concept – zoom in on a specific metric (e.g. revenue).

• Edgar Search – discovery of filings with flexible queries.

• Latest Filings – what just hit the tape.

• Filing Details – drill into specific submissions.

The sample application ships as a guided tour: configuration, service usage, pagination, error handling, and output examples. It’s less a “hello world” and more a “here’s how you’d actually wire this into a research workflow.”

---

MCP: Giving AI Agents First-Class Access to EDGAR

The most forward-looking part of the repo is Moedim.Edgar.Mcp, an implementation of a Model Context Protocol server that exposes EDGAR as a toolset to AI assistants.

Instead of having your AI agent hallucinate SEC data or rely on brittle scraping, you define tools that:

• Look up companies

• Pull company facts

• Fetch concept-specific timeseries

• Search filings

• Retrieve filing details

The MCP server is built on:

• The ModelContextProtocol C# SDK

• The Moedim.Edgar library itself

• The .NET Generic Host (Microsoft.Extensions.Hosting)

The documentation calls out:

• Self-contained binaries for Windows, macOS, and Linux (no runtime required).

• Targeting .NET 10 SDK for development, but compiled into cross-platform, self-contained applications.

• A structured TOOLS.md describing 13 tools grouped by domain:

  • Company data tools

  • Filing search tools

  • Filing details tools

  • Configuration and usage examples

  • Common financial concepts and SEC forms

This is exactly the kind of pattern we’re seeing emerge across AI ecosystems: instead of “prompting the model to Google things,” you grant the model a well-documented, typed interface to critical data systems, and let it reason on top.

Moedim.Edgar.Mcp is that interface for EDGAR.

---

Design Choices That Matter to AI Builders

Several technical choices in this repo are particularly relevant if you’re building AI-infused systems:

1. Type-Safe Financial Models

   By encoding EDGAR concepts in strongly-typed C# models, you get:

   • Safer transformations into embeddings, feature vectors, or RAG documents.

   • Less room for silent shape mismatches when serializing/deserializing data for AI pipelines.

   • Clearer documentation and discoverable APIs directly from IDE tooling.

2. Async-First API Surface

   Fetching EDGAR data is inherently I/O-bound and often pagination-heavy. Full async support throughout means:

   • You can build high-throughput ingestion services.

   • Agents can concurrently fetch multiple companies or filings without blocking threads.

   • You’re well-positioned to scale in cloud-native environments.

3. Dependency Injection as a First-Class Citizen

   Support for Microsoft.Extensions.DependencyInjection makes the EDGAR client feel like any other infrastructure dependency:

   • Register the client and services once.

   • Inject into orchestrators, background workers, or tool handlers.

   • Swap or wrap services for testing or extended logic.

This is especially key when bridging between a host (e.g., an MCP server or orchestration engine) and the low-level EDGAR API.

4. Configuration via Options

   SecEdgarOptions centralizes configuration—user agent, rate limiting behavior, base URLs, etc.—so that:

   • You can tune behavior per environment.

   • You can plug in secrets/configuration providers for regulated deployments.

   • You can adapt when the SEC inevitably adjusts its API boundaries.

---

A Path to AI-Native Financial Research

Taken together, Moedim.Edgar and Moedim.Edgar.Mcp offer a compelling blueprint for turning a legacy data source into something AI-native:

1. Normalize the data source with a robust, typed client library.

2. Provide a guided sample that demonstrates real-world usage patterns and edge cases.

3. Expose an AI-friendly protocol layer (MCP) that lets assistants call into that library safely and reliably.

4. Ship cross-platform binaries so teams can run the AI data services anywhere—locally, in containers, or on hosted environments.

This is a pattern that can be replicated for:

• Other regulators (e.g., ESMA, FCA, local securities commissions)

• Alternative data sources (shipping, satellite, ESG, credit)

• Internal enterprise systems (ERP, CRM, risk engines)

Moedim.Edgar just happens to tackle one of the most foundational public datasets in finance.

---

Why This Matters Now

As LLM-based copilots move from “answering questions” to powering workflows, they need deep, structured, and reliable access to domain data. For financial workflows, EDGAR is table stakes.

Projects like Moedim.Edgar show how you can:

• Respect the underlying API and its constraints.

• Wrap it in a developer-friendly, cloud-native .NET library.

• Then layer on an AI-native protocol (MCP) that lets assistants plug directly into the data without brittle scraping or ad-hoc glue code.

If you’re building AI systems that touch public companies, this repo is less a “nice utility” and more a reference architecture for how to turn a legacy data source into a first-class AI tool.

And if nothing else, it’s a reminder that sometimes the most impactful AI work isn’t in training bigger models—it’s in making the right data reliably available to the models we already have.