@etsquare/mcp-server-sec 0.2.0

package/dist/etsquare-client.d.ts

@@ -0,0 +1,20 @@
+/**
+ * ETSquare SEC Intelligence API client.
+ * Wraps /api/v1/* endpoints with X-API-Key authentication.
+ */
+import type { SearchInput, LookupCompanyInput, ExecuteMetricsInput, DiscoverMetricsInput } from './types.js';
+export interface ETSquareClientOptions {
+    baseUrl: string;
+    apiKey: string;
+}
+export declare class ETSquareClient {
+    private readonly baseUrl;
+    private readonly apiKey;
+    constructor(options: ETSquareClientOptions);
+    private get headers();
+    private handleResponse;
+    search(input: SearchInput): Promise<Record<string, unknown>>;
+    lookupCompany(input: LookupCompanyInput): Promise<Record<string, unknown>>;
+    executeMetrics(input: ExecuteMetricsInput): Promise<Record<string, unknown>>;
+    discoverMetrics(input: DiscoverMetricsInput): Promise<Record<string, unknown>>;
+}

package/dist/etsquare-client.js

@@ -0,0 +1,93 @@
+export class ETSquareClient {
+    constructor(options) {
+        this.baseUrl = options.baseUrl.replace(/\/$/, '');
+        this.apiKey = options.apiKey;
+    }
+    get headers() {
+        return {
+            'Content-Type': 'application/json',
+            'X-API-Key': this.apiKey,
+        };
+    }
+    async handleResponse(res) {
+        if (!res.ok) {
+            let detail = await res.text();
+            try {
+                const json = JSON.parse(detail);
+                if (json.detail) {
+                    detail = typeof json.detail === 'string' ? json.detail : JSON.stringify(json.detail);
+                }
+                else if (json.message) {
+                    detail = json.message;
+                }
+            }
+            catch {
+                // ignore parse error
+            }
+            throw new Error(`ETSquare API error (${res.status}): ${detail}`);
+        }
+        return (await res.json());
+    }
+    async search(input) {
+        const body = {
+            query: input.query,
+            mode_lock: input.mode_lock,
+            scope_lock: input.scope_lock,
+            top_k: input.top_k ?? 5,
+            include_synthesis: false,
+            skip_micro_rewrite: true,
+        };
+        if (input.tickers)
+            body.tickers = input.tickers;
+        if (input.sic_codes)
+            body.sic_codes = input.sic_codes;
+        if (input.doc_types)
+            body.doc_types = input.doc_types;
+        const res = await fetch(`${this.baseUrl}/api/v1/search`, {
+            method: 'POST',
+            headers: this.headers,
+            body: JSON.stringify(body),
+        });
+        return this.handleResponse(res);
+    }
+    async lookupCompany(input) {
+        const params = new URLSearchParams({ query: input.query });
+        if (input.limit)
+            params.set('limit', String(input.limit));
+        const res = await fetch(`${this.baseUrl}/api/v1/companies/lookup?${params}`, {
+            headers: this.headers,
+        });
+        return this.handleResponse(res);
+    }
+    async executeMetrics(input) {
+        const body = {
+            template_id: input.template_id,
+            bind_params: input.bind_params || {},
+        };
+        if (input.row_limit)
+            body.row_limit = input.row_limit;
+        const res = await fetch(`${this.baseUrl}/api/v1/metrics/execute`, {
+            method: 'POST',
+            headers: this.headers,
+            body: JSON.stringify(body),
+        });
+        return this.handleResponse(res);
+    }
+    async discoverMetrics(input) {
+        const body = {
+            question: input.question,
+        };
+        if (input.scenario)
+            body.scenario = input.scenario;
+        if (input.metric_family)
+            body.metric_family = input.metric_family;
+        if (input.max_results)
+            body.max_results = input.max_results;
+        const res = await fetch(`${this.baseUrl}/api/v1/metrics/discover`, {
+            method: 'POST',
+            headers: this.headers,
+            body: JSON.stringify(body),
+        });
+        return this.handleResponse(res);
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/index.js

@@ -0,0 +1,360 @@
+#!/usr/bin/env node
+/**
+ * @etsquare/mcp-server-sec
+ * MCP server for SEC Intelligence: search SEC filings,
+ * resolve company tickers, and execute financial metrics templates.
+ */
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { z } from 'zod';
+import { ETSquareClient } from './etsquare-client.js';
+// Guardrail keywords to detect prompt injection attempts
+const GUARDRAIL_KEYWORDS = [
+    'reset guardrails',
+    'disable guardrails',
+    'ignore guardrails',
+    'bypass guardrails',
+    'disable safety',
+    'bypass safety',
+    'disable protections',
+    'turn off protections',
+];
+function containsGuardrailBypass(payload) {
+    if (payload === null || payload === undefined)
+        return false;
+    if (typeof payload === 'string') {
+        const lower = payload.toLowerCase();
+        return GUARDRAIL_KEYWORDS.some(kw => lower.includes(kw));
+    }
+    if (Array.isArray(payload)) {
+        return payload.some(item => containsGuardrailBypass(item));
+    }
+    if (typeof payload === 'object') {
+        return Object.values(payload).some(value => containsGuardrailBypass(value));
+    }
+    return false;
+}
+function guardrailViolationResponse() {
+    return {
+        content: [{ type: 'text', text: 'Request rejected: system guardrails cannot be bypassed.' }],
+        isError: true,
+    };
+}
+// Environment configuration
+const baseUrl = process.env.ETSQUARE_BASE_URL || 'https://www.etsquare.ai';
+const apiKey = process.env.ETSQUARE_API_KEY;
+const DEBUG = process.env.DEBUG === 'true';
+function log(level, message, data) {
+    if (level === 'debug' && !DEBUG)
+        return;
+    const timestamp = new Date().toISOString();
+    const logData = data ? ` ${JSON.stringify(data)}` : '';
+    console.error(`[${timestamp}] [${level.toUpperCase()}] ${message}${logData}`);
+}
+// Validate API key
+if (!apiKey) {
+    console.error('ERROR: ETSQUARE_API_KEY environment variable is required');
+    process.exit(1);
+}
+// Initialize client
+const client = new ETSquareClient({ baseUrl, apiKey });
+log('info', `ETSquare MCP Server starting with backend: ${baseUrl}`);
+// Initialize MCP Server
+const server = new McpServer({
+    name: 'etsquare-mcp-sec',
+    version: '0.2.0',
+});
+// Tool 1: Company Lookup
+server.registerTool('etsquare_lookup_company', {
+    title: 'Look Up Company Ticker',
+    description: 'Resolve a company name or partial ticker to its official SEC ticker symbol and CIK number. ' +
+        'Call this when a user mentions a company by name (e.g., "Apple" -> AAPL, "Texas Roadhouse" -> TXRH). ' +
+        'Returns ticker, company name, CIK, and SIC industry code.',
+    inputSchema: {
+        query: z.string().min(2).describe('Company name or partial ticker to look up (e.g., "Apple", "Texas Road", "NVDA")'),
+        limit: z.number().min(1).max(10).default(5).describe('Max results to return'),
+    },
+}, async ({ query, limit }) => {
+    if (containsGuardrailBypass(query))
+        return guardrailViolationResponse();
+    try {
+        log('debug', 'Looking up company', { query });
+        const result = await client.lookupCompany({ query, limit });
+        const results = result.results || [];
+        if (results.length === 0) {
+            return { content: [{ type: 'text', text: `No companies found for: "${query}"` }] };
+        }
+        const formatted = results
+            .map((r) => {
+            let line = `${r.ticker || 'N/A'} - ${r.company_name || 'Unknown'}`;
+            if (r.cik)
+                line += ` (CIK: ${r.cik})`;
+            if (r.sic_code)
+                line += ` [SIC: ${r.sic_code}]`;
+            return line;
+        })
+            .join('\n');
+        log('info', `Company lookup returned ${results.length} results`);
+        return {
+            content: [{ type: 'text', text: `Company matches for "${query}":\n${formatted}` }],
+        };
+    }
+    catch (error) {
+        log('error', 'Company lookup failed', { error: error instanceof Error ? error.message : error });
+        return {
+            content: [{ type: 'text', text: `Lookup failed: ${error instanceof Error ? error.message : 'Unknown error'}` }],
+            isError: true,
+        };
+    }
+});
+// Tool 2: SEC Filing Search
+server.registerTool('etsquare_search', {
+    title: 'Search SEC Filings',
+    description: 'Search 1.2M+ SEC filing sections (10-K, 10-Q, 8-K) with hybrid retrieval. ' +
+        'Returns verbatim filing text with citations — best for qualitative research.\n\n' +
+        'Execution contract (required):\n' +
+        '- mode_lock: NARRATIVE (recommended) | HYBRID\n' +
+        '- scope_lock: COMPANY (specific tickers) | INDUSTRY (SIC sector) | MACRO (cross-market)\n\n' +
+        'For structured financial data (revenue, margins, ratios), use etsquare_discover_metrics + etsquare_execute_metrics instead.\n\n' +
+        'Use tickers to scope to specific companies (resolve names first with etsquare_lookup_company). ' +
+        'Results include verbatim filing text, similarity scores, and SEC source URLs.',
+    inputSchema: {
+        query: z.string().min(3).describe('What to search for in SEC filings (e.g., "customer concentration risk", "Show NVDA revenue trend")'),
+        mode_lock: z.enum(['NARRATIVE', 'HYBRID']).describe('NARRATIVE for text search, HYBRID for text + any available metrics'),
+        scope_lock: z.enum(['COMPANY', 'INDUSTRY', 'MACRO']).describe('COMPANY for specific tickers, INDUSTRY for SIC sector-wide, MACRO for cross-market'),
+        top_k: z.number().min(1).max(50).default(5).describe('Number of results to return (default: 5)'),
+        tickers: z.array(z.string()).optional().describe('Limit to specific companies by ticker (e.g., ["AAPL", "MSFT"])'),
+        doc_types: z.array(z.string()).optional().describe('Limit by SEC form type: "10-k", "10-q", "8-k"'),
+        sic_codes: z.array(z.string()).optional().describe('Limit by SIC industry code (e.g., "7372", "3674")'),
+    },
+}, async (input) => {
+    if (containsGuardrailBypass(input))
+        return guardrailViolationResponse();
+    try {
+        log('debug', 'Executing search', {
+            query: input.query,
+            mode_lock: input.mode_lock,
+            scope_lock: input.scope_lock,
+            top_k: input.top_k,
+        });
+        const result = await client.search(input);
+        const searchResults = Array.isArray(result.narrative_results)
+            ? result.narrative_results
+            : Array.isArray(result.results)
+                ? result.results
+                : [];
+        const xbrlMetrics = Array.isArray(result.xbrl_metrics)
+            ? result.xbrl_metrics
+            : [];
+        const resultCount = searchResults.length;
+        if (resultCount === 0 && xbrlMetrics.length === 0) {
+            let text = `No results found for: "${input.query}"`;
+            text += '\nTry broadening your query or removing filters.';
+            return { content: [{ type: 'text', text }] };
+        }
+        // Format narrative citations
+        const sections = [];
+        if (resultCount > 0) {
+            const formatted = searchResults
+                .slice(0, input.top_k || 5)
+                .map((r, i) => {
+                const formType = r.form_type || r.doc_subtype || '';
+                const score = r.final_score ?? r.similarity_score;
+                const lines = [
+                    `[${i + 1}] ${r.ticker || 'N/A'} — ${r.company_name || 'Unknown'} (${formType})`,
+                    `    Filed: ${r.filing_date || 'N/A'} | Section: ${r.item_code || 'N/A'} | Score: ${typeof score === 'number' ? score.toFixed(3) : 'N/A'}`,
+                ];
+                if (r.fiscal_year && r.fiscal_period) {
+                    lines[1] += ` | ${r.fiscal_period} FY${r.fiscal_year}`;
+                }
+                if (r.chunk_text) {
+                    const snippet = r.chunk_text.substring(0, 600);
+                    lines.push(`    ${snippet}${r.chunk_text.length > 600 ? '...' : ''}`);
+                }
+                const url = r.sec_url || r.source_url;
+                if (url) {
+                    lines.push(`    SEC URL: ${url}`);
+                }
+                return lines.join('\n');
+            })
+                .join('\n\n');
+            sections.push(`SEC Filing Citations (${resultCount}):\n\n${formatted}`);
+        }
+        // Format XBRL metrics if present (handles both wide-format and long-format rows)
+        if (xbrlMetrics.length > 0) {
+            const colNames = Object.keys(xbrlMetrics[0] || {}).filter((k) => !k.startsWith('_'));
+            const header = colNames.join(' | ');
+            const separator = colNames.map(() => '---').join(' | ');
+            const displayRows = xbrlMetrics.slice(0, 20);
+            const tableRows = displayRows.map((row) => colNames.map((col) => {
+                const val = row[col];
+                if (val === null || val === undefined)
+                    return 'N/A';
+                if (typeof val === 'number')
+                    return Number.isInteger(val) ? String(val) : val.toFixed(2);
+                return String(val);
+            }).join(' | '));
+            const table = [header, separator, ...tableRows].join('\n');
+            const suffix = xbrlMetrics.length > 20
+                ? `\n(Showing 20 of ${xbrlMetrics.length} rows)`
+                : '';
+            sections.push(`XBRL Metrics (${xbrlMetrics.length}):\n\n${table}${suffix}`);
+        }
+        log('info', `Search returned ${resultCount} citations, ${xbrlMetrics.length} metrics`);
+        return {
+            content: [{
+                    type: 'text',
+                    text: sections.join('\n\n---\n\n'),
+                }],
+        };
+    }
+    catch (error) {
+        log('error', 'Search failed', { error: error instanceof Error ? error.message : error });
+        return {
+            content: [{ type: 'text', text: `Search failed: ${error instanceof Error ? error.message : 'Unknown error'}` }],
+            isError: true,
+        };
+    }
+});
+// Tool 3: Execute Metrics (XBRL structured data)
+server.registerTool('etsquare_execute_metrics', {
+    title: 'Execute Financial Metrics Query',
+    description: 'Execute an XBRL metrics template by template_id to get structured financial data ' +
+        '(numbers, ratios, time series). Returns tabular rows with columns like revenue, margins, EPS, etc.\n\n' +
+        'Common bind_params: p_ticker (company ticker), p_sic_code (industry), ' +
+        'p_start_year / p_end_year (time range, e.g., 2023-2025).',
+    inputSchema: {
+        template_id: z.string().min(10).describe('Template ID for metrics execution'),
+        bind_params: z.record(z.unknown()).optional().describe('Template parameters as key-value pairs'),
+        row_limit: z.number().min(1).max(500).optional().describe('Max rows to return (default: 100)'),
+    },
+}, async (input) => {
+    if (containsGuardrailBypass(input))
+        return guardrailViolationResponse();
+    try {
+        log('debug', 'Executing metrics template', { template_id: input.template_id });
+        const result = await client.executeMetrics(input);
+        const rows = result.rows || [];
+        const rowCount = result.row_count || rows.length;
+        const truncated = result.truncated || false;
+        const columns = result.columns || [];
+        if (rowCount === 0) {
+            return {
+                content: [{
+                        type: 'text',
+                        text: `No data returned for template ${input.template_id}. Check bind_params (e.g., p_ticker, p_start_year, p_end_year).`,
+                    }],
+            };
+        }
+        const colNames = columns.length > 0 ? columns.map((c) => c.name) : Object.keys(rows[0] || {});
+        const header = colNames.join(' | ');
+        const separator = colNames.map(() => '---').join(' | ');
+        const displayRows = rows.slice(0, 20);
+        const tableRows = displayRows.map((row) => colNames.map((col) => {
+            const val = row[col];
+            if (val === null || val === undefined)
+                return 'N/A';
+            if (typeof val === 'number')
+                return Number.isInteger(val) ? String(val) : val.toFixed(2);
+            return String(val);
+        }).join(' | '));
+        const table = [header, separator, ...tableRows].join('\n');
+        const suffix = truncated || rows.length > 20
+            ? `\n\n(Showing ${displayRows.length} of ${rowCount} rows${truncated ? ', results truncated' : ''})`
+            : '';
+        log('info', `Metrics query returned ${rowCount} rows`);
+        return {
+            content: [{
+                    type: 'text',
+                    text: `Metrics data (${rowCount} rows):\n\n${table}${suffix}`,
+                }],
+        };
+    }
+    catch (error) {
+        log('error', 'Metrics execution failed', { error: error instanceof Error ? error.message : error });
+        return {
+            content: [{ type: 'text', text: `Metrics query failed: ${error instanceof Error ? error.message : 'Unknown error'}` }],
+            isError: true,
+        };
+    }
+});
+// Tool 4: Discover Metrics Templates
+server.registerTool('etsquare_discover_metrics', {
+    title: 'Discover Financial Metrics Templates',
+    description: 'Find available XBRL metrics templates by business question. ' +
+        'Returns template IDs and metadata — use the template_id with etsquare_execute_metrics.\n\n' +
+        'Example: "revenue trend by quarter" → returns matching templates with their required bind_params.\n\n' +
+        'Workflow: discover_metrics → pick template_id → execute_metrics with bind_params.',
+    inputSchema: {
+        question: z.string().min(3).describe('Business question (e.g., "revenue trend by quarter", "profit margins comparison")'),
+        scenario: z.enum(['snapshot', 'trends', 'peer_benchmark']).optional().describe('Filter by scenario type'),
+        metric_family: z.string().optional().describe('Filter by metric family: REVENUE, EARNINGS, PROFITABILITY_MARGIN, LEVERAGE_DEBT, FREE_CASH_FLOW, LIQUIDITY'),
+        max_results: z.number().min(1).max(10).default(5).optional().describe('Max templates to return'),
+    },
+}, async (input) => {
+    if (containsGuardrailBypass(input))
+        return guardrailViolationResponse();
+    try {
+        log('debug', 'Discovering metrics templates', { question: input.question });
+        const result = await client.discoverMetrics(input);
+        const templates = Array.isArray(result.templates)
+            ? result.templates
+            : [];
+        if (templates.length === 0) {
+            return {
+                content: [{
+                        type: 'text',
+                        text: `No metrics templates found for: "${input.question}"\nTry a different question or remove filters.`,
+                    }],
+            };
+        }
+        const formatted = templates
+            .map((t, i) => {
+            const lines = [
+                `[${i + 1}] ${t.title || 'Untitled'}`,
+                `    template_id: ${t.template_id}`,
+            ];
+            if (t.description)
+                lines.push(`    ${t.description}`);
+            if (t.scenario)
+                lines.push(`    Scenario: ${t.scenario}`);
+            if (t.category)
+                lines.push(`    Category: ${t.category}`);
+            if (t.required_params && Object.keys(t.required_params).length > 0) {
+                const params = Object.entries(t.required_params)
+                    .map(([k, v]) => {
+                    if (v && typeof v === 'object') {
+                        const ex = v.example !== undefined ? `, e.g. ${JSON.stringify(v.example)}` : '';
+                        return `${k} (${v.type || 'string'}${ex})`;
+                    }
+                    return `${k} (${v})`;
+                })
+                    .join(', ');
+                lines.push(`    Required params: ${params}`);
+            }
+            if (Array.isArray(t.columns) && t.columns.length > 0) {
+                lines.push(`    Output columns: ${t.columns.join(', ')}`);
+            }
+            return lines.join('\n');
+        })
+            .join('\n\n');
+        log('info', `Discovered ${templates.length} metrics templates`);
+        return {
+            content: [{
+                    type: 'text',
+                    text: `Found ${templates.length} metrics template(s) for: "${input.question}"\n\n${formatted}\n\nUse etsquare_execute_metrics with the template_id and required bind_params to get data.`,
+                }],
+        };
+    }
+    catch (error) {
+        log('error', 'Metrics discovery failed', { error: error instanceof Error ? error.message : error });
+        return {
+            content: [{ type: 'text', text: `Template discovery failed: ${error instanceof Error ? error.message : 'Unknown error'}` }],
+            isError: true,
+        };
+    }
+});
+// Start server
+const transport = new StdioServerTransport();
+await server.connect(transport);
+log('info', 'ETSquare MCP Server ready and listening on stdio');

package/dist/types.d.ts

@@ -0,0 +1,69 @@
+import { z } from 'zod';
+export declare const searchSchema: z.ZodObject<{
+    query: z.ZodString;
+    mode_lock: z.ZodEnum<["NARRATIVE", "HYBRID"]>;
+    scope_lock: z.ZodEnum<["COMPANY", "INDUSTRY", "MACRO"]>;
+    top_k: z.ZodOptional<z.ZodNumber>;
+    tickers: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    sic_codes: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    doc_types: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+}, "strip", z.ZodTypeAny, {
+    query: string;
+    mode_lock: "NARRATIVE" | "HYBRID";
+    scope_lock: "COMPANY" | "INDUSTRY" | "MACRO";
+    top_k?: number | undefined;
+    tickers?: string[] | undefined;
+    sic_codes?: string[] | undefined;
+    doc_types?: string[] | undefined;
+}, {
+    query: string;
+    mode_lock: "NARRATIVE" | "HYBRID";
+    scope_lock: "COMPANY" | "INDUSTRY" | "MACRO";
+    top_k?: number | undefined;
+    tickers?: string[] | undefined;
+    sic_codes?: string[] | undefined;
+    doc_types?: string[] | undefined;
+}>;
+export declare const lookupCompanySchema: z.ZodObject<{
+    query: z.ZodString;
+    limit: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    query: string;
+    limit?: number | undefined;
+}, {
+    query: string;
+    limit?: number | undefined;
+}>;
+export declare const executeMetricsSchema: z.ZodObject<{
+    template_id: z.ZodString;
+    bind_params: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    row_limit: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    template_id: string;
+    bind_params?: Record<string, unknown> | undefined;
+    row_limit?: number | undefined;
+}, {
+    template_id: string;
+    bind_params?: Record<string, unknown> | undefined;
+    row_limit?: number | undefined;
+}>;
+export declare const discoverMetricsSchema: z.ZodObject<{
+    question: z.ZodString;
+    scenario: z.ZodOptional<z.ZodEnum<["snapshot", "trends", "peer_benchmark"]>>;
+    metric_family: z.ZodOptional<z.ZodString>;
+    max_results: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    question: string;
+    scenario?: "snapshot" | "trends" | "peer_benchmark" | undefined;
+    metric_family?: string | undefined;
+    max_results?: number | undefined;
+}, {
+    question: string;
+    scenario?: "snapshot" | "trends" | "peer_benchmark" | undefined;
+    metric_family?: string | undefined;
+    max_results?: number | undefined;
+}>;
+export type SearchInput = z.infer<typeof searchSchema>;
+export type LookupCompanyInput = z.infer<typeof lookupCompanySchema>;
+export type ExecuteMetricsInput = z.infer<typeof executeMetricsSchema>;
+export type DiscoverMetricsInput = z.infer<typeof discoverMetricsSchema>;

package/dist/types.js

@@ -0,0 +1,25 @@
+import { z } from 'zod';
+export const searchSchema = z.object({
+    query: z.string().min(3, 'query must be at least 3 characters'),
+    mode_lock: z.enum(['NARRATIVE', 'HYBRID']),
+    scope_lock: z.enum(['COMPANY', 'INDUSTRY', 'MACRO']),
+    top_k: z.number().min(1).max(50).optional(),
+    tickers: z.array(z.string()).optional(),
+    sic_codes: z.array(z.string()).optional(),
+    doc_types: z.array(z.string()).optional(),
+});
+export const lookupCompanySchema = z.object({
+    query: z.string().min(2, 'query must be at least 2 characters'),
+    limit: z.number().min(1).max(10).optional(),
+});
+export const executeMetricsSchema = z.object({
+    template_id: z.string().min(10, 'template_id is required'),
+    bind_params: z.record(z.unknown()).optional(),
+    row_limit: z.number().min(1).max(500).optional(),
+});
+export const discoverMetricsSchema = z.object({
+    question: z.string().min(3, 'question must be at least 3 characters'),
+    scenario: z.enum(['snapshot', 'trends', 'peer_benchmark']).optional(),
+    metric_family: z.string().optional(),
+    max_results: z.number().min(1).max(10).optional(),
+});

package/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "@etsquare/mcp-server-sec",
+  "version": "0.2.0",
+  "type": "module",
+  "description": "MCP server for Claude Desktop: search 1.2M+ SEC filing sections with hybrid retrieval, XBRL templates, and company lookup.",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "bin": {
+    "etsquare-mcp-sec": "./dist/index.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "keywords": [
+    "mcp",
+    "mcp-server",
+    "claude",
+    "sec",
+    "sec-filings",
+    "xbrl",
+    "financial-analysis",
+    "search",
+    "hybrid-search"
+  ],
+  "author": "ETSquare",
+  "license": "MIT",
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "start": "node dist/index.js",
+    "dev": "ts-node src/index.ts"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.0.0",
+    "zod": "^3.23.8"
+  },
+  "devDependencies": {
+    "@types/node": "^20.11.30",
+    "typescript": "^5.4.0",
+    "ts-node": "^10.9.2"
+  }
+}