@minjunkwon/localgovernment-welfare-mcp-server/dist/index-clean.js

MCP server for Korean Local Government Welfare Services - provides intelligent search and information retrieval for local government social welfare programs

#!/usr/bin/env node
import { Server } from "@modelcontextprotocol/sdk/server/index.js";
import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
import { CallToolRequestSchema, ListToolsRequestSchema, McpError, ErrorCode } from "@modelcontextprotocol/sdk/types.js";
import { LocalWelfareAPI } from './api.js';
const server = new Server({
    name: "localgovernment-welfare-mcp-server",
    version: "2.0.0"
}, {
    capabilities: {
        tools: {},
    },
});
server.setRequestHandler(ListToolsRequestSchema, async () => {
    return {
        tools: [
            {
                name: "search_local_welfare_services",
                description: `🔍 Search local government welfare services with automatic detailed information retrieval.

⚡ WHAT THIS TOOL DOES:
1. Searches welfare services based on your criteria
2. Automatically fetches detailed information for ALL found services
3. Returns both search results AND complete details in one response

🎯 WHEN TO USE: When user asks for welfare services information

📋 PARAMETER INFERENCE GUIDE:
🏢 Region (ctpvNm/sggNm):
- "서울 은평구" → ctpvNm: "서울특별시", sggNm: "은평구"
- "경기도 성남시" → ctpvNm: "경기도", sggNm: "성남시" 
- "부산" → ctpvNm: "부산광역시"

👥 Target Group (trgterIndvdlArray):
- "저소득층", "생계급여" → "010" 
- "장애인" → "020"
- "한부모가족", "조손가정" → "030"
- "다자녀가정" → "040"
- "임신부", "출산" → "050"
- "보훈대상자" → "060"

📅 Life Stage (lifeArray):
- "영유아", "0-5세" → "001"
- "아동", "6-12세" → "002" 
- "청소년", "13-18세" → "003"
- "청년", "19-34세" → "004"
- "중장년", "35-64세" → "005"
- "노년", "65세 이상" → "006"
- "전체", "전 연령" → "007"

🎯 Interest Theme (intrsThemaArray):
- "일자리", "취업", "창업" → "010"
- "주거", "주택", "임대" → "020"  
- "교육", "학습", "자격증" → "030"
- "복지문화", "문화생활" → "040"
- "안전", "보안" → "050"
- "보건", "의료", "건강" → "060"
- "환경" → "070"
- "농림축산어업" → "080"
- "기타" → "090"
- "서민금융", "대출", "지원금" → "100"
- "신체건강", "재활" → "110"
- "임신·출산" → "120"
- "보육·돌봄", "육아" → "130"
- "입양·위탁" → "140"

⚠️ IMPORTANT: 
- Automatically fetches details for up to 15 services (configurable via maxDetails)
- Larger result sets may take longer due to sequential API calls
- Each detail fetch has 500ms delay for API stability`,
                inputSchema: {
                    type: "object",
                    properties: {
                        pageNo: {
                            type: "number",
                            description: "Page number (default: 1)"
                        },
                        numOfRows: {
                            type: "number",
                            description: "Number of results per page (default: 10, max: 50)"
                        },
                        maxDetails: {
                            type: "number",
                            description: "Maximum number of services to get details for (default: 15, max: 20)"
                        },
                        serviceKey: {
                            type: "string",
                            description: "API service key (optional - server has default)"
                        },
                        lifeArray: {
                            type: "string",
                            description: "Life stage codes: 001(영유아), 002(아동), 003(청소년), 004(청년), 005(중장년), 006(노년), 007(전체)"
                        },
                        trgterIndvdlArray: {
                            type: "string",
                            description: "Target individual codes: 010(저소득), 020(장애인), 030(한부모·조손), 040(다자녀), 050(임신·출산), 060(보훈대상자)"
                        },
                        intrsThemaArray: {
                            type: "string",
                            description: "Interest theme codes: 010(일자리), 020(주거), 030(교육), 040(복지문화), 050(안전), 060(보건), 070(환경), 080(농림축산어업), 090(기타), 100(서민금융), 110(신체건강), 120(임신·출산), 130(보육·돌봄), 140(입양·위탁)"
                        },
                        ctpvNm: {
                            type: "string",
                            description: "Province/City name (e.g., 서울특별시, 경기도, 부산광역시)"
                        },
                        sggNm: {
                            type: "string",
                            description: "District name (e.g., 은평구, 성남시, 해운대구)"
                        },
                        srchKeyCode: {
                            type: "string",
                            description: "Search key code: 001(서비스명), 002(서비스 요약), 003(전체)"
                        },
                        searchWrd: {
                            type: "string",
                            description: "Search keyword"
                        },
                        arrgOrd: {
                            type: "string",
                            description: "Sort order: 001(최신순), 002(인기순)"
                        }
                    }
                }
            }
            // {
            //   name: "get_local_welfare_codes",
            //   description: `Get code definitions used in the local welfare services API.
            // WHEN TO USE: When you need to understand what codes mean or show users available options.
            // PARAMETER:
            // codeType (OPTIONAL): Type of codes to retrieve
            // - "all" (default): All code types
            // - "lifeCycle": Life stage codes (영유아, 아동, 청소년, etc.)
            // - "householdType": Household situation codes (저소득, 장애인, 한부모, etc.)
            // - "interestTheme": Interest theme codes (일자리, 주거, 교육, etc.)
            // - "sortOrder": Sort order options (최신순, 인기순)
            // USAGE: Call this when user asks about available options or code meanings.`,
            //   inputSchema: {
            //     type: "object",
            //     properties: {
            //       codeType: {
            //         type: "string",
            //         enum: ["lifeCycle", "householdType", "interestTheme", "sortOrder", "all"],
            //         description: "Type of codes to retrieve (default: all)"
            //       }
            //     }
            //   }
            // }
        ],
    };
});
server.setRequestHandler(CallToolRequestSchema, async (request) => {
    try {
        console.error('CallToolRequest received:', JSON.stringify(request));
        const { name, arguments: args } = request.params;
        // arguments가 없는 경우 더 상세한 로깅
        if (!args) {
            console.error('No arguments provided in request.params:', request.params);
            throw new McpError(ErrorCode.InvalidParams, "No arguments provided");
        }
        switch (name) {
            case "search_local_welfare_services": {
                console.error('search_local_welfare_services called with args:', JSON.stringify(args));
                if (!args || typeof args !== 'object') {
                    throw new McpError(ErrorCode.InvalidParams, "Invalid arguments provided");
                }
                const searchParams = {
                    pageNo: args && 'pageNo' in args ? Number(args.pageNo) || 1 : 1,
                    numOfRows: args && 'numOfRows' in args ? Number(args.numOfRows) || 10 : 10
                };
                // 모든 검색 매개변수 처리
                if (args && 'serviceKey' in args && typeof args.serviceKey === 'string' && args.serviceKey.trim()) {
                    searchParams.serviceKey = args.serviceKey;
                }
                if (args.lifeArray && args.lifeArray.trim()) {
                    searchParams.lifeArray = args.lifeArray;
                }
                if (args.trgterIndvdlArray && args.trgterIndvdlArray.trim()) {
                    searchParams.trgterIndvdlArray = args.trgterIndvdlArray;
                }
                if (args.intrsThemaArray && args.intrsThemaArray.trim()) {
                    searchParams.intrsThemaArray = args.intrsThemaArray;
                }
                if (args.ctpvNm && args.ctpvNm.trim()) {
                    searchParams.ctpvNm = args.ctpvNm;
                }
                if (args.sggNm && args.sggNm.trim()) {
                    searchParams.sggNm = args.sggNm;
                }
                if (args.srchKeyCode && ['001', '002', '003'].includes(args.srchKeyCode)) {
                    searchParams.srchKeyCode = args.srchKeyCode;
                }
                if (args.searchWrd && args.searchWrd.trim()) {
                    searchParams.searchWrd = args.searchWrd;
                }
                if (args.arrgOrd && ['001', '002'].includes(args.arrgOrd)) {
                    searchParams.arrgOrd = args.arrgOrd;
                }
                // 상세조회 옵션 (항상 활성화)
                const maxDetails = args && 'maxDetails' in args ? Math.min(Number(args.maxDetails) || 15, 20) : 15;
                try {
                    // 1단계: 목록 조회
                    const localWelfareAPI = new LocalWelfareAPI();
                    const searchResult = await localWelfareAPI.getLocalWelfareList(searchParams);
                    // 2단계: 자동 상세조회
                    const servList = searchResult.wantedList?.servList;
                    if (!servList || servList.length === 0) {
                        return {
                            content: [
                                {
                                    type: "text",
                                    text: JSON.stringify({
                                        searchParams: searchParams,
                                        searchResult: searchResult,
                                        details: [],
                                        message: "No services found"
                                    }, null, 2)
                                }
                            ]
                        };
                    }
                    // 상세조회할 서비스 ID 목록 생성 (최대 maxDetails개)
                    const servIds = (Array.isArray(servList) ? servList : [servList])
                        .slice(0, maxDetails)
                        .map(service => service.servId)
                        .filter(id => id);
                    console.error(`Auto-fetching details for ${servIds.length} services...`);
                    const detailResults = [];
                    for (let i = 0; i < servIds.length; i++) {
                        const servId = servIds[i];
                        try {
                            console.error(`Fetching details for ${servId} (${i + 1}/${servIds.length})`);
                            const detailAPI = new LocalWelfareAPI();
                            const detailResult = await detailAPI.getLocalWelfareDetail({ servId });
                            detailResults.push({
                                servId,
                                success: true,
                                data: detailResult.wantedDtl
                            });
                            // API 호출 간 500ms 지연 (마지막 호출 제외)
                            if (i < servIds.length - 1) {
                                await new Promise(resolve => setTimeout(resolve, 500));
                            }
                        }
                        catch (error) {
                            console.error(`Error fetching details for ${servId}:`, error);
                            detailResults.push({
                                servId,
                                success: false,
                                error: error instanceof Error ? error.message : String(error)
                            });
                        }
                    }
                    return {
                        content: [
                            {
                                type: "text",
                                text: JSON.stringify({
                                    searchParams: searchParams,
                                    searchResult: searchResult,
                                    detailsSummary: {
                                        total: servIds.length,
                                        successful: detailResults.filter(r => r.success).length,
                                        failed: detailResults.filter(r => !r.success).length
                                    },
                                    details: detailResults
                                }, null, 2)
                            }
                        ]
                    };
                }
                catch (error) {
                    console.error('Error in search_local_welfare_services:', error);
                    throw new McpError(ErrorCode.InternalError, `Failed to search welfare services with details: ${error instanceof Error ? error.message : String(error)}`);
                }
            }
            // case "get_local_welfare_codes": {
            //   const codeType = (args as any).codeType || "all";
            //   let codes: any = {};
            //   switch (codeType) {
            //     case "lifeCycle":
            //       codes = { lifeCycle: LifeCycleCode };
            //       break;
            //     case "householdType":
            //       codes = { householdType: HouseholdTypeCode };
            //       break;
            //     case "interestTheme":
            //       codes = { interestTheme: InterestThemeCode };
            //       break;
            //     case "sortOrder":
            //       codes = { sortOrder: SortOrderCode };
            //       break;
            //     case "all":
            //     default:
            //       codes = {
            //         lifeCycle: LifeCycleCode,
            //         householdType: HouseholdTypeCode,
            //         interestTheme: InterestThemeCode,
            //         sortOrder: SortOrderCode
            //       };
            //       break;
            //   }
            //   return {
            //     content: [
            //       {
            //         type: "text",
            //         text: JSON.stringify(codes, null, 2)
            //       }
            //     ]
            //   };
            // }
            default:
                throw new McpError(ErrorCode.MethodNotFound, `Unknown tool: ${name}`);
        }
    }
    catch (error) {
        console.error('Tool execution error:', error);
        if (error instanceof McpError) {
            throw error;
        }
        throw new McpError(ErrorCode.InternalError, `Tool execution failed: ${error instanceof Error ? error.message : String(error)}`);
    }
});
async function main() {
    const transport = new StdioServerTransport();
    await server.connect(transport);
    console.error("Local Government Welfare MCP Server running on stdio");
}
main().catch((error) => {
    console.error("Server failed to start:", error);
    process.exit(1);
});
//# sourceMappingURL=index-clean.js.map