Skip to main content
Glama
agentladle

mcp-dart

by agentladle

AgentLadle MCP DART

English | 中文

🇨🇳/🇭🇰 Cloud-gehostetes MCP für A-share- und HK-notierte Unternehmen (Jahres- und letzte Zwischenberichte der vergangenen 3 Jahre). Mehr lesen | API-Schlüssel erhalten

Ein MCP (Model Context Protocol)-Server, der Werkzeuge zum Entdecken, Herunterladen, Parsen und Durchsuchen koreanischer DART-Finanzberichte (금융감독원 전자공시시스템) bereitstellt.

Er ermöglicht KI-Assistenten (Claude, Cursor usw.) den Zugriff auf Koreas Open-DART-Daten über 6 strukturierte Werkzeuge – vom Auflösen eines Firmennamens bis zur Stichwortsuche in Berichtsseiten.

Funktionen

  • 6 MCP-Werkzeuge für DART-Daten: Firmennamen auflösen, Einreichungen auflisten, Herunterladen+Parsen, Inhaltsverzeichnis abrufen, Seiten lesen, Stichwortsuche

  • Vollständige Unterstützung für 정기공시-Finanzberichte — A001 사업보고서 (annual), A002 반기보고서 (semi-annual), A003 분기보고서 (quarterly), jeweils mit einem dedizierten toc.yaml-Abschnitts-Mapping, das aus echten DART-XML abgeleitet ist

  • Automatisch erkennender Multi-Format-Parser – strukturiertes SECTION-N-XML (Typen A/B/D/E) wird an den Abschnittsbaum-Parser weitergeleitet (toc.yaml falls verfügbar, sonst generische Baumextraktion); HTML-Einseiten-Offenlegungen (I001 수시공시, I002 공정공시/잠정실적) werden an den HTML-Extraktionsparser weitergeleitet. Das Format wird anhand des Dateiinhalts erkannt, nicht durch den Typ festgelegt.

  • Professionelles DART-Dokument-Parsing – direkte XML-Pfad-Extraktion (./P, ./TABLE) und standardmäßige TOC-Ausrichtung (A001: 123 Codes / 110 Blätter; A002: 53 Codes / 43 Blätter; A003: 59 Codes / 48 Blätter)

  • 章节树 + 节内限页 Paginierungsmodell – Seiten respektieren den standardmäßigen Abschnittsbaum von DART (Präzision statt fester 4000-Zeichen-Blöcke)

  • Koreanisch-bewusste Suche – Substring-Matching (keine \b-Wortgrenzen), Zeichenanzahl-TF-Normalisierung, Hinweise auf morphologische Varianten

  • Dreistufiger lokaler Cache – ZIP-Archive, extrahiertes XML und geparstes JSON werden getrennt unter ~/.agentladle/mcp-dart/data/{zip,xml,json}/ gespeichert

  • Idempotent – bereits heruntergeladene/geparste Einreichungen werden automatisch übersprungen

  • Reines Python, plattformübergreifend (Windows / macOS / Linux)

Related MCP server: MCP OpenDART

Voraussetzungen

Hinweis: Nach der Installation von uv starten Sie Ihr Terminal und den MCP-Client (z. B. Cherry Studio) neu, um sicherzustellen, dass der Befehl uv erkannt wird.

Schnellstart

Fügen Sie Folgendes zu Ihrer MCP-Client-Konfiguration hinzu (Claude Desktop, Cursor usw.):

{
  "mcpServers": {
    "mcp-dart": {
      "command": "uvx",
      "args": ["agentladle-mcp-dart"],
      "env": {
        "DART_API_KEY": "your_dart_api_key_here",
        "UV_HTTP_TIMEOUT": "300"
      }
    }
  }
}

Das war's. uvx lädt das Paket und seine Abhängigkeiten automatisch von PyPI herunter – kein Klonen, keine manuelle Installation, keine Pfadkonfiguration.

Langsames Netzwerk? Der erste uvx-Lauf lädt viele Abhängigkeiten herunter (einschließlich dart-fss, pandas usw.). Das Standard-Timeout von 30 Sekunden kann zu kurz sein und zu MCP Connection closed führen. Setzen Sie UV_HTTP_TIMEOUT auf "300", um Download-Timeouts zu vermeiden. Wenn es weiterhin fehlschlägt, verwenden Sie die unten stehende pip-Installationsalternative.

Alternative: .env-Datei

Wenn Sie den Schlüssel nicht über den Env-Block des MCP-Clients injizieren möchten, kopieren Sie .env.example in eines der folgenden Verzeichnisse:

  • ./.env (projektbezogene Überschreibung; git-ignoriert – niemals einen echten Schlüssel committen)

  • ~/.agentladle/mcp-dart/.env (benutzerglobale Standardeinstellung)

und setzen Sie:

DART_API_KEY=your_dart_api_key_here

Die erste vorhandene .env gewinnt; explizite Umgebungsvariablen, die im MCP-Client gesetzt werden, überschreiben immer .env. Einzelheiten finden Sie in .env.example.

Alternative: pip-Installation

Wenn Sie die Umgebung lieber selbst verwalten:

pip install agentladle-mcp-dart

Dann konfigurieren Sie (kein uvx erforderlich):

{
  "mcpServers": {
    "mcp-dart": {
      "command": "agentladle-mcp-dart",
      "env": { "DART_API_KEY": "your_dart_api_key_here" }
    }
  }
}

Alternative: Aus dem Quellcode ausführen (lokale Entwicklung)

Klonen Sie das Repository und führen Sie es direkt aus:

git clone https://github.com/agentladle/mcp-dart.git

Dann konfigurieren Sie Ihren MCP-Client:

{
  "mcpServers": {
    "mcp-dart": {
      "command": "uv",
      "args": ["run", "--directory", "/path/to/mcp-dart", "agentladle-mcp-dart"],
      "env": { "DART_API_KEY": "your_dart_api_key_here" }
    }
  }
}

Ersetzen Sie /path/to/mcp-dart durch den tatsächlichen Pfad zum geklonten Repository.

Datenfluss

DART OpenAPI                      Local Files (~/.agentladle/mcp-dart/data/)
────────────                      ──────────────────────────────────────────
corp_list (dart-fss)  ──→         corp_list.csv                (CSV cache, ~114k corps)
search_dart_company    ──→        corp_list.csv lookup         (Tool 6: name → stock_code)
                                     │
search_filings API     ──→        zip/{rcept_no}.zip           (Tool 2: download)
                                     │
ZIP extraction         ──→        xml/{rcept_no}/*.xml           (Tool 2: extract)
                                     │
dart_parsers + toc.yaml ──→       json/{stock_code}_{rcept_no}.json  (Tool 2: parse)
                                     │
Local TF search        ──→        search results               (Tool 5: keyword_search)
TOC (section_tree)     ──→        section_tree + page ranges   (Tool 3: get_report_toc)
Page range read        ──→        page content                 (Tool 4: get_report_pages)

Werkzeuge

#

Werkzeug

Beschreibung

1

list_dart_filings

DART-Einreichungen für ein koreanisches Unternehmen nach Aktiencode auflisten (gibt rcept_no zurück)

2

download_dart_report

Ein DART-Einreichungs-ZIP herunterladen und in einen Abschnittsbaum-JSON-Cache parsen

3

get_report_toc

Den section_tree (TOC) mit Seitenbereichen abrufen – abgeleitet aus toc.yaml, nicht heuristisch

4

get_report_pages

Seiten nach globaler Seitennummer oder nach section_code lesen

5

keyword_search

Koreanische Substring-Volltextsuche mit Zeichenanzahl-TF + Positions-Boost

6

search_dart_company

Einen Firmennamen (koreanisch/englisch) über den lokalen corp_list.csv-Cache in stock_code / corp_code auflösen

Werkzeug 1: list_dart_filings

Listet verfügbare DART-Einreichungen für ein koreanisches börsennotiertes Unternehmen auf.

Parameter

Typ

Erforderlich

Beschreibung

stock_code

string

6-stelliger koreanischer Aktiencode, z. B. "005930" (Samsung Electronics)

bgn_de

string

Startdatum YYYYMMDD (Standard: 20150101)

end_de

string

Enddatum YYYYMMDD (Standard: heute)

report_types

string[]

DART-Detailtypen zum Filtern (Standard: ["A001","A002","A003"] — 사업/반기/분기보고서)

limit

int

Maximale Anzahl zurückzugebender Einreichungen (Standard 20, max. 100)

Gibt für jede Einreichung rcept_no, rcept_dt, report_nm, corp_code, report_type und ein parseable-Flag zurück (true für jeden gültigen DART-Typ – der Parser erkennt das Dokumentformat beim Parsen automatisch).

Werkzeug 2: download_dart_report

Lädt eine einzelne DART-Einreichung herunter und parst sie. Vereint den download- und parse-Schritt des SEC-Flows in einem Schritt. Idempotent (überspringt, wenn zwischengespeichert und gültig).

Parameter

Typ

Erforderlich

Beschreibung

rcept_no

string

14-stellige DART-Eingangsnummer (aus list_dart_filings)

stock_code

string

6-stelliger Aktiencode für den JSON-Dateinamen ({stock_code}_{rcept_no}.json); wenn nicht angegeben, wird als {rcept_no}.json zwischengespeichert – die Suche funktioniert weiterhin über rcept_no

rcept_dt

string

Eingangsdatum YYYYMMDD (informativ)

report_type

string

DART-Detailtyp, Standard "A001". Jeder gültige Typ aus types.yaml wird akzeptiert; der Parser erkennt das Dokumentformat automatisch (Abschnittsbaum-XML für A/B/D/E, HTML für I001/I002).

force_parse

bool

Erneut parsen, auch wenn zwischengespeichertes JSON existiert

Werkzeug 3: get_report_toc

Ruft den vollständigen DART-section_tree (Inhaltsverzeichnis) für einen geparsten Bericht ab. Direkt aus toc.yaml erstellt, abgeglichen mit dem geparsten XML – Seitenbereiche sind maßgeblich, nicht heuristisch.

Parameter

Typ

Erforderlich

Beschreibung

rcept_no

string

14-stellige DART-Eingangsnummer

stock_code

string

Aktiencode (verbessert die Cache-Suche)

Jeder Knoten hat section_code, title, start_page, end_page, local_pages, matched (bool – ob XML diesem toc-Eintrag entspricht) und children. Übergeben Sie einen beliebigen section_code an den Parameter section_code von Werkzeug 4, um den gesamten Unterbaum zu lesen.

Werkzeug 4: get_report_pages

Liest den vollständigen Seiteninhalt nach globalem Seitenbereich oder nach section_code.

Parameter

Typ

Erforderlich

Beschreibung

rcept_no

string

14-stellige DART-Eingangsnummer

start_page

int

Startseite (1-basiert); Standard 1; ignoriert, wenn section_code gesetzt ist

page_count

int

Anzahl der zurückzugebenden Seiten (Standard 3, max. 10). Wird ignoriert, wenn end_page positiv ist.

end_page

int

Inklusive Endseite (z. B. start_page=12, end_page=14). 0 = nicht gesetzt.

section_code

string

DART-Abschnittscode (z. B. "020100"); überschreibt Seitenbereichsargumente, gibt gesamten Unterbaum zurück

stock_code

string

Aktiencode (Hilfe bei der Cache-Suche)

Werkzeug 5: keyword_search

Koreanisch-freundliche Volltextsuche. Bewertung:

  • TF = Substring-Anzahl / Anzahl der Nicht-Leerzeichen-Zeichen (Koreanisch hat keine durch Leerzeichen getrennten Wörter)

  • Positions-Boost ×1.2, wenn der erste Treffer in den oberen 20 % der Seite liegt

  • Der ALL-Match-Modus wendet einen ×2.0-Bonus an, wenn jedes Stichwort zutrifft

Parameter

Typ

Erforderlich

Beschreibung

rcept_no

string

14-stellige DART-Eingangsnummer

keywords

string[]

1–5 koreanische (oder ASCII-)Stichwörter; übergeben Sie morphologische Varianten wie ["매출", "매출액"]

match_mode

string

"ANY" (Standard) oder "ALL"

max_results

int

Maximale Treffer (Standard 5, max. 50)

stock_code

string

Aktiencode (Hilfe bei der Cache-Suche)

Jeder Treffer gibt page_number, score, keyword_hits, snippet (hervorgehoben mit **...**) und den Abschnittskontext (section_code/section_title) zurück.

Werkzeug 6: search_dart_company

Löst einen Firmennamen (koreanisch oder englisch) in einen stock_code / corp_code auf. Fragt die lokal zwischengespeicherte corp_list.csv ab (kein Netzwerkaufruf nach dem ersten Vorwärmen). Verwenden Sie dies vor list_dart_filings / download_dart_report, wenn der Benutzer ein Unternehmen mit Namen nennt, aber keinen 6-stelligen stock_code angibt.

Parameter

Type

Required

Description

query

string

Unternehmensname (koreanisch corp_name oder englisch corp_eng_name), z. B. "삼성전자" oder "Samsung"

exact

bool

true = exakte Namensübereinstimmung; false (Standard) = Groß-/Kleinschreibung ignorierende Teilstring-Suche

limit

int

Maximale Treffer (Standard 20, max. 50)

include_delisting

bool

true = auch delistete / nicht notierte Unternehmen zurückgeben; false (Standard) = nur notierte Unternehmen mit einem 6-stelligen stock_code

Jeder Treffer enthält corp_name, corp_eng_name, stock_code, corp_code, modify_date. Wenn mehrere Treffer zurückgegeben werden, wähle den korrekten stock_code und übergib ihn an list_dart_filings.

Konfiguration

Nach dem ersten Lauf wird eine Standard-Konfigurationsdatei unter ~/.agentladle/mcp-dart/config.yaml erstellt:

dart:
  api_key: ""

paths:
  data_dir: "~/.agentladle/mcp-dart/data"
  zip_dir: "~/.agentladle/mcp-dart/data/zip"
  xml_dir: "~/.agentladle/mcp-dart/data/xml"
  json_dir: "~/.agentladle/mcp-dart/data/json"

parsing:
  page_char_limit: 4000
  max_pages_per_section: 10      # soft target (precision preserved on overflow)

download:
  delay_between_requests: 0.2

DART_API_KEY-Auflösungspriorität (höchste zu niedrigste):

  1. Echte OS-Umgebungsvariable (DART_API_KEY=xxx uvx agentladle-mcp-dart)

  2. .env-Datei – zuerst ./.env, dann ~/.agentladle/mcp-dart/.env

  3. dart.api_key in ~/.agentladle/mcp-dart/config.yaml

Datenverzeichnisstruktur

~/.agentladle/mcp-dart/
├── .env                              # Optional user-global API key (git-ignored)
├── config.yaml                       # Configuration (auto-created)
└── data/
    ├── corp_list.csv                 # ~114k Korean companies (CSV cache, dart-fss)
    ├── zip/
    │   └── {rcept_no}.zip            # Original DART archive (retained after download)
    ├── xml/
    │   └── {rcept_no}/               # Extracted XML per filing
    │       ├── {rcept_no}.xml        # Main DART XML
    │       └── {rcept_no}_NNNNN.xml  # Optional attachments
    └── json/
        └── {stock_code}_{rcept_no}.json   # Parsed section_tree + pages + coverage

Dateibenennungskonvention: {stock_code}_{rcept_no}.json, wenn stock_code bekannt ist; {rcept_no}.json, wenn stock_code beim Download weggelassen wurde. find_json_file greift außerdem auf den *_{rcept_no}.json-Glob und ältere raw/- / xml/-Layouts am selben Ort zurück.

Beispielverwendung

Die Tools folgen einem EAFP-Ansatz (Easier to Ask for Forgiveness than Permission). KI-Assistenten sollten direkt versuchen zu lesen/suchen und sich auf Fehler verlassen, um Downloads auszulösen.

Szenario A: Datei ist bereits lokal vorhanden (kürzester Weg)

User: "Analyze Samsung's latest financial report."

1. keyword_search(rcept_no="<rcept_no>", keywords=["매출", "매출액", "영업이익"])
   → Returns page snippets matching the keywords immediately.

Szenario B: Datei fehlt (Fallback ausgelöst)

User: "What does LG Energy Solution's latest annual report say about R&D?"

1. keyword_search(rcept_no="<rcept_no>", keywords=["연구개발", "R&D"])
   → Error: Parsed report not found.
2. list_dart_filings(stock_code="373220", report_types=["A001"])
   → Returns the correct rcept_no.
3. download_dart_report(rcept_no="<rcept_no>")
   → Downloads ZIP, extracts XMLs, parses to JSON cache.
4. keyword_search(rcept_no="<rcept_no>", keywords=["연구개발", "R&D"])
   → Now returns hits with section context.

Szenario C: Neueste Ad-hoc-Mitteilung (Samsung-Gewinnprognose / 잠정실적)

User: "Analyze Samsung's latest earnings guidance."

1. list_dart_filings(stock_code="005930", report_types=["I002"], limit=1)
   → Returns the latest 공정공시 (e.g. 잠정실적 / provisional earnings).
2. download_dart_report(rcept_no="<rcept_no>", stock_code="005930", report_type="I002")
   → Parses the HTML single-page disclosure.
3. keyword_search(rcept_no="<rcept_no>", keywords=["매출", "영업이익", "실적"])
   → AI summarizes revenue, operating profit, and YoY change.

Technologie-Stack

Komponente

Wahl

Zweck

MCP-Framework

mcp (FastMCP)

MCP-Server mit stdio-Transport

API / Download

dart-fss (MIT)

DART-Authentifizierung, Unternehmensliste, ZIP-Download

XML-Parsing

lxml

Kern-Parser-Engine

Strukturierte Daten

pandas

corp_list-CSV-Cache (dart-fss-Abhängigkeit)

TOC / Format-Konfig

pyyaml

Lader für toc.yaml / types.yaml / formats.yaml

Suche

Python-Built-in

Zeichenanzahl-TF + Positions-Boost

Lizenz

MIT

Available Tools

6 tools
download_dart_reportA

Download and parse a single DART filing. Combines the SEC flow's download_sec_report + parse_sec_report into one step.

Args: rcept_no: 14-digit DART receipt number (from list_dart_filings) stock_code: optional 6-digit stock code for the JSON filename ({stock_code}_{rcept_no}.json). When omitted, resolves from an existing cache or uses {rcept_no}.json. rcept_dt: optional receipt date YYYYMMDD (informational) report_type: DART detail type code, default "A001". Any valid type from types.yaml is accepted; the parser auto-detects the document format. force_parse: re-parse even if a cached JSON exists

ParametersJSON Schema
NameRequiredDescriptionDefault
rcept_dtNo
rcept_noYes
stock_codeNo
force_parseNo
report_typeNoA001

Output Schema

ParametersJSON Schema
NameRequiredDescription
resultYes

TDQS

A4.7/5.0
Behavior4/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description fully carries the transparency burden. It discloses caching behavior, auto-detection of document format, and parsing routes for different report types. It lacks explicit mention of side effects like network usage, but covers core behavioral traits.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness4/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is longer but well-structured with strategy and critical rules in XML tags. Every sentence adds value, and the purpose is front-loaded. Minor room for cutting verbosity without losing meaning.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness5/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the tool's complexity (5 parameters, multiple report types, caching), the description covers workflow, error handling, auto-detection, parameter usage, and sibling relationships. The presence of an output schema complements the description.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters5/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema coverage is 0%, but the description provides rich parameter details: rcept_no's format and source, stock_code's role in file naming, rcept_dt's informational nature, report_type's default and flexibility, and force_parse's meaning. This adds significant value over the bare schema.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the tool's action ('Download and parse a single DART filing') and distinguishes it from siblings by noting it combines two SEC flow steps. This provides specificity and uniqueness.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines5/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description includes an explicit strategy that tells the agent when to invoke this tool (only on 'file not found' errors from other tools) and critical rules that prevent misuse (never assume download before search). This provides thorough usage guidance.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

get_report_pagesA

Retrieve page content from a parsed DART report.

Two modes:

  • By global page range: pass start_page + (page_count OR end_page). If both are given, end_page wins (inclusive). Per plan §Verification step 4: get_report_pages(rcept_no, start_page=12, end_page=14).

  • By section_code: pass section_code (e.g., "020100"); returns all pages in that section (overrides start_page/page_count/end_page).

Args: rcept_no: 14-digit DART receipt number start_page: Starting page number (1-based); ignored if section_code is set page_count: Consecutive pages to return (default 3, max 10). Ignored when end_page is positive. end_page: Inclusive end page (1-based). Use for start_page=12, end_page=14 style ranges (plan §Verification). 0 = interpret as not-set. section_code: Optional DART section code (e.g., "020100"); overrides start_page/page_count/end_page and returns all of that section stock_code: optional 6-digit stock code for cache hit rate

ParametersJSON Schema
NameRequiredDescriptionDefault
end_pageNo
rcept_noYes
page_countNo
start_pageNo
stock_codeNo
section_codeNo

Output Schema

ParametersJSON Schema
NameRequiredDescription
resultYes

TDQS

A4.9/5.0
Behavior5/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description clearly explains parameter interactions (end_page wins over page_count, section_code overrides others), default values, and cache hint via stock_code. No contradictions.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness4/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is well-structured with sections and bullet points, but slightly verbose with some repeated explanations (e.g., end_page winning). Still, each sentence adds value, so it remains efficient.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness5/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Despite no annotations, the description covers all aspects: modes, parameter usage, strategy, rules, and acknowledges the output schema (not shown). It is complete for an agent to use the tool correctly.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters5/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema coverage is 0%, but the description provides detailed parameter meanings, default values, interactions, and examples (e.g., stock_code for cache hit rate), going far beyond the bare schema.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the tool retrieves page content from a parsed DART report, specifies two modes (page range vs section_code), and distinguishes from sibling tools like keyword_search and get_report_toc.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines5/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description includes a <strategy> block advising to use this tool for reading large continuous blocks and to prefer keyword_search for targeted fact-finding. <critical_rules> advise keeping page_count reasonable and using get_report_toc for section_code.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

get_report_tocA

Retrieve the complete DART section_tree (Table of Contents) for a parsed report. Each entry includes start_page, end_page, local_pages, and children.

Args: rcept_no: 14-digit DART receipt number (from list_dart_filings) stock_code: optional 6-digit stock code (improves cache hit rate when JSON file naming uses standard prefix)

ParametersJSON Schema
NameRequiredDescriptionDefault
rcept_noYes
stock_codeNo

Output Schema

ParametersJSON Schema
NameRequiredDescription
resultYes

TDQS

A4.6/5.0
Behavior4/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description carries the full burden. It discloses that the tool does NOT use heuristic page-scan; section_tree is built directly from toc.yaml and parsed XML, making page ranges authoritative. It also notes that an optional stock_code improves cache hit rate, adding behavioral insight.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is well-structured with sections (main description, <strategy>, <critical_rules>, args). It is front-loaded with the key purpose. Every sentence adds value with no redundancy.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness5/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the presence of an output schema (not shown but indicated), the description need not explain return values. It adequately covers purpose, usage guidelines, behavioral transparency, and parameter semantics for a simple tool with 2 parameters (1 required) and a well-defined output.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters5/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema coverage is 0%, so the description compensates fully. It explains that rcept_no is a 14-digit DART receipt number from list_dart_filings, and stock_code is an optional 6-digit code that improves cache hit rate. This adds valuable context beyond the schema's title and default.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states it retrieves the complete DART section_tree (Table of Contents) for a parsed report, specifying entry fields (start_page, end_page, local_pages, children). This distinguishes it from siblings like get_report_pages (which reads sections) and list_dart_filings (which lists filings).

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines4/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The <strategy> block explicitly says 'Directly invoke this tool to understand the structural layout of the report' and explains that returned section_code values can be passed to get_report_pages. This provides clear guidance on when to use and how it integrates with sibling tools, though it does not explicitly state when not to use it.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

list_dart_filingsA

List DART filings for a Korean listed company by stock code.

Args: stock_code: 6-digit Korean stock code, e.g. "005930" (Samsung Electronics) bgn_de: Start date YYYYMMDD, e.g. "20230101" (optional) end_de: End date YYYYMMDD, e.g. "20241231" (optional) report_types: DART report detail types to filter (default: ["A001","A002","A003"]) limit: Maximum number of filings to return (default 20, max 100)

ParametersJSON Schema
NameRequiredDescriptionDefault
limitNo
bgn_deNo
end_deNo
stock_codeYes
report_typesNo

Output Schema

ParametersJSON Schema
NameRequiredDescription
resultYes

TDQS

A4.5/5.0
Behavior4/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description carries full burden. It discloses that the parser auto-detects format, that non-parseable types are flagged, and that omitting dates returns most recent filings. This provides useful behavioral context beyond parameter syntax.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

Description is well-structured with separate strategy and critical rules sections, concise sentences, and no redundant information. Every sentence adds distinct value.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness4/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Despite having an output schema (not shown), the description mentions that it returns rcept_no and flags non-parseable types. For a 5-parameter tool, this is sufficient to understand the tool's role and output, though additional return value details could be included.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters5/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 0%, so description compensates fully. It provides concrete examples for stock_code ('005930'), format for dates (YYYYMMDD), default values for report_types and limit, and max value for limit. All five parameters are clearly explained.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

Description uses specific verb 'List' and explicitly states resource 'DART filings for a Korean listed company by stock code'. It clearly distinguishes from sibling tool 'download_dart_report' by mentioning it returns 'rcept_no' needed for download.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines4/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The strategy section instructs to invoke this tool before downloading, and the critical rules provide concrete guidance on using return value for download_dart_report and handling date parameters. However, it does not explicitly contrast with other siblings like get_report_pages.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

search_dart_companyA

Search Korean listed companies by name (Korean or English) and return their stock_code / corp_code. Use this when the user references a company by name without providing a 6-digit stock_code.

Args: query: Company name (Korean or English), e.g. "삼성전자" or "Samsung" exact: If True, match the name exactly; if False (default), substring contains. limit: Max number of matches to return (default 20, max 50). include_delisting: If True, also return delisted / non-listed companies (those without a 6-digit stock_code). Defaults to False.

ParametersJSON Schema
NameRequiredDescriptionDefault
exactNo
limitNo
queryYes
include_delistingNo

Output Schema

ParametersJSON Schema
NameRequiredDescription
resultYes

TDQS

A4.9/5.0
Behavior5/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations provided, the description fully discloses behavior: case-insensitive matching, exact vs. substring modes, returning all candidates on multiple matches (not guessing), and the include_delisting option. No contradictions.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness4/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is well-structured with sections for strategy, critical rules, and examples. It is comprehensive but slightly lengthy; however, every sentence adds value. Front-loading the core purpose helps efficient reading.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness5/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the tool's complexity (4 parameters, ambiguity resolution, sibling coordination) and presence of an output schema, the description is complete: it explains purpose, usage, parameter details, return behavior, and provides examples. No gaps remain.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters5/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The description details all 4 parameters beyond the schema: query (Korean/English name), exact (exact match vs substring), limit (default 20, max 50), include_delisting (returns delisted companies). Schema coverage is 0%, so the description fully compensates.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the tool searches Korean listed companies by name (Korean or English) and returns stock_code/corp_code. It distinguishes from sibling tools like list_dart_filings by explicitly stating to resolve stock_code first. Examples solidify the purpose.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines5/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The <strategy> section explicitly says to invoke this tool FIRST when a company name is given without a stock_code. The <critical_rules> specify to SKIP if a stock_code is already provided and call list_dart_filings directly. This provides clear when-to-use and when-not-to-use guidance with alternatives.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections. Dates show when Glama detected each change.

  1. 6 tool updatesv0.1.0
    • First observeddownload_dart_report
    • First observedget_report_pages
    • First observedget_report_toc
    • First observedkeyword_search
    • First observedlist_dart_filings
    • First observedsearch_dart_company

TDQS

A4.7/5.0

Scored across 6 tools

Disambiguation5/5

Each tool targets a distinct task: company lookup, filing listing, downloading/parsing, table of contents retrieval, page reading, and keyword search. There is no overlap in functionality.

Naming Consistency4/5

Most tools follow a verb_noun pattern (search_dart_company, list_dart_filings, download_dart_report, get_report_toc, get_report_pages). One tool (keyword_search) uses a noun_verb structure, which is a minor deviation but still understandable.

Tool Count5/5

Six tools cover the core workflow for DART financial filings: search company, list filings, download, get structure, read pages, and search within. The count is well-scoped for the domain.

Completeness5/5

The tool set provides comprehensive coverage for a read-only financial filings system: find company, list filings, download/parse, navigate structure, read content, and search. No obvious gaps for the intended purpose.

Maintenance

ActivityMaintained
ResponsivenessNo issues

Resources

Unclaimed servers have limited discoverability.

Looking for Admin?

If you are the server author, to access and configure the admin panel.

Related MCP Connectors

Related MCP Servers

  • F
    license
    Not graded
    quality
    D
    maintenance
    Enables AI agents to query Korean listed companies' financial statements, public disclosures, executive information, and shareholder structures in real-time using the DART API.
    2
    -
  • F
    license
    C
    quality
    Not graded
    maintenance
    Enables AI assistants to access South Korea's financial disclosure system (OpenDART), allowing users to retrieve corporate financial reports, disclosure documents, shareholder information, and automatically extract and search financial statement notes through natural language queries.
    85
    -
  • A
    license
    Not graded
    quality
    D
    maintenance
    Enables AI agents to access Korean corporate disclosure data from DART, allowing natural language queries about companies, financial statements, and disclosures.
    27
    2
    MIT