@isnow890/naver-search-mcp 1.0.0 → 1.0.2

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
@@ -99,7 +120,7 @@ export NAVER_CLIENT_SECRET=your_client_secret
 #### Run with NPX
 
 ```bash
-npx @modelcontextprotocol/server-naver-search
+npx @isnow890/naver-search-mcp
 ```
 
 #### Run with Docker
@@ -111,7 +132,7 @@ docker run -i --rm \
   mcp/naver-search
 ```
 
-## Cursor Desktop Configuration
+## Claude Desktop Configuration
 
 Add to `claude_desktop_config.json`:
 
@@ -120,7 +141,26 @@ Add to `claude_desktop_config.json`:
   "mcpServers": {
     "naver-search": {
       "command": "npx",
-      "args": ["-y", "@modelcontextprotocol/server-naver-search"],
+      "args": ["-y", "@isnow890/naver-search-mcp"],
+      "env": {
+        "NAVER_CLIENT_ID": "your_client_id",
+        "NAVER_CLIENT_SECRET": "your_client_secret"
+      }
+    }
+  }
+}
+```
+
+## Cursor AI Configuration
+
+Add to `mcp.json`:
+
+```json
+{
+  "mcpServers": {
+    "naver-search": {
+      "command": "npx",
+      "args": ["-y", "@isnow890/naver-search-mcp"],
       "env": {
         "NAVER_CLIENT_ID": "your_client_id",
         "NAVER_CLIENT_SECRET": "your_client_secret"
@@ -151,6 +191,7 @@ For Docker:
   }
 }
 ```
+
 ## Build
 
 Docker build:
@@ -159,8 +200,6 @@ Docker build:
 docker build -t mcp/naver-search .
 ```
 
-
-
 ## License
 
 MIT License

package/dist/package.json

@@ -0,0 +1,39 @@
+{
+    "name": "@isnow890/naver-search-mcp",
+    "version": "1.0.2",
+    "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"
+    },
+    "engines": {
+        "node": ">=18"
+    },
+    "dependencies": {
+        "@modelcontextprotocol/sdk": "0.5.0",
+        "axios": "^1.6.7",
+        "zod": "^3.22.4",
+        "zod-to-json-schema": "^3.23.5",
+        "sharp": "^0.33.2",
+        "dotenv": "^16.4.5"
+    },
+    "devDependencies": {
+        "@types/node": "^22",
+        "shx": "^0.3.4",
+        "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/index.js

@@ -1,15 +1,14 @@
-#!/usr/bin/env node
 import * as dotenv from "dotenv";
-dotenv.config();
+import pkg from "../package.json" with { type: "json" };
 import { Server } from "@modelcontextprotocol/sdk/server/index.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { CallToolRequestSchema, ListToolsRequestSchema, } from "@modelcontextprotocol/sdk/types.js";
-import { NaverSearchClient } from "./naver-search.client.js";
-import { SearchArgsSchema } from "./schemas/search.schemas.js";
+import { NaverSearchClient } from "./clients/naver-search.client.js";
 import { searchTools } from "./tools/search.tools.js";
 import { datalabTools } from "./tools/datalab.tools.js";
-import { handleAcademicSearch, handleBlogSearch, handleBookSearch, handleEncycSearch, handleImageSearch, handleKinSearch, handleLocalSearch, handleNewsSearch, handleShopSearch, handleWebKrSearch, } from "./handlers/search.handlers.js";
-import { handleSearchTrend, handleShoppingByAgeTrend, handleShoppingByDeviceTrend, handleShoppingByGenderTrend, handleShoppingCategoryTrend, handleShoppingKeywordByAgeTrend, handleShoppingKeywordByDeviceTrend, handleShoppingKeywordByGenderTrend, handleShoppingKeywordsTrend, } from "./handlers/datalab.handlers.js";
+import { searchToolHandlers } from "./handlers/search.handlers.js";
+import { datalabToolHandlers } from "./handlers/datalab.handlers.js";
+dotenv.config();
 // 환경 변수 유효성 검사
 const NAVER_CLIENT_ID = process.env.NAVER_CLIENT_ID;
 const NAVER_CLIENT_SECRET = process.env.NAVER_CLIENT_SECRET;
@@ -26,7 +25,7 @@ client.initialize({
 // MCP 서버 인스턴스 생성
 const server = new Server({
     name: "naver-search",
-    version: "1.0.0",
+    version: pkg.version,
 }, {
     capabilities: {
         tools: {},
@@ -38,6 +37,10 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
         tools: [...searchTools, ...datalabTools],
     };
 });
+const toolHandlers = {
+    ...searchToolHandlers,
+    ...datalabToolHandlers,
+};
 // 에러 응답 헬퍼 함수
 function createErrorResponse(error) {
     const errorMessage = error instanceof Error ? error.message : String(error);
@@ -55,70 +58,10 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
         if (!args) {
             throw new Error("Arguments are required");
         }
-        let result;
-        switch (name) {
-            // 검색 API
-            case "search_webkr":
-                result = await handleWebKrSearch(SearchArgsSchema.parse(args));
-                break;
-            case "search_news":
-                result = await handleNewsSearch(SearchArgsSchema.parse(args));
-                break;
-            case "search_blog":
-                result = await handleBlogSearch(SearchArgsSchema.parse(args));
-                break;
-            case "search_shop":
-                result = await handleShopSearch(SearchArgsSchema.parse(args));
-                break;
-            case "search_image":
-                result = await handleImageSearch(SearchArgsSchema.parse(args));
-                break;
-            case "search_kin":
-                result = await handleKinSearch(SearchArgsSchema.parse(args));
-                break;
-            case "search_book":
-                result = await handleBookSearch(SearchArgsSchema.parse(args));
-                break;
-            case "search_encyc":
-                result = await handleEncycSearch(SearchArgsSchema.parse(args));
-                break;
-            case "search_academic":
-                result = await handleAcademicSearch(SearchArgsSchema.parse(args));
-                break;
-            case "search_local":
-                result = await handleLocalSearch(args);
-                break;
-            // 데이터랩 API
-            case "datalab_search":
-                result = await handleSearchTrend(args);
-                break;
-            case "datalab_shopping_category":
-                result = await handleShoppingCategoryTrend(args);
-                break;
-            case "datalab_shopping_by_device":
-                result = await handleShoppingByDeviceTrend(args);
-                break;
-            case "datalab_shopping_by_gender":
-                result = await handleShoppingByGenderTrend(args);
-                break;
-            case "datalab_shopping_by_age":
-                result = await handleShoppingByAgeTrend(args);
-                break;
-            case "datalab_shopping_keywords":
-                result = await handleShoppingKeywordsTrend(args);
-                break;
-            case "datalab_shopping_keyword_by_device":
-                result = await handleShoppingKeywordByDeviceTrend(args);
-                break;
-            case "datalab_shopping_keyword_by_gender":
-                result = await handleShoppingKeywordByGenderTrend(args);
-                break;
-            case "datalab_shopping_keyword_by_age":
-                result = await handleShoppingKeywordByAgeTrend(args);
-                break;
-            default:
-                throw new Error(`Unknown tool: ${name}`);
-        }
+        const handler = toolHandlers[name];
+        if (!handler)
+            throw new Error(`Unknown tool: ${name}`);
+        const result = await handler(args);
         console.error(`Tool ${name} executed successfully`);
         return {
             content: [{ type: "text", text: JSON.stringify(result, null, 2) }],

package/dist/src/schemas/search.schemas.js

@@ -1,17 +1,47 @@
 import { z } from "zod";
-// 기본 검색 파라미터 스키마
+// 네이버 검색 타입(카테고리)
+export const NaverSearchTypeSchema = z.enum([
+    "news",
+    "encyc",
+    "blog",
+    "shop",
+    "webkr",
+    "image",
+    "doc",
+    "kin",
+    "book",
+    "cafearticle",
+    "local",
+]);
+// 네이버 검색 공통 파라미터
 export const SearchArgsSchema = z.object({
-    query: z.string().describe("Search query"),
-    display: z
-        .number()
-        .optional()
-        .describe("Number of results to display (default: 10)"),
-    start: z
-        .number()
-        .optional()
-        .describe("Start position of search results (default: 1)"),
+    query: z.string().describe("검색어"),
+    display: z.number().optional().describe("한 번에 가져올 결과 수 (기본 10)"),
+    start: z.number().optional().describe("검색 시작 위치 (기본 1)"),
     sort: z
         .enum(["sim", "date"])
         .optional()
-        .describe("Sort method (sim: similarity, date: date)"),
+        .describe("정렬 방식 (sim: 유사도, date: 날짜순)"),
+});
+// 네이버 API 인증 정보
+export const NaverSearchConfigSchema = z.object({
+    clientId: z.string().describe("네이버 개발자센터에서 발급받은 Client ID"),
+    clientSecret: z
+        .string()
+        .describe("네이버 개발자센터에서 발급받은 Client Secret"),
+});
+// 전문자료(논문 등) 검색 파라미터
+export const NaverDocumentSearchParamsSchema = z.object({
+    query: z.string().describe("검색어"),
+    display: z.number().optional().describe("한 번에 가져올 결과 수 (최대 100)"),
+    start: z.number().optional().describe("검색 시작 위치 (최대 1000)"),
+});
+// 지역 검색 파라미터
+export const NaverLocalSearchParamsSchema = SearchArgsSchema.extend({
+    sort: z
+        .enum(["random", "comment"])
+        .optional()
+        .describe("정렬 방식 (random: 정확도순, comment: 리뷰 많은순)"),
+    display: z.number().optional().describe("한 번에 가져올 결과 수 (최대 5)"),
+    start: z.number().optional().describe("검색 시작 위치 (최대 1)"),
 });

package/dist/src/tools/search.tools.js

@@ -1,6 +1,5 @@
 import { zodToJsonSchema } from "zod-to-json-schema";
-import { SearchArgsSchema } from "../schemas/search.schemas.js";
-import { NaverLocalSearchParamsSchema } from "../types/naver-search.types.js";
+import { SearchArgsSchema, NaverLocalSearchParamsSchema, } from "../schemas/search.schemas.js";
 /**
  * 검색 관련 도구 정의
  */
@@ -55,4 +54,9 @@ export const searchTools = [
         description: "Perform a search on Naver Local. (네이버 지역 검색)",
         inputSchema: zodToJsonSchema(NaverLocalSearchParamsSchema),
     },
+    {
+        name: "search_cafearticle",
+        description: "Perform a search on Naver Cafe Articles. (네이버 카페글 검색)",
+        inputSchema: zodToJsonSchema(SearchArgsSchema),
+    },
 ];

package/dist/src/types/datalab.types.js

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

package/dist/src/types/search.types.js

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@isnow890/naver-search-mcp",
-  "version": "1.0.0",
+  "version": "1.0.2",
   "description": "Naver Search MCP Server",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

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

@@ -1,155 +0,0 @@
-import axios from "axios";
-/**
- * NaverSearchClient - 네이버 API 서비스를 위한 싱글톤 클라이언트
- * 검색, 데이터랩 API 요청 처리
- */
-export class NaverSearchClient {
-    constructor() {
-        this.searchBaseUrl = "https://openapi.naver.com/v1/search";
-        this.datalabBaseUrl = "https://openapi.naver.com/v1/datalab";
-        this.config = null;
-    }
-    /**
-     * 싱글톤 인스턴스 반환
-     */
-    static getInstance() {
-        if (!NaverSearchClient.instance) {
-            NaverSearchClient.instance = new NaverSearchClient();
-        }
-        return NaverSearchClient.instance;
-    }
-    /**
-     * API 자격 증명으로 클라이언트 초기화
-     */
-    initialize(config) {
-        this.config = config;
-    }
-    /**
-     * API 요청에 필요한 헤더 생성
-     * @throws 클라이언트가 초기화되지 않은 경우 에러 발생
-     */
-    getHeaders(contentType = "application/json") {
-        if (!this.config) {
-            throw new Error("NaverSearchClient is not initialized. Please call initialize() first.");
-        }
-        const headers = {
-            "X-Naver-Client-Id": this.config.clientId,
-            "X-Naver-Client-Secret": this.config.clientSecret,
-            "Content-Type": contentType,
-        };
-        return { headers };
-    }
-    /**
-     * 모든 검색 유형을 지원하는 일반 검색 메서드
-     */
-    async search(params) {
-        const { type, ...searchParams } = params;
-        const response = await axios.get(`${this.searchBaseUrl}/${type}`, {
-            params: searchParams,
-            ...this.getHeaders(),
-        });
-        return response.data;
-    }
-    /**
-     * 전문자료 검색 메서드
-     */
-    async searchAcademic(params) {
-        return this.search({ type: "doc", ...params });
-    }
-    /**
-     * 지역 검색 메서드
-     */
-    async searchLocal(params) {
-        const response = await axios.get(`${this.searchBaseUrl}/local`, {
-            params: { ...params },
-            ...this.getHeaders(),
-        });
-        return response.data;
-    }
-    /**
-     * 검색어 트렌드 분석 메서드
-     */
-    async searchTrend(params) {
-        return this.post("datalab", "/search", params);
-    }
-    /**
-     * 쇼핑 카테고리 트렌드 분석 메서드
-     */
-    async datalabShoppingCategory(params) {
-        return this.post("datalab", "/shopping/categories", params);
-    }
-    /**
-     * 쇼핑 기기별 트렌드 분석 메서드
-     */
-    async datalabShoppingByDevice(params) {
-        return this.post("datalab", "/shopping/category/device", params);
-    }
-    /**
-     * 쇼핑 성별 트렌드 분석 메서드
-     */
-    async datalabShoppingByGender(params) {
-        return this.post("datalab", "/shopping/category/gender", params);
-    }
-    /**
-     * 쇼핑 연령별 트렌드 분석 메서드
-     */
-    async datalabShoppingByAge(params) {
-        return this.post("datalab", "/shopping/category/age", params);
-    }
-    /**
-     * 쇼핑 키워드 트렌드 분석 메서드
-     */
-    async datalabShoppingKeywords(params) {
-        return this.post("datalab", "/shopping/category/keywords", params);
-    }
-    /**
-     * 쇼핑 키워드 기기별 트렌드 분석 메서드
-     */
-    async datalabShoppingKeywordByDevice(params) {
-        return this.post("datalab", "/shopping/category/keyword/device", params);
-    }
-    /**
-     * 쇼핑 키워드 성별 트렌드 분석 메서드
-     */
-    async datalabShoppingKeywordByGender(params) {
-        return this.post("datalab", "/shopping/category/keyword/gender", params);
-    }
-    /**
-     * 쇼핑 키워드 연령별 트렌드 분석 메서드
-     */
-    async datalabShoppingKeywordByAge(params) {
-        return this.post("datalab", "/shopping/category/keyword/age", params);
-    }
-    /**
-     * POST 요청 처리 헬퍼 메서드
-     * @param apiType - API 유형 (search, datalab)
-     * @param endpoint - API 엔드포인트
-     * @param data - 요청 데이터
-     */
-    async post(apiType, endpoint, data) {
-        if (!this.config) {
-            throw new Error("NaverSearchClient is not initialized. Please call initialize() first.");
-        }
-        const baseUrl = {
-            search: this.searchBaseUrl,
-            datalab: this.datalabBaseUrl,
-        }[apiType];
-        try {
-            const headers = {
-                "X-Naver-Client-Id": this.config.clientId,
-                "X-Naver-Client-Secret": this.config.clientSecret,
-            };
-            const response = await axios.post(`${baseUrl}${endpoint}`, data, {
-                headers,
-            });
-            return response.data;
-        }
-        catch (error) {
-            if (axios.isAxiosError(error)) {
-                throw new Error(`Naver API Error: ${error.response?.data?.errorMessage || error.message}`);
-            }
-            throw error;
-        }
-    }
-}
-NaverSearchClient.instance = null;

package/dist/src/types/naver-search.types.js

@@ -1,61 +0,0 @@
-import { z } from "zod";
-export const NaverSearchTypeSchema = z.enum([
-    "news",
-    "encyc",
-    "blog",
-    "shop",
-    "webkr",
-    "image",
-    "doc",
-    "kin",
-    "book",
-    "cafearticle",
-    "local",
-]);
-export const NaverSearchParamsSchema = z.object({
-    query: z.string().describe("Search query"),
-    display: z
-        .number()
-        .optional()
-        .describe("Number of results to display (default: 10)"),
-    start: z
-        .number()
-        .optional()
-        .describe("Start position of search results (default: 1)"),
-    sort: z
-        .enum(["sim", "date"])
-        .optional()
-        .describe("Sort method (sim: similarity, date: chronological)"),
-});
-export const NaverSearchConfigSchema = z.object({
-    clientId: z.string().describe("Client ID issued by Naver Developer Center"),
-    clientSecret: z
-        .string()
-        .describe("Client Secret issued by Naver Developer Center"),
-});
-// 전문자료 검색 파라미터 스키마
-export const NaverDocumentSearchParamsSchema = z.object({
-    query: z.string().describe("Search query"),
-    display: z
-        .number()
-        .optional()
-        .describe("Number of results to display (default: 10, max: 100)"),
-    start: z
-        .number()
-        .optional()
-        .describe("Start position of search results (default: 1, max: 1000)"),
-});
-// 지역 검색 파라미터 스키마
-export const NaverLocalSearchParamsSchema = NaverSearchParamsSchema.extend({
-    sort: z.enum(["random", "comment"])
-        .optional()
-        .describe("Sort method (random: accuracy, comment: review count)"),
-    display: z
-        .number()
-        .optional()
-        .describe("Number of results to display (default: 1, max: 5)"),
-    start: z
-        .number()
-        .optional()
-        .describe("Start position of search results (default: 1, max: 1)"),
-});

package/dist/src/utils/image-processor.js

@@ -1,61 +0,0 @@
-import sharp from "sharp";
-export class ImageProcessor {
-    /**
-     * base64 이미지를 압축하여 Buffer로 반환
-     * @param base64Image base64로 인코딩된 이미지
-     * @returns 압축된 이미지 Buffer
-     */
-    static async compressImage(base64Image) {
-        const imageBuffer = Buffer.from(base64Image, "base64");
-        // 이미지 크기가 2MB 이하면 그대로 반환
-        if (imageBuffer.length <= this.MAX_SIZE) {
-            return imageBuffer;
-        }
-        // 이미지 메타데이터 가져오기
-        const metadata = await sharp(imageBuffer).metadata();
-        // 압축 품질 계산 (2MB를 기준으로 비율 계산)
-        const quality = Math.floor((this.MAX_SIZE / imageBuffer.length) * 100);
-        // 이미지 크기 조절 계수 계산
-        const scale = Math.sqrt(this.MAX_SIZE / imageBuffer.length);
-        const width = Math.floor((metadata.width || 1000) * scale);
-        const height = Math.floor((metadata.height || 1000) * scale);
-        // 이미지 압축
-        const compressedBuffer = await sharp(imageBuffer)
-            .resize(width, height, {
-            fit: "inside",
-            withoutEnlargement: true,
-        })
-            .jpeg({
-            quality: Math.max(quality, 60), // 최소 품질 60으로 제한
-            progressive: true,
-        })
-            .toBuffer();
-        // 압축 후에도 2MB를 초과하면 더 강하게 압축
-        if (compressedBuffer.length > this.MAX_SIZE) {
-            return await sharp(compressedBuffer)
-                .jpeg({
-                quality: 60,
-                progressive: true,
-            })
-                .toBuffer();
-        }
-        return compressedBuffer;
-    }
-    /**
-     * 이미지 크기 확인
-     * @param imageBuffer 이미지 버퍼
-     * @returns 이미지 크기가 2MB를 초과하는지 여부
-     */
-    static isOversize(imageBuffer) {
-        return imageBuffer.length > this.MAX_SIZE;
-    }
-    /**
-     * 이미지 메타데이터 확인
-     * @param imageBuffer 이미지 버퍼
-     * @returns 이미지 메타데이터
-     */
-    static async getMetadata(imageBuffer) {
-        return await sharp(imageBuffer).metadata();
-    }
-}
-ImageProcessor.MAX_SIZE = 2 * 1024 * 1024; // 2MB