@minjunkwon/localgovernment-welfare-mcp-server/dist/index-old.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 { ListToolsRequestSchema } from "@modelcontextprotocol/sdk/types.js";
const server = new Server({
    name: "localgovernment-welfare-mcp-server",
    version: "1.0.0"
}, {
    capabilities: {
        tools: {},
    },
});
server.setRequestHandler(ListToolsRequestSchema, async () => {
    return {
        tools: [
            {
                name: "search_local_welfare_services",
                description: `Search local government welfare services in Korea with structured filtering options.

WHEN TO USE: When user asks for specific welfare services with clear criteria (region, target group, topic, etc.)

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

👥 Target Group (trgterIndvdlArray):
- "저소득층", "기초생활수급자" → "050"
- "장애인" → "040"
- "한부모가정", "조손가정" → "060"
- "다자녀가정" → "020"
- "보훈대상자" → "030"

🎯 Life Stage (lifeArray):
- "임신", "출산", "산모" → "007"
- "영유아", "신생아" → "001"
- "아동", "어린이" → "002"
- "청소년" → "003"
- "청년", "대학생" → "004"
- "중장년" → "005"
- "노인", "어르신" → "006"

📋 Interest Theme (intrsThemaArray):
- "일자리", "취업", "고용" → "050"
- "주거", "주택" → "040"
- "보육", "어린이집" → "090"
- "교육" → "100"
- "의료", "건강" → "010"
- "서민금융", "지원금" → "130"

🔍 Search Parameters:
- srchKeyCode: "001" for service name, "002" for organization, "003" for region
- searchWrd: keyword to search for
- age: specific age number for filtering

EXAMPLES:
1. "서울 은평구 저소득층 복지서비스" → {"ctpvNm": "서울특별시", "sggNm": "은평구", "trgterIndvdlArray": "050"}
2. "부산 청년 일자리 지원" → {"ctpvNm": "부산광역시", "lifeArray": "004", "intrsThemaArray": "050"}
3. "경기도 장애인 주거 서비스" → {"ctpvNm": "경기도", "trgterIndvdlArray": "040", "intrsThemaArray": "040"}
4. "임신 지원 검색" → {"srchKeyCode": "001", "searchWrd": "임신"}
5. "30세 청년 지원" → {"age": 30, "lifeArray": "004"}`,
                inputSchema: {
                    type: "object",
                    properties: {
                        serviceKey: {
                            type: "string",
                            description: "서비스키 (선택사항)"
                        },
                        pageNo: {
                            type: "integer",
                            minimum: 1,
                            maximum: 1000,
                            description: "페이지 번호 (기본값: 1)"
                        },
                        numOfRows: {
                            type: "integer",
                            minimum: 1,
                            maximum: 100,
                            description: "출력 건수 (기본값: 10)"
                        },
                        lifeArray: {
                            type: "string",
                            enum: ["001", "002", "003", "004", "005", "006", "007"],
                            description: "생애주기별 필터링 (001: 영유아, 002: 아동, 003: 청소년, 004: 청년, 005: 중장년, 006: 노년, 007: 임신·출산)"
                        },
                        trgterIndvdlArray: {
                            type: "string",
                            enum: ["010", "020", "030", "040", "050", "060"],
                            description: "가구상황별 필터링 (010: 다문화·탈북민, 020: 다자녀, 030: 보훈대상자, 040: 장애인, 050: 저소득, 060: 한부모·조손)"
                        },
                        intrsThemaArray: {
                            type: "string",
                            enum: ["010", "020", "030", "040", "050", "060", "070", "080", "090", "100", "110", "120", "130", "140"],
                            description: "관심주제별 필터링 (010: 신체건강, 020: 정신건강, 030: 생활지원, 040: 주거, 050: 일자리, 060: 문화·여가, 070: 안전·위기, 080: 임신·출산, 090: 보육, 100: 교육, 110: 입양·위탁, 120: 보호·돌봄, 130: 서민금융, 140: 법률)"
                        },
                        age: {
                            type: "integer",
                            minimum: 0,
                            maximum: 150,
                            description: "연령 (선택사항)"
                        },
                        ctpvNm: {
                            type: "string",
                            description: "시도명 (예: '서울특별시', '경기도', '부산광역시' 등)"
                        },
                        sggNm: {
                            type: "string",
                            description: "시군구명 (예: '은평구', '성남시', '부산진구' 등)"
                        },
                        srchKeyCode: {
                            type: "string",
                            enum: ["001", "002", "003"],
                            description: "검색키코드 (001: 서비스명, 002: 기관명, 003: 지역명)"
                        },
                        searchWrd: {
                            type: "string",
                            description: "검색어 (선택사항)"
                        },
                        arrgOrd: {
                            type: "string",
                            enum: ["001", "002"],
                            description: "정렬순서 (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)"
                        }
                    }
                }
            },
            WHEN, TO, USE, When, you, want, to, search
        ], for: services, and, immediately, get their() { }, detailed, information, without, multiple, API, calls, : .
            PARAMETERS, Same, as, search_local_welfare_services, plus: -includeDetails(boolean), Whether, to, fetch, detailed, information, for: each
    }
        - maxDetails(number);
    Maximum;
    number;
    of;
    services;
    to;
    get;
    details;
    for (; ; )
        ;
    10, max;
    20;
});
USAGE: This;
combines;
search;
and;
batch;
detail;
fetching;
to;
provide;
complete;
information;
efficiently. `,
        inputSchema: {
          type: "object",
          properties: {
            pageNo: {
              type: "number",
              description: "Page number (default: 1)"
            },
            numOfRows: {
              type: "number", 
              description: "Number of results per page (default: 10, max: 100)"
            },
            ctpvNm: {
              type: "string",
              description: "Province/City name (e.g., '서울특별시')"
            },
            sggNm: {
              type: "string",
              description: "District name (e.g., '은평구')"
            },
            lifeArray: {
              type: "string",
              description: "Life stage code (001-007)"
            },
            trgterIndvdlArray: {
              type: "string", 
              description: "Target individual code (001-010)"
            },
            intrsThemaArray: {
              type: "string",
              description: "Interest theme code (001-012)"
            },
            age: {
              type: "number",
              description: "Age"
            },
            searchWrd: {
              type: "string",
              description: "Search keyword"
            },
            includeDetails: {
              type: "boolean",
              description: "Whether to fetch detailed information (default: false)"
            },
            maxDetails: {
              type: "number",
              description: "Maximum number of services to get details for (default: 10, max: 20)"
            }
          }
        }
      },
      {
        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"();
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: LocalWelfareListRequest = {
          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 as any).lifeArray && (args as any).lifeArray.trim()) {
          searchParams.lifeArray = (args as any).lifeArray;
        }
        if ((args as any).trgterIndvdlArray && (args as any).trgterIndvdlArray.trim()) {
          searchParams.trgterIndvdlArray = (args as any).trgterIndvdlArray;
        }
        if ((args as any).intrsThemaArray && (args as any).intrsThemaArray.trim()) {
          searchParams.intrsThemaArray = (args as any).intrsThemaArray;
        }
        if ((args as any).age !== undefined && (args as any).age !== null) {
          searchParams.age = (args as any).age;
        }
        if ((args as any).ctpvNm && (args as any).ctpvNm.trim()) {
          searchParams.ctpvNm = (args as any).ctpvNm;
        }
        if ((args as any).sggNm && (args as any).sggNm.trim()) {
          searchParams.sggNm = (args as any).sggNm;
        }
        if ((args as any).srchKeyCode && ['001', '002', '003'].includes((args as any).srchKeyCode)) {
          searchParams.srchKeyCode = (args as any).srchKeyCode;
        }
        if ((args as any).searchWrd && (args as any).searchWrd.trim()) {
          searchParams.searchWrd = (args as any).searchWrd;
        }
        if ((args as any).arrgOrd && ['001', '002'].includes((args as any).arrgOrd)) {
          searchParams.arrgOrd = (args as any).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 as any).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: any[] = [];
          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_detail": {
        console.error('get_local_welfare_detail called with args:', JSON.stringify(args));
        
        if (!args || typeof args !== 'object') {
          throw new McpError(ErrorCode.InvalidParams, "Invalid arguments provided");
        }
        
        const servId = args && 'servId' in args ? String(args.servId) : null;
        if (!servId) {
          throw new McpError(ErrorCode.InvalidParams, "servId is required");
        }

        const detailParams: LocalWelfareDetailRequest = {
          servId: servId
        };

        try {
          const localWelfareAPI = new LocalWelfareAPI();
          const result = await localWelfareAPI.getLocalWelfareDetail(detailParams);
          
          return {
            content: [
              {
                type: "text", 
                text: JSON.stringify(result, null, 2)
              }
            ]
          };
        } catch (error) {
          console.error('Error in get_local_welfare_detail:', error);
          throw new McpError(
            ErrorCode.InternalError, 
            `;
Failed;
to;
get;
welfare;
detail: $;
{
    error instanceof Error ? error.message : String(error);
}
`
          );
        }
      }

      case "get_multiple_welfare_details": {
        console.error('get_multiple_welfare_details called with args:', JSON.stringify(args));
        
        if (!args || typeof args !== 'object') {
          throw new McpError(ErrorCode.InvalidParams, "Invalid arguments provided");
        }
        
        const servIdsString = args && 'servIds' in args ? String(args.servIds) : '';
        if (!servIdsString) {
          throw new McpError(ErrorCode.InvalidParams, "servIds is required");
        }

        const servIds = servIdsString.split(',').map(id => id.trim()).filter(id => id);
        if (servIds.length === 0) {
          throw new McpError(ErrorCode.InvalidParams, "At least one valid service ID is required");
        }

        const results: any[] = [];
        const errors: string[] = [];

        for (let i = 0; i < servIds.length; i++) {
          const servId = servIds[i];
          try {
            console.error(`;
Fetching;
details;
for ($; { servId }($, { i } + 1, /${servIds.length}) `);
            
            const localWelfareAPI = new LocalWelfareAPI();
            const result = await localWelfareAPI.getLocalWelfareDetail({ servId });
            
            results.push({
              servId,
              success: true,
              data: result.wantedDtl
            });
            
            // API 호출 간 500ms 지연 (마지막 호출 제외)
            if (i < servIds.length - 1) {
              await new Promise(resolve => setTimeout(resolve, 500));
            }
            
          } catch (error) {
            console.error(`; Error)
    fetching;
$;
{
    servId;
}
`, error);
            errors.push(`;
$;
{
    servId;
}
$;
{
    error instanceof Error ? error.message : String(error);
}
`);
            results.push({
              servId,
              success: false,
              error: error instanceof Error ? error.message : String(error)
            });
          }
        }

        const summary = {
          total: servIds.length,
          successful: results.filter(r => r.success).length,
          failed: results.filter(r => !r.success).length,
          results: results
        };

        return {
          content: [
            {
              type: "text",
              text: JSON.stringify(summary, null, 2)
            }
          ]
        };
      }

      case "search_welfare_with_details": {
        console.error('search_welfare_with_details called with args:', JSON.stringify(args));
        
        if (!args || typeof args !== 'object') {
          throw new McpError(ErrorCode.InvalidParams, "Invalid arguments provided");
        }
        
        // 검색 파라미터 구성
        const searchParams: LocalWelfareListRequest = {
          pageNo: args && 'pageNo' in args ? Number(args.pageNo) || 1 : 1,
          numOfRows: args && 'numOfRows' in args ? Number(args.numOfRows) || 10 : 10
        };

        // 모든 검색 매개변수 처리 (기존 search_local_welfare_services와 동일)
        if (args && 'ctpvNm' in args && typeof args.ctpvNm === 'string' && args.ctpvNm.trim()) {
          searchParams.ctpvNm = args.ctpvNm;
        }
        if (args && 'sggNm' in args && typeof args.sggNm === 'string' && args.sggNm.trim()) {
          searchParams.sggNm = args.sggNm;
        }
        if (args && 'lifeArray' in args && typeof args.lifeArray === 'string' && args.lifeArray.trim()) {
          searchParams.lifeArray = args.lifeArray as any;
        }
        if (args && 'trgterIndvdlArray' in args && typeof args.trgterIndvdlArray === 'string' && args.trgterIndvdlArray.trim()) {
          searchParams.trgterIndvdlArray = args.trgterIndvdlArray as any;
        }
        if (args && 'intrsThemaArray' in args && typeof args.intrsThemaArray === 'string' && args.intrsThemaArray.trim()) {
          searchParams.intrsThemaArray = args.intrsThemaArray as any;
        }
        if (args && 'age' in args && typeof args.age === 'number') {
          searchParams.age = args.age;
        }
        if (args && 'searchWrd' in args && typeof args.searchWrd === 'string' && args.searchWrd.trim()) {
          searchParams.searchWrd = args.searchWrd;
        }

        // 상세조회 옵션
        const includeDetails = args && 'includeDetails' in args ? Boolean(args.includeDetails) : false;
        const maxDetails = args && 'maxDetails' in args ? Math.min(Number(args.maxDetails) || 10, 20) : 10;

        try {
          // 1단계: 목록 조회
          const localWelfareAPI = new LocalWelfareAPI();
          const searchResult = await localWelfareAPI.getLocalWelfareList(searchParams);
          
          if (!includeDetails) {
            // 상세조회 없이 목록만 반환
            return {
              content: [
                {
                  type: "text",
                  text: JSON.stringify({
                    searchParams: searchParams,
                    result: searchResult
                  }, null, 2)
                }
              ]
            };
          }

          // 2단계: 상세조회 수행
          const servList = (searchResult as any).wantedList?.servList;
          if (!servList || servList.length === 0) {
            return {
              content: [
                {
                  type: "text",
                  text: JSON.stringify({
                    searchParams: searchParams,
                    searchResult: searchResult,
                    details: [],
                    message: "No services found to get details for"
                  }, null, 2)
                }
              ]
            };
          }

          // 상세조회할 서비스 ID 목록 생성 (최대 maxDetails개)
          const servIds = (Array.isArray(servList) ? servList : [servList])
            .slice(0, maxDetails)
            .map(service => service.servId)
            .filter(id => id);

          console.error(`;
Fetching;
details;
for ($; { servIds, : .length }; services)
    ;
`);

          const detailResults: any[] = [];
          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_welfare_with_details:', 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) {
    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-old.js.map