@songyaeji/security-paper-mcp-server 1.0.0

package/README.md

@@ -0,0 +1,112 @@
+# Security Paper Search MCP Server
+
+보안 학회 논문을 검색하는 MCP (Model Context Protocol) 서버입니다.
+
+## 지원 컨퍼런스
+
+### Top-Tier (4대 학회)
+- **S&P** (IEEE Symposium on Security and Privacy)
+- **USENIX Security** (USENIX Security Symposium)
+- **CCS** (ACM Conference on Computer and Communications Security)
+- **NDSS** (Network and Distributed System Security Symposium)
+
+### Second-Tier
+- **ACSAC** (Annual Computer Security Applications Conference)
+- **RAID** (Research in Attacks, Intrusions and Defenses)
+- **ESORICS** (European Symposium on Research in Computer Security)
+
+## 설치
+
+```bash
+npm install
+npm run build
+```
+
+## Claude Code에서 사용하기
+
+`~/.claude/claude_desktop_config.json` 또는 `settings.json`에 추가:
+
+```json
+{
+  "mcpServers": {
+    "security-papers": {
+      "command": "node",
+      "args": ["<절대경로>/security-paper-mcp-server/dist/index.js"]
+    }
+  }
+}
+```
+
+## 제공 도구 (Tools)
+
+### 1. search_papers
+논문 검색 (키워드, 저자, 연도, 컨퍼런스 필터)
+
+```
+search_papers(
+  keyword: "fuzzing",        // 검색 키워드
+  author: "John Smith",      // 저자명
+  yearFrom: 2022,            // 시작 연도
+  yearTo: 2024,              // 종료 연도
+  conferences: ["sp", "ccs"], // 특정 컨퍼런스
+  tier: "top",               // top, second, all
+  limit: 50                  // 최대 결과 수
+)
+```
+
+### 2. get_conference_papers
+특정 컨퍼런스의 특정 연도 논문 조회
+
+```
+get_conference_papers(
+  conference: "sp",  // sp, usenix, ccs, ndss, acsac, raid, esorics
+  year: 2024
+)
+```
+
+### 3. list_conferences
+지원되는 컨퍼런스 목록 확인
+
+```
+list_conferences()
+```
+
+### 4. get_stats
+검색 결과 통계 (연도별, 컨퍼런스별)
+
+```
+get_stats(
+  keyword: "malware",
+  tier: "top"
+)
+```
+
+## 사용 예시
+
+Claude에게 다음과 같이 요청하면 됩니다:
+
+- "2024년 S&P 논문 중 fuzzing 관련 논문 찾아줘"
+- "CCS와 NDSS에서 발표된 malware 분석 논문 검색해줘"
+- "2022년부터 2024년까지 top-tier 학회의 LLM 보안 관련 논문 찾아줘"
+- "USENIX Security 2023 논문 목록 보여줘"
+
+## 데이터 소스
+
+이 서버는 [DBLP](https://dblp.org) API를 사용하여 논문 정보를 검색합니다.
+
+## 개발
+
+```bash
+# 개발 모드 실행
+npm run dev
+
+# 빌드
+npm run build
+
+# 실행
+npm start
+```
+
+## 라이선스
+
+MIT

package/dist/conferences.json

@@ -0,0 +1,115 @@
+{
+    "conferences": {
+        "top_tier": {
+            "sp": {
+                "name": "IEEE Symposium on Security and Privacy (S&P/Oakland)",
+                "shortName": "S&P",
+                "tier": "top",
+                "urls": {
+                    "2020": "https://www.ieee-security.org/TC/SP2020/program-papers.html",
+                    "2021": "https://www.ieee-security.org/TC/SP2021/program-papers.html",
+                    "2022": "https://www.ieee-security.org/TC/SP2022/program-papers.html",
+                    "2023": "https://www.ieee-security.org/TC/SP2023/program-papers.html",
+                    "2024": "https://www.ieee-security.org/TC/SP2024/program-papers.html",
+                    "2025": "https://www.ieee-security.org/TC/SP2025/program-papers.html"
+                },
+                "dblpKey": "conf/sp"
+            },
+            "usenix": {
+                "name": "USENIX Security Symposium",
+                "shortName": "USENIX Security",
+                "tier": "top",
+                "urls": {
+                    "2020": "https://www.usenix.org/conference/usenixsecurity20/technical-sessions",
+                    "2021": "https://www.usenix.org/conference/usenixsecurity21/technical-sessions",
+                    "2022": "https://www.usenix.org/conference/usenixsecurity22/technical-sessions",
+                    "2023": "https://www.usenix.org/conference/usenixsecurity23/technical-sessions",
+                    "2024": "https://www.usenix.org/conference/usenixsecurity24/technical-sessions",
+                    "2025": "https://www.usenix.org/conference/usenixsecurity25/technical-sessions"
+                },
+                "dblpKey": "conf/uss"
+            },
+            "ccs": {
+                "name": "ACM Conference on Computer and Communications Security (CCS)",
+                "shortName": "CCS",
+                "tier": "top",
+                "urls": {
+                    "2020": "https://www.sigsac.org/ccs/CCS2020/accepted-papers.html",
+                    "2021": "https://www.sigsac.org/ccs/CCS2021/accepted-papers.html",
+                    "2022": "https://www.sigsac.org/ccs/CCS2022/program/accepted-papers.html",
+                    "2023": "https://www.sigsac.org/ccs/CCS2023/tocs/tocs-ccs23.html",
+                    "2024": "https://www.sigsac.org/ccs/CCS2024/program/accepted-papers.html",
+                    "2025": "https://www.sigsac.org/ccs/CCS2025/accepted-papers/"
+                },
+                "dblpKey": "conf/ccs"
+            },
+            "ndss": {
+                "name": "Network and Distributed System Security Symposium (NDSS)",
+                "shortName": "NDSS",
+                "tier": "top",
+                "urls": {
+                    "2020": "https://www.ndss-symposium.org/ndss2020/accepted-papers/",
+                    "2021": "https://www.ndss-symposium.org/ndss2021/accepted-papers/",
+                    "2022": "https://www.ndss-symposium.org/ndss2022/accepted-papers/",
+                    "2023": "https://www.ndss-symposium.org/ndss2023/accepted-papers/",
+                    "2024": "https://www.ndss-symposium.org/ndss2024/accepted-papers/",
+                    "2025": "https://www.ndss-symposium.org/ndss2025/accepted-papers/"
+                },
+                "dblpKey": "conf/ndss"
+            }
+        },
+        "second_tier": {
+            "acsac": {
+                "name": "Annual Computer Security Applications Conference (ACSAC)",
+                "shortName": "ACSAC",
+                "tier": "second",
+                "urls": {
+                    "2020": "https://www.acsac.org/2020/program/papers/",
+                    "2021": "https://www.acsac.org/2021/program/papers/",
+                    "2022": "https://www.acsac.org/2022/program/papers/",
+                    "2023": "https://www.acsac.org/2023/program/papers/",
+                    "2024": "https://www.acsac.org/2024/program/"
+                },
+                "dblpKey": "conf/acsac"
+            },
+            "raid": {
+                "name": "International Symposium on Research in Attacks, Intrusions and Defenses (RAID)",
+                "shortName": "RAID",
+                "tier": "second",
+                "urls": {
+                    "2020": "https://raid2020.org/accepted-papers/",
+                    "2021": "https://dl.acm.org/doi/proceedings/10.1145/3471621",
+                    "2022": "https://dblp.org/db/conf/raid/raid2022.html",
+                    "2023": "https://dblp.org/db/conf/raid/raid2023.html",
+                    "2024": "https://raid2024.github.io/accepted_open.html"
+                },
+                "dblpKey": "conf/raid"
+            },
+            "esorics": {
+                "name": "European Symposium on Research in Computer Security (ESORICS)",
+                "shortName": "ESORICS",
+                "tier": "second",
+                "urls": {
+                    "2020": "https://dblp.org/db/conf/esorics/esorics2020-1.html",
+                    "2021": "https://esorics2021.athene-center.de/program.php",
+                    "2022": "https://esorics2022.compute.dtu.dk/program.html",
+                    "2023": "https://esorics2023.org/program/",
+                    "2024": "https://dblp.org/db/conf/esorics/esorics2024-1.html"
+                },
+                "dblpKey": "conf/esorics"
+            }
+        }
+    },
+    "dblpBaseUrl": "https://dblp.org/search/publ/api",
+    "alternativeSources": {
+        "dblp": {
+            "description": "DBLP Computer Science Bibliography - comprehensive paper database",
+            "searchUrl": "https://dblp.org/search/publ/api?q={query}+venue:{venue}&format=json",
+            "venueUrl": "https://dblp.org/db/conf/{venue}/index.html"
+        },
+        "semanticScholar": {
+            "description": "Semantic Scholar API for paper metadata",
+            "searchUrl": "https://api.semanticscholar.org/graph/v1/paper/search"
+        }
+    }
+}

package/dist/index.d.ts

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

package/dist/index.js

@@ -0,0 +1,170 @@
+#!/usr/bin/env node
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import * as z from 'zod';
+import { searchPapers, searchByConference, listAvailableConferences, getAvailableYears, getConferenceInfo } from './paperSearch.js';
+const server = new McpServer({
+    name: 'security-paper-search',
+    version: '1.0.0'
+});
+// Tool 1: Search papers with various filters
+server.registerTool('search_papers', {
+    title: 'Search Security Papers',
+    description: `Search for security research papers from top-tier (S&P, USENIX Security, CCS, NDSS) and second-tier (ACSAC, RAID, ESORICS) conferences.
+
+Supports filtering by:
+- keyword: Search in paper titles
+- author: Author name
+- yearFrom/yearTo: Year range (2020-present)
+- conferences: Specific conference keys (sp, usenix, ccs, ndss, acsac, raid, esorics)
+- tier: "top", "second", or "all"`,
+    inputSchema: {
+        keyword: z.string().optional().describe('Keyword to search in paper titles'),
+        author: z.string().optional().describe('Author name to search'),
+        yearFrom: z.number().min(2020).max(2026).optional().describe('Start year (default: 2020)'),
+        yearTo: z.number().min(2020).max(2026).optional().describe('End year (default: current year)'),
+        conferences: z.array(z.string()).optional().describe('Conference keys: sp, usenix, ccs, ndss, acsac, raid, esorics'),
+        tier: z.enum(['top', 'second', 'all']).optional().describe('Conference tier filter'),
+        limit: z.number().min(1).max(200).optional().describe('Max results (default: 50)')
+    }
+}, async (args) => {
+    try {
+        const papers = await searchPapers({
+            keyword: args.keyword,
+            author: args.author,
+            yearFrom: args.yearFrom || 2020,
+            yearTo: args.yearTo || new Date().getFullYear(),
+            conferences: args.conferences,
+            tier: args.tier || 'all',
+            limit: args.limit || 50
+        });
+        const resultText = papers.length > 0
+            ? `Found ${papers.length} papers:\n\n${papers.map((p, i) => `${i + 1}. "${p.title}"\n   Authors: ${p.authors.join(', ')}\n   Conference: ${p.conference} ${p.year} (${p.tier}-tier)\n   Paper URL: ${p.url || 'N/A'}${p.conferenceUrl ? `\n   Conference Page: ${p.conferenceUrl}` : ''}`).join('\n\n')}`
+            : 'No papers found matching your criteria.';
+        return {
+            content: [{ type: 'text', text: resultText }]
+        };
+    }
+    catch (error) {
+        return {
+            content: [{ type: 'text', text: `Error searching papers: ${error}` }],
+            isError: true
+        };
+    }
+});
+// Tool 2: Get papers from a specific conference and year
+server.registerTool('get_conference_papers', {
+    title: 'Get Conference Papers',
+    description: 'Get all papers from a specific security conference in a specific year.',
+    inputSchema: {
+        conference: z.enum(['sp', 'usenix', 'ccs', 'ndss', 'acsac', 'raid', 'esorics'])
+            .describe('Conference key'),
+        year: z.number().min(2020).max(2026)
+            .describe('Conference year')
+    }
+}, async ({ conference, year }) => {
+    try {
+        const confInfo = getConferenceInfo(conference);
+        const papers = await searchByConference(conference, year);
+        const resultText = papers.length > 0
+            ? `${confInfo?.name || conference} ${year} - Found ${papers.length} papers:\n\n${papers.map((p, i) => `${i + 1}. "${p.title}"\n   Authors: ${p.authors.join(', ')}\n   Paper URL: ${p.url || 'N/A'}${p.conferenceUrl ? `\n   Conference Page: ${p.conferenceUrl}` : ''}`).join('\n\n')}`
+            : `No papers found for ${conference} ${year}.`;
+        return {
+            content: [{ type: 'text', text: resultText }]
+        };
+    }
+    catch (error) {
+        return {
+            content: [{ type: 'text', text: `Error: ${error}` }],
+            isError: true
+        };
+    }
+});
+// Tool 3: List available conferences
+server.registerTool('list_conferences', {
+    title: 'List Available Conferences',
+    description: 'List all supported security conferences with their keys and full names.',
+    inputSchema: {}
+}, async () => {
+    const { topTier, secondTier } = listAvailableConferences();
+    const years = getAvailableYears();
+    const text = `## Supported Security Conferences
+
+### Top-Tier (Big 4)
+${topTier.map(c => `- **${c.shortName}** (key: \`${c.key}\`)\n  ${c.name}\n  Available years: ${c.years.join(', ')}`).join('\n')}
+
+### Second-Tier
+${secondTier.map(c => `- **${c.shortName}** (key: \`${c.key}\`)\n  ${c.name}\n  Available years: ${c.years.join(', ')}`).join('\n')}
+
+### Data Source
+- Primary: DBLP (reliable, structured API)
+- Conference URLs: Reference links to official conference pages
+
+### Available Years
+${years.join(', ')}
+
+### Usage Examples
+- Search by keyword: \`search_papers(keyword: "fuzzing")\`
+- Search by author: \`search_papers(author: "John Smith")\`
+- Filter by year: \`search_papers(yearFrom: 2023, yearTo: 2024)\`
+- Specific conference: \`get_conference_papers(conference: "sp", year: 2024)\`
+- Top-tier only: \`search_papers(keyword: "malware", tier: "top")\``;
+    return {
+        content: [{ type: 'text', text: text }]
+    };
+});
+// Tool 4: Get conference statistics
+server.registerTool('get_stats', {
+    title: 'Get Paper Statistics',
+    description: 'Get statistics about papers matching search criteria (count by year, conference, etc.)',
+    inputSchema: {
+        keyword: z.string().optional().describe('Keyword to search'),
+        tier: z.enum(['top', 'second', 'all']).optional().describe('Conference tier')
+    }
+}, async ({ keyword, tier }) => {
+    try {
+        const papers = await searchPapers({
+            keyword,
+            tier: tier || 'all',
+            limit: 200
+        });
+        // Group by year
+        const byYear = {};
+        const byConference = {};
+        for (const paper of papers) {
+            byYear[paper.year] = (byYear[paper.year] || 0) + 1;
+            byConference[paper.conference] = (byConference[paper.conference] || 0) + 1;
+        }
+        const text = `## Paper Statistics${keyword ? ` for "${keyword}"` : ''}
+
+**Total papers found:** ${papers.length}
+
+### By Year
+${Object.entries(byYear)
+            .sort(([a], [b]) => Number(b) - Number(a))
+            .map(([year, count]) => `- ${year}: ${count} papers`)
+            .join('\n')}
+
+### By Conference
+${Object.entries(byConference)
+            .sort(([, a], [, b]) => b - a)
+            .map(([conf, count]) => `- ${conf}: ${count} papers`)
+            .join('\n')}`;
+        return {
+            content: [{ type: 'text', text: text }]
+        };
+    }
+    catch (error) {
+        return {
+            content: [{ type: 'text', text: `Error: ${error}` }],
+            isError: true
+        };
+    }
+});
+// Start the server
+async function main() {
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    console.error('Security Paper Search MCP Server running on stdio');
+}
+main().catch(console.error);

package/dist/paperSearch.d.ts

@@ -0,0 +1,22 @@
+import { Paper, SearchOptions, ConferenceInfo } from './types.js';
+export declare function getAllConferences(): Record<string, ConferenceInfo>;
+export declare function getConferencesByTier(tier: 'top' | 'second' | 'all'): Record<string, ConferenceInfo>;
+export declare function getConferenceInfo(key: string): ConferenceInfo | undefined;
+export declare function getConferenceWebsiteUrl(key: string, year: number): string | undefined;
+export declare function searchPapers(options: SearchOptions): Promise<Paper[]>;
+export declare function searchByConference(conferenceKey: string, year: number): Promise<Paper[]>;
+export declare function listAvailableConferences(): {
+    topTier: {
+        key: string;
+        name: string;
+        shortName: string;
+        years: string[];
+    }[];
+    secondTier: {
+        key: string;
+        name: string;
+        shortName: string;
+        years: string[];
+    }[];
+};
+export declare function getAvailableYears(): number[];

package/dist/paperSearch.js

@@ -0,0 +1,187 @@
+import conferencesData from './conferences.json' with { type: 'json' };
+const conferences = conferencesData;
+// DBLP venue key mappings for accurate matching
+const DBLP_VENUE_MAPPINGS = {
+    'sp': ['sp', 'ieee symposium on security and privacy', 's&p', 'oakland'],
+    'usenix': ['uss', 'usenix security', 'usenix security symposium'],
+    'ccs': ['ccs', 'acm ccs', 'computer and communications security'],
+    'ndss': ['ndss', 'network and distributed system security'],
+    'acsac': ['acsac', 'annual computer security applications'],
+    'raid': ['raid', 'research in attacks', 'intrusions and defenses'],
+    'esorics': ['esorics', 'european symposium on research in computer security']
+};
+export function getAllConferences() {
+    return {
+        ...conferences.conferences.top_tier,
+        ...conferences.conferences.second_tier
+    };
+}
+export function getConferencesByTier(tier) {
+    if (tier === 'top') {
+        return conferences.conferences.top_tier;
+    }
+    else if (tier === 'second') {
+        return conferences.conferences.second_tier;
+    }
+    return getAllConferences();
+}
+export function getConferenceInfo(key) {
+    const all = getAllConferences();
+    return all[key.toLowerCase()];
+}
+// Get conference website URL for a specific year
+export function getConferenceWebsiteUrl(key, year) {
+    const conf = getConferenceInfo(key);
+    if (!conf)
+        return undefined;
+    return conf.urls[year.toString()];
+}
+function buildDblpQuery(options) {
+    const parts = [];
+    if (options.keyword) {
+        parts.push(options.keyword);
+    }
+    if (options.author) {
+        parts.push(`author:${options.author}`);
+    }
+    // Build venue filter
+    const targetConferences = options.conferences?.length
+        ? options.conferences
+        : Object.keys(getConferencesByTier(options.tier || 'all'));
+    const venueQueries = targetConferences
+        .map(c => {
+        const conf = getConferenceInfo(c);
+        return conf?.dblpKey;
+    })
+        .filter(Boolean);
+    if (venueQueries.length > 0) {
+        // DBLP uses venue: prefix for conference filtering
+        const venueFilter = venueQueries.map(v => `venue:${v}:`).join('|');
+        parts.push(venueFilter);
+    }
+    return parts.join(' ');
+}
+// Improved venue matching using multiple identifiers
+function matchConference(venue) {
+    const venueLower = venue.toLowerCase();
+    const allConfs = getAllConferences();
+    for (const [key, conf] of Object.entries(allConfs)) {
+        // Check against DBLP key
+        if (venueLower.includes(conf.dblpKey)) {
+            return { key, conf };
+        }
+        // Check against known venue mappings
+        const mappings = DBLP_VENUE_MAPPINGS[key] || [];
+        for (const mapping of mappings) {
+            if (venueLower.includes(mapping)) {
+                return { key, conf };
+            }
+        }
+        // Check against short name
+        if (venueLower.includes(key) || venueLower.includes(conf.shortName.toLowerCase())) {
+            return { key, conf };
+        }
+    }
+    return null;
+}
+export async function searchPapers(options) {
+    const query = buildDblpQuery(options);
+    const limit = options.limit || 50;
+    const url = new URL('https://dblp.org/search/publ/api');
+    url.searchParams.set('q', query);
+    url.searchParams.set('format', 'json');
+    url.searchParams.set('h', limit.toString()); // max hits
+    try {
+        const response = await fetch(url.toString(), {
+            headers: {
+                'User-Agent': 'SecurityPaperMCP/1.0'
+            }
+        });
+        if (!response.ok) {
+            throw new Error(`DBLP API error: ${response.status}`);
+        }
+        const data = await response.json();
+        const hits = data.result?.hits?.hit || [];
+        const papers = [];
+        for (const hit of hits) {
+            const info = hit.info;
+            const year = parseInt(info.year, 10);
+            // Apply year filter
+            if (options.yearFrom && year < options.yearFrom)
+                continue;
+            if (options.yearTo && year > options.yearTo)
+                continue;
+            // Extract authors
+            let authors = [];
+            if (info.authors?.author) {
+                const authorData = info.authors.author;
+                if (Array.isArray(authorData)) {
+                    authors = authorData.map(a => a.text);
+                }
+                else {
+                    authors = [authorData.text];
+                }
+            }
+            // Match conference using improved matching
+            const venue = info.venue || '';
+            const matched = matchConference(venue);
+            // Filter by requested conferences
+            if (options.conferences?.length && matched && !options.conferences.includes(matched.key)) {
+                continue;
+            }
+            // Get conference website URL for reference
+            const confWebsiteUrl = matched ? getConferenceWebsiteUrl(matched.key, year) : undefined;
+            papers.push({
+                title: info.title,
+                authors,
+                year,
+                conference: matched?.conf.shortName || info.venue,
+                conferenceFull: matched?.conf.name || info.venue,
+                tier: matched?.conf.tier || 'second',
+                url: info.ee || info.url,
+                doi: info.doi,
+                conferenceUrl: confWebsiteUrl // Reference link to conference website
+            });
+        }
+        return papers;
+    }
+    catch (error) {
+        console.error('Search error:', error);
+        throw error;
+    }
+}
+export async function searchByConference(conferenceKey, year) {
+    const conf = getConferenceInfo(conferenceKey);
+    if (!conf) {
+        throw new Error(`Unknown conference: ${conferenceKey}`);
+    }
+    return searchPapers({
+        conferences: [conferenceKey],
+        yearFrom: year,
+        yearTo: year,
+        limit: 200
+    });
+}
+export function listAvailableConferences() {
+    const topTier = Object.entries(conferences.conferences.top_tier).map(([key, conf]) => ({
+        key,
+        name: conf.name,
+        shortName: conf.shortName,
+        years: Object.keys(conf.urls).sort()
+    }));
+    const secondTier = Object.entries(conferences.conferences.second_tier).map(([key, conf]) => ({
+        key,
+        name: conf.name,
+        shortName: conf.shortName,
+        years: Object.keys(conf.urls).sort()
+    }));
+    return { topTier, secondTier };
+}
+export function getAvailableYears() {
+    const currentYear = new Date().getFullYear();
+    const years = [];
+    for (let y = 2020; y <= currentYear + 1; y++) { // Include next year for upcoming conferences
+        years.push(y);
+    }
+    return years;
+}

package/dist/types.d.ts

@@ -0,0 +1,65 @@
+export interface Paper {
+    title: string;
+    authors: string[];
+    year: number;
+    conference: string;
+    conferenceFull: string;
+    tier: 'top' | 'second';
+    url?: string;
+    doi?: string;
+    abstract?: string;
+    conferenceUrl?: string;
+}
+export interface ConferenceInfo {
+    name: string;
+    shortName: string;
+    tier: 'top' | 'second';
+    urls: Record<string, string>;
+    dblpKey: string;
+}
+export interface ConferencesConfig {
+    conferences: {
+        top_tier: Record<string, ConferenceInfo>;
+        second_tier: Record<string, ConferenceInfo>;
+    };
+    dblpBaseUrl: string;
+    alternativeSources: Record<string, {
+        description: string;
+        searchUrl: string;
+        venueUrl?: string;
+    }>;
+}
+export interface SearchOptions {
+    keyword?: string;
+    author?: string;
+    yearFrom?: number;
+    yearTo?: number;
+    conferences?: string[];
+    tier?: 'top' | 'second' | 'all';
+    limit?: number;
+}
+export interface DblpHit {
+    info: {
+        title: string;
+        authors?: {
+            author: {
+                text: string;
+            } | {
+                text: string;
+            }[];
+        };
+        year: string;
+        venue: string;
+        url?: string;
+        doi?: string;
+        ee?: string;
+    };
+}
+export interface DblpResponse {
+    result: {
+        hits: {
+            hit?: DblpHit[];
+            '@total': string;
+        };
+    };
+}

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -0,0 +1,60 @@
+{
+  "name": "@songyaeji/security-paper-mcp-server",
+  "version": "1.0.0",
+  "description": "MCP server for searching security conference papers from top-tier (S&P, USENIX Security, CCS, NDSS) and second-tier (ACSAC, RAID, ESORICS) conferences",
+  "main": "dist/index.js",
+  "bin": {
+    "security-paper-mcp-server": "dist/index.js"
+  },
+  "type": "module",
+  "scripts": {
+    "build": "tsc",
+    "start": "node dist/index.js",
+    "dev": "tsx src/index.ts",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": [
+    "mcp",
+    "model-context-protocol",
+    "security",
+    "papers",
+    "conference",
+    "research",
+    "dblp",
+    "ieee-sp",
+    "usenix-security",
+    "acm-ccs",
+    "ndss",
+    "acsac",
+    "raid",
+    "esorics",
+    "claude",
+    "ai-assistant"
+  ],
+  "author": "",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": ""
+  },
+  "homepage": "",
+  "bugs": {
+    "url": ""
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.0.0",
+    "zod": "^3.23.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.10.0",
+    "tsx": "^4.7.0",
+    "typescript": "^5.3.0"
+  }
+}