@isnow890/naver-search-mcp 1.0.14 → 1.0.19

package/README.md

@@ -6,6 +6,26 @@
 
 MCP server for Naver Search API and DataLab API integration, enabling comprehensive search across various Naver services and data trend analysis.
 
+#### Version History
+
+###### 1.0.2 (2025-04-26)
+
+- README updated: cafe article search tool and version history section improved
+
+###### 1.0.1 (2025-04-26)
+
+- Cafe article search feature added
+- Shopping category info added to zod
+- Source code refactored
+
+###### 1.0.0 (2025-04-08)
+
+- Initial release
+
+#### Information
+
+**If you want to install the MCP via npm, do NOT use @mseep/server-naver-search (https://www.npmjs.com/package/@mseep/server-naver-search). That package is a copy of my work and was published without my permission. The npx version of that package is also broken and will not work properly. Please use this official package instead.**
+
 #### Prerequisites
 
 - Naver Developers API Key (Client ID and Secret)
@@ -30,6 +50,7 @@ MCP server for Naver Search API and DataLab API integration, enabling comprehens
 - **search_webkr**: Search Naver web documents
 - **search_news**: Search Naver news
 - **search_blog**: Search Naver blogs
+- **search_cafearticle**: Search Naver cafe articles
 - **search_shop**: Search Naver shopping
 - **search_image**: Search Naver images
 - **search_kin**: Search Naver KnowledgeiN

package/dist/package.json

@@ -0,0 +1,43 @@
+{
+    "name": "@isnow890/naver-search-mcp",
+    "version": "1.0.19",
+    "description": "Naver Search MCP Server",
+    "main": "dist/index.js",
+    "types": "dist/index.d.ts",
+    "files": [
+        "dist"
+    ],
+    "scripts": {
+        "prebuild": "shx rm -rf dist",
+        "build": "tsc",
+        "prepare": "npm run build",
+        "watch": "tsc --watch",
+        "start": "node dist/src/index.js",
+        "test": "npx cross-env NODE_OPTIONS=--experimental-vm-modules npx jest"
+    },
+    "engines": {
+        "node": ">=18"
+    },
+    "dependencies": {
+        "@modelcontextprotocol/sdk": "1.10.2",
+        "axios": "^1.6.7",
+        "dotenv": "^16.4.5",
+        "sharp": "^0.33.2",
+        "zod": "^3.22.4",
+        "zod-to-json-schema": "^3.23.5"
+    },
+    "devDependencies": {
+        "@types/jest": "^29.5.14",
+        "@types/node": "^22",
+        "jest": "^29.7.0",
+        "shx": "^0.3.4",
+        "ts-jest": "^29.3.2",
+        "typescript": "^5.3.3"
+    },
+    "author": "isnow890",
+    "license": "MIT",
+    "bin": {
+        "naver-search-mcp": "dist/src/index.js"
+    },
+    "type": "module"
+}

package/dist/src/clients/naver-api-core.client.js

@@ -0,0 +1,30 @@
+import axios from "axios";
+export class NaverApiCoreClient {
+    constructor() {
+        this.searchBaseUrl = "https://openapi.naver.com/v1/search";
+        this.datalabBaseUrl = "https://openapi.naver.com/v1/datalab";
+        this.config = null;
+    }
+    initialize(config) {
+        this.config = config;
+    }
+    getHeaders(contentType = "application/json") {
+        if (!this.config)
+            throw new Error("NaverApiCoreClient is not initialized.");
+        return {
+            headers: {
+                "X-Naver-Client-Id": this.config.clientId,
+                "X-Naver-Client-Secret": this.config.clientSecret,
+                "Content-Type": contentType,
+            },
+        };
+    }
+    async get(url, params) {
+        const response = await axios.get(url, { params, ...this.getHeaders() });
+        return response.data;
+    }
+    async post(url, data) {
+        const response = await axios.post(url, data, this.getHeaders());
+        return response.data;
+    }
+}

package/dist/src/clients/naver-search.client.js

@@ -0,0 +1,100 @@
+import { NaverApiCoreClient } from "./naver-api-core.client.js";
+/**
+ * NaverSearchClient - 네이버 API 서비스를 위한 싱글톤 클라이언트
+ * 검색, 데이터랩 API 요청 처리
+ */
+export class NaverSearchClient extends NaverApiCoreClient {
+    constructor() {
+        super();
+    }
+    /**
+     * 싱글톤 인스턴스 반환
+     */
+    static getInstance() {
+        if (!NaverSearchClient.instance) {
+            NaverSearchClient.instance = new NaverSearchClient();
+        }
+        return NaverSearchClient.instance;
+    }
+    /**
+     * API 자격 증명으로 클라이언트 초기화
+     */
+    initialize(config) {
+        this.config = config;
+    }
+    /**
+     * 네이버 검색 API 호출 (type별로)
+     * @param type 검색 타입(카테고리)
+     * @param params 검색 파라미터
+     */
+    async search(type, params) {
+        return this.get(`${this.searchBaseUrl}/${type}`, params);
+    }
+    /**
+     * 전문자료 검색 메서드
+     */
+    async searchAcademic(params) {
+        return this.get(`${this.searchBaseUrl}/doc`, params);
+    }
+    /**
+     * 지역 검색 메서드
+     */
+    async searchLocal(params) {
+        return this.get(`${this.searchBaseUrl}/local`, params);
+    }
+    /**
+     * 검색어 트렌드 분석 메서드
+     */
+    async searchTrend(params) {
+        return this.post(`${this.datalabBaseUrl}/search`, params);
+    }
+    /**
+     * 쇼핑 카테고리 트렌드 분석 메서드
+     */
+    async datalabShoppingCategory(params) {
+        return this.post(`${this.datalabBaseUrl}/shopping/categories`, params);
+    }
+    /**
+     * 쇼핑 기기별 트렌드 분석 메서드
+     */
+    async datalabShoppingByDevice(params) {
+        return this.post(`${this.datalabBaseUrl}/shopping/category/device`, params);
+    }
+    /**
+     * 쇼핑 성별 트렌드 분석 메서드
+     */
+    async datalabShoppingByGender(params) {
+        return this.post(`${this.datalabBaseUrl}/shopping/category/gender`, params);
+    }
+    /**
+     * 쇼핑 연령별 트렌드 분석 메서드
+     */
+    async datalabShoppingByAge(params) {
+        return this.post(`${this.datalabBaseUrl}/shopping/category/age`, params);
+    }
+    /**
+     * 쇼핑 키워드 트렌드 분석 메서드
+     */
+    async datalabShoppingKeywords(params) {
+        return this.post(`${this.datalabBaseUrl}/shopping/category/keywords`, params);
+    }
+    /**
+     * 쇼핑 키워드 기기별 트렌드 분석 메서드
+     */
+    async datalabShoppingKeywordByDevice(params) {
+        return this.post(`${this.datalabBaseUrl}/shopping/category/keyword/device`, params);
+    }
+    /**
+     * 쇼핑 키워드 성별 트렌드 분석 메서드
+     */
+    async datalabShoppingKeywordByGender(params) {
+        return this.post(`${this.datalabBaseUrl}/shopping/category/keyword/gender`, params);
+    }
+    /**
+     * 쇼핑 키워드 연령별 트렌드 분석 메서드
+     */
+    async datalabShoppingKeywordByAge(params) {
+        return this.post(`${this.datalabBaseUrl}/shopping/category/keyword/age`, params);
+    }
+}
+NaverSearchClient.instance = null;

package/dist/src/handlers/datalab.handlers.js

@@ -1,20 +1,42 @@
-import { NaverSearchClient } from "../naver-search.client.js";
-// 클라이언트 인스턴스
+import { NaverSearchClient } from "../clients/naver-search.client.js";
+// 클라이언트 인스턴스 (싱글톤)
 const client = NaverSearchClient.getInstance();
+/**
+ * 데이터랩 도구 핸들러 맵
+ * 각 도구 이름을 키로, 실행할 핸들러 함수를 값으로 가짐
+ * index.ts에서 도구 실행 분기 없이 바로 사용
+ */
+export const datalabToolHandlers = {
+    datalab_search: (args) => handleSearchTrend(args), // 검색어 트렌드 분석
+    datalab_shopping_category: (args) => handleShoppingCategoryTrend(args), // 쇼핑 카테고리별 트렌드
+    datalab_shopping_by_device: (args) => handleShoppingByDeviceTrend(args), // 쇼핑 기기별 트렌드
+    datalab_shopping_by_gender: (args) => handleShoppingByGenderTrend(args), // 쇼핑 성별 트렌드
+    datalab_shopping_by_age: (args) => handleShoppingByAgeTrend(args), // 쇼핑 연령별 트렌드
+    datalab_shopping_keywords: (args) => handleShoppingKeywordsTrend(args), // 쇼핑 키워드 그룹 트렌드
+    datalab_shopping_keyword_by_device: (args) => handleShoppingKeywordByDeviceTrend(args), // 쇼핑 키워드 기기별 트렌드
+    datalab_shopping_keyword_by_gender: (args) => handleShoppingKeywordByGenderTrend(args), // 쇼핑 키워드 성별 트렌드
+    datalab_shopping_keyword_by_age: (args) => handleShoppingKeywordByAgeTrend(args), // 쇼핑 키워드 연령별 트렌드
+};
 /**
  * 검색어 트렌드 핸들러
+ * 네이버 데이터랩 검색어 트렌드 분석 API 호출
+ * @param params DatalabSearch
  */
 export async function handleSearchTrend(params) {
     return client.searchTrend(params);
 }
 /**
  * 쇼핑 카테고리 트렌드 핸들러
+ * 네이버 데이터랩 쇼핑 카테고리별 트렌드 분석 API 호출
+ * @param params DatalabShopping
  */
 export async function handleShoppingCategoryTrend(params) {
     return client.datalabShoppingCategory(params);
 }
 /**
  * 쇼핑 기기별 트렌드 핸들러
+ * 네이버 데이터랩 쇼핑 기기별 트렌드 분석 API 호출
+ * @param params DatalabShoppingDevice
  */
 export async function handleShoppingByDeviceTrend(params) {
     return client.datalabShoppingByDevice({
@@ -27,6 +49,8 @@ export async function handleShoppingByDeviceTrend(params) {
 }
 /**
  * 쇼핑 성별 트렌드 핸들러
+ * 네이버 데이터랩 쇼핑 성별 트렌드 분석 API 호출
+ * @param params DatalabShoppingGender
  */
 export async function handleShoppingByGenderTrend(params) {
     return client.datalabShoppingByGender({
@@ -39,6 +63,8 @@ export async function handleShoppingByGenderTrend(params) {
 }
 /**
  * 쇼핑 연령별 트렌드 핸들러
+ * 네이버 데이터랩 쇼핑 연령별 트렌드 분석 API 호출
+ * @param params DatalabShoppingAge
  */
 export async function handleShoppingByAgeTrend(params) {
     return client.datalabShoppingByAge({
@@ -50,8 +76,9 @@ export async function handleShoppingByAgeTrend(params) {
     });
 }
 /**
- * 쇼핑 키워드 트렌드 핸들러
- * 복수 키워드 그룹을 지원합니다.
+ * 쇼핑 키워드 트렌드 핸들러 (복수 키워드 그룹 지원)
+ * 네이버 데이터랩 쇼핑 키워드 그룹 트렌드 분석 API 호출
+ * @param params DatalabShoppingKeywords
  */
 export async function handleShoppingKeywordsTrend(params) {
     // 키워드 배열을 네이버 API에 맞는 형식으로 변환
@@ -60,11 +87,13 @@ export async function handleShoppingKeywordsTrend(params) {
         endDate: params.endDate,
         timeUnit: params.timeUnit,
         category: params.category,
-        keyword: params.keyword
+        keyword: params.keyword,
     });
 }
 /**
  * 쇼핑 키워드 기기별 트렌드 핸들러
+ * 네이버 데이터랩 쇼핑 키워드 기기별 트렌드 분석 API 호출
+ * @param params DatalabShoppingKeywordDevice
  */
 export async function handleShoppingKeywordByDeviceTrend(params) {
     return client.datalabShoppingKeywordByDevice({
@@ -78,6 +107,8 @@ export async function handleShoppingKeywordByDeviceTrend(params) {
 }
 /**
  * 쇼핑 키워드 성별 트렌드 핸들러
+ * 네이버 데이터랩 쇼핑 키워드 성별 트렌드 분석 API 호출
+ * @param params DatalabShoppingKeywordGender
  */
 export async function handleShoppingKeywordByGenderTrend(params) {
     return client.datalabShoppingKeywordByGender({
@@ -91,6 +122,8 @@ export async function handleShoppingKeywordByGenderTrend(params) {
 }
 /**
  * 쇼핑 키워드 연령별 트렌드 핸들러
+ * 네이버 데이터랩 쇼핑 키워드 연령별 트렌드 분석 API 호출
+ * @param params DatalabShoppingKeywordAge
  */
 export async function handleShoppingKeywordByAgeTrend(params) {
     return client.datalabShoppingKeywordByAge({

package/dist/src/handlers/search.handlers.js

@@ -1,12 +1,20 @@
-import { NaverSearchClient } from "../naver-search.client.js";
+import { NaverSearchClient } from "../clients/naver-search.client.js";
+import { SearchArgsSchema } from "../schemas/search.schemas.js";
 // 클라이언트 인스턴스
 const client = NaverSearchClient.getInstance();
-/**
- * 기본 검색 핸들러
- */
-export async function handleSearch(params) {
-    return client.search({ ...params });
-}
+export const searchToolHandlers = {
+    search_webkr: (args) => handleWebKrSearch(SearchArgsSchema.parse(args)),
+    search_news: (args) => handleNewsSearch(SearchArgsSchema.parse(args)),
+    search_blog: (args) => handleBlogSearch(SearchArgsSchema.parse(args)),
+    search_shop: (args) => handleShopSearch(SearchArgsSchema.parse(args)),
+    search_image: (args) => handleImageSearch(SearchArgsSchema.parse(args)),
+    search_kin: (args) => handleKinSearch(SearchArgsSchema.parse(args)),
+    search_book: (args) => handleBookSearch(SearchArgsSchema.parse(args)),
+    search_encyc: (args) => handleEncycSearch(SearchArgsSchema.parse(args)),
+    search_academic: (args) => handleAcademicSearch(SearchArgsSchema.parse(args)),
+    search_local: (args) => handleLocalSearch(args),
+    search_cafearticle: (args) => handleCafeArticleSearch(args),
+};
 /**
  * 전문자료 검색 핸들러
  */
@@ -17,25 +25,25 @@ export async function handleAcademicSearch(params) {
  * 도서 검색 핸들러
  */
 export async function handleBookSearch(params) {
-    return client.search({ type: "book", ...params });
+    return client.search("book", params);
 }
 /**
  * 지식백과 검색 핸들러
  */
 export async function handleEncycSearch(params) {
-    return client.search({ type: "encyc", ...params });
+    return client.search("encyc", params);
 }
 /**
  * 이미지 검색 핸들러
  */
 export async function handleImageSearch(params) {
-    return client.search({ type: "image", ...params });
+    return client.search("image", params);
 }
 /**
  * 지식iN 검색 핸들러
  */
 export async function handleKinSearch(params) {
-    return client.search({ type: "kin", ...params });
+    return client.search("kin", params);
 }
 /**
  * 지역 검색 핸들러
@@ -47,33 +55,27 @@ export async function handleLocalSearch(params) {
  * 뉴스 검색 핸들러
  */
 export async function handleNewsSearch(params) {
-    return client.search({ type: "news", ...params });
+    return client.search("news", params);
 }
 /**
  * 블로그 검색 핸들러
  */
 export async function handleBlogSearch(params) {
-    return client.search({ type: "blog", ...params });
+    return client.search("blog", params);
 }
 /**
  * 쇼핑 검색 핸들러
  */
 export async function handleShopSearch(params) {
-    return client.search({ type: "shop", ...params });
-}
-/**
- * 웹문서 검색 핸들러
- */
-export async function handleWebSearch(params) {
-    return client.search({ type: "webkr", ...params });
+    return client.search("shop", params);
 }
 /**
  * 카페글 검색 핸들러
  */
 export async function handleCafeArticleSearch(params) {
-    return client.search({ type: "cafearticle", ...params });
+    return client.search("cafearticle", params);
 }
 export async function handleWebKrSearch(args) {
     const client = NaverSearchClient.getInstance();
-    return await client.search({ type: "webkr", ...args });
+    return await client.search("webkr", args);
 }

package/dist/src/handlers/unified-search.handlers.js

@@ -0,0 +1,144 @@
+import { searchToolHandlers } from "./search.handlers.js";
+import { datalabToolHandlers } from "./datalab.handlers.js";
+import { UnifiedSearchSchema } from "../schemas/unified-search.schemas.js";
+/**
+ * 통합 검색 핸들러
+ * 일반 검색과 트렌드 검색을 통합하여 처리
+ * @param args 통합 검색 파라미터
+ * @returns 검색 결과
+ */
+export async function handleUnifiedSearch(args) {
+    // Zod를 사용하여 입력 파라미터 검증
+    const parsedArgs = UnifiedSearchSchema.parse(args);
+    // 검색 유형에 따라 처리
+    if (parsedArgs.searchType === "general") {
+        return handleGeneralSearch(parsedArgs);
+    }
+    else if (parsedArgs.searchType === "trend") {
+        return handleTrendSearch(parsedArgs);
+    }
+    throw new Error("지원하지 않는 검색 유형입니다.");
+}
+/**
+ * 일반 검색 핸들러
+ * @param search 일반 검색 파라미터
+ * @returns 검색 결과
+ */
+async function handleGeneralSearch(search) {
+    const { generalType, params } = search;
+    // 모든 검색 타입을 통합하여 검색하는 경우
+    if (generalType === "all") {
+        return handleAllGeneralSearch(params);
+    }
+    // 단일 검색 유형인 경우
+    const handlerKey = `search_${generalType}`;
+    const handler = searchToolHandlers[handlerKey];
+    if (!handler) {
+        throw new Error(`'${generalType}' 유형에 대한 검색 핸들러가 없습니다.`);
+    }
+    return handler(params);
+}
+/**
+ * 모든 일반 검색을 병렬로 수행하는 핸들러
+ * @param params 검색 파라미터
+ * @returns 모든 검색 결과 (검색 유형별로 객체 키 할당)
+ */
+async function handleAllGeneralSearch(params) {
+    // 모든 가능한 일반 검색 타입 (local과 다른 타입은 파라미터가 다르므로 주의)
+    // 검색할 타입 목록 (local은 파라미터가 다르므로 처리 방식 구분)
+    const generalTypes = [
+        "webkr", "news", "blog", "shop", "image",
+        "kin", "book", "encyc", "academic", "cafearticle"
+    ];
+    // Promise 배열 생성 및 결과 수집
+    const searchPromises = generalTypes.map(type => {
+        const handlerKey = `search_${type}`;
+        const handler = searchToolHandlers[handlerKey];
+        return handler(params)
+            .then(result => ({ type, result }))
+            .catch(error => ({ type, error: error.message }));
+    });
+    // local 검색은 파라미터가 다르지만 동일 인터페이스로 처리
+    const localHandler = searchToolHandlers["search_local"];
+    searchPromises.push(localHandler(params)
+        .then(result => ({ type: "local", result }))
+        .catch(error => ({ type: "local", error: error.message })));
+    // 모든 검색 병렬 실행
+    const results = await Promise.all(searchPromises);
+    // 결과를 유형별로 객체로 변환
+    return results.reduce((acc, item) => {
+        const { type } = item;
+        if ('result' in item) {
+            acc[type] = item.result;
+        }
+        else if ('error' in item) {
+            acc[type] = { error: item.error };
+        }
+        return acc;
+    }, {});
+}
+/**
+ * 트렌드 검색 핸들러
+ * @param search 트렌드 검색 파라미터
+ * @returns 검색 결과
+ */
+async function handleTrendSearch(search) {
+    const { trendType, params } = search;
+    // 모든 트렌드 타입을 통합하여 검색하는 경우
+    if (trendType === "all") {
+        return handleAllTrendSearch(params);
+    }
+    // 단일 트렌드 검색 유형인 경우
+    const handlerKey = `datalab_${trendType}`;
+    const handler = datalabToolHandlers[handlerKey];
+    if (!handler) {
+        throw new Error(`'${trendType}' 유형에 대한 트렌드 검색 핸들러가 없습니다.`);
+    }
+    return handler(params);
+}
+/**
+ * 모든 트렌드 검색을 병렬로 수행하는 핸들러
+ * @param params 트렌드 검색 파라미터
+ * @returns 모든 트렌드 검색 결과 (검색 유형별로 객체 키 할당)
+ */
+async function handleAllTrendSearch(params) {
+    // 파라미터 유형에 따라 가능한 트렌드 검색 타입 결정
+    const trendTypes = [
+        "search"
+    ];
+    // 쇼핑 관련 트렌드는 category 파라미터가 있어야 함
+    if (params.category) {
+        trendTypes.push("shopping_category", "shopping_by_device", "shopping_by_gender", "shopping_by_age", "shopping_keywords");
+        // 키워드 관련 트렌드는 keyword 파라미터가 있어야 함
+        if (params.keyword) {
+            trendTypes.push("shopping_keyword_by_device", "shopping_keyword_by_gender", "shopping_keyword_by_age");
+        }
+    }
+    // Promise 배열 생성 및 결과 수집
+    const trendPromises = trendTypes.map(type => {
+        const handlerKey = `datalab_${type}`;
+        const handler = datalabToolHandlers[handlerKey];
+        // 일부 트렌드 검색은 파라미터 형식이 다를 수 있으므로 
+        // 에러가 발생해도 다른 검색은 계속 진행하도록 처리
+        return handler(params)
+            .then((result) => ({ type, result }))
+            .catch((error) => ({ type, error: error.message }));
+    });
+    // 모든 트렌드 검색 병렬 실행
+    const results = await Promise.all(trendPromises);
+    // 결과를 유형별로 객체로 변환
+    return results.reduce((acc, item) => {
+        const { type } = item;
+        if ('result' in item) {
+            acc[type] = item.result;
+        }
+        else if ('error' in item) {
+            acc[type] = { error: item.error };
+        }
+        return acc;
+    }, {});
+}
+// 통합 검색 도구 핸들러 맵
+export const unifiedSearchToolHandlers = {
+    unified_search: (args) => handleUnifiedSearch(args)
+};