@isnow890/naver-search-mcp 1.0.2 → 1.0.3

package/README.md

@@ -6,25 +6,9 @@
 
 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.**
+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
 
@@ -50,7 +34,6 @@ 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

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

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

@@ -1,42 +1,20 @@
-import { NaverSearchClient } from "../clients/naver-search.client.js";
-// 클라이언트 인스턴스 (싱글톤)
+import { NaverSearchClient } from "../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({
@@ -49,8 +27,6 @@ export async function handleShoppingByDeviceTrend(params) {
 }
 /**
  * 쇼핑 성별 트렌드 핸들러
- * 네이버 데이터랩 쇼핑 성별 트렌드 분석 API 호출
- * @param params DatalabShoppingGender
  */
 export async function handleShoppingByGenderTrend(params) {
     return client.datalabShoppingByGender({
@@ -63,8 +39,6 @@ export async function handleShoppingByGenderTrend(params) {
 }
 /**
  * 쇼핑 연령별 트렌드 핸들러
- * 네이버 데이터랩 쇼핑 연령별 트렌드 분석 API 호출
- * @param params DatalabShoppingAge
  */
 export async function handleShoppingByAgeTrend(params) {
     return client.datalabShoppingByAge({
@@ -76,9 +50,8 @@ export async function handleShoppingByAgeTrend(params) {
     });
 }
 /**
- * 쇼핑 키워드 트렌드 핸들러 (복수 키워드 그룹 지원)
- * 네이버 데이터랩 쇼핑 키워드 그룹 트렌드 분석 API 호출
- * @param params DatalabShoppingKeywords
+ * 쇼핑 키워드 트렌드 핸들러
+ * 복수 키워드 그룹을 지원합니다.
  */
 export async function handleShoppingKeywordsTrend(params) {
     // 키워드 배열을 네이버 API에 맞는 형식으로 변환
@@ -87,13 +60,11 @@ 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({
@@ -107,8 +78,6 @@ export async function handleShoppingKeywordByDeviceTrend(params) {
 }
 /**
  * 쇼핑 키워드 성별 트렌드 핸들러
- * 네이버 데이터랩 쇼핑 키워드 성별 트렌드 분석 API 호출
- * @param params DatalabShoppingKeywordGender
  */
 export async function handleShoppingKeywordByGenderTrend(params) {
     return client.datalabShoppingKeywordByGender({
@@ -122,8 +91,6 @@ 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,20 +1,6 @@
-import { NaverSearchClient } from "../clients/naver-search.client.js";
-import { SearchArgsSchema } from "../schemas/search.schemas.js";
+import { NaverSearchClient } from "../naver-search.client.js";
 // 클라이언트 인스턴스
 const client = NaverSearchClient.getInstance();
-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),
-};
 /**
  * 전문자료 검색 핸들러
  */
@@ -25,25 +11,25 @@ export async function handleAcademicSearch(params) {
  * 도서 검색 핸들러
  */
 export async function handleBookSearch(params) {
-    return client.search("book", params);
+    return client.search({ type: "book", ...params });
 }
 /**
  * 지식백과 검색 핸들러
  */
 export async function handleEncycSearch(params) {
-    return client.search("encyc", params);
+    return client.search({ type: "encyc", ...params });
 }
 /**
  * 이미지 검색 핸들러
  */
 export async function handleImageSearch(params) {
-    return client.search("image", params);
+    return client.search({ type: "image", ...params });
 }
 /**
  * 지식iN 검색 핸들러
  */
 export async function handleKinSearch(params) {
-    return client.search("kin", params);
+    return client.search({ type: "kin", ...params });
 }
 /**
  * 지역 검색 핸들러
@@ -55,27 +41,27 @@ export async function handleLocalSearch(params) {
  * 뉴스 검색 핸들러
  */
 export async function handleNewsSearch(params) {
-    return client.search("news", params);
+    return client.search({ type: "news", ...params });
 }
 /**
  * 블로그 검색 핸들러
  */
 export async function handleBlogSearch(params) {
-    return client.search("blog", params);
+    return client.search({ type: "blog", ...params });
 }
 /**
  * 쇼핑 검색 핸들러
  */
 export async function handleShopSearch(params) {
-    return client.search("shop", params);
+    return client.search({ type: "shop", ...params });
 }
 /**
  * 카페글 검색 핸들러
  */
 export async function handleCafeArticleSearch(params) {
-    return client.search("cafearticle", params);
+    return client.search({ type: "cafearticle", ...params });
 }
 export async function handleWebKrSearch(args) {
     const client = NaverSearchClient.getInstance();
-    return await client.search("webkr", args);
+    return await client.search({ type: "webkr", ...args });
 }

package/dist/src/index.js

@@ -1,14 +1,16 @@
+#!/usr/bin/env node
 import * as dotenv from "dotenv";
 import pkg from "../package.json" with { type: "json" };
+dotenv.config();
 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 "./clients/naver-search.client.js";
+import { NaverSearchClient } from "./naver-search.client.js";
+import { SearchArgsSchema } from "./schemas/search.schemas.js";
 import { searchTools } from "./tools/search.tools.js";
 import { datalabTools } from "./tools/datalab.tools.js";
-import { searchToolHandlers } from "./handlers/search.handlers.js";
-import { datalabToolHandlers } from "./handlers/datalab.handlers.js";
-dotenv.config();
+import { handleAcademicSearch, handleBlogSearch, handleBookSearch, handleCafeArticleSearch, 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";
 // 환경 변수 유효성 검사
 const NAVER_CLIENT_ID = process.env.NAVER_CLIENT_ID;
 const NAVER_CLIENT_SECRET = process.env.NAVER_CLIENT_SECRET;
@@ -37,10 +39,6 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
         tools: [...searchTools, ...datalabTools],
     };
 });
-const toolHandlers = {
-    ...searchToolHandlers,
-    ...datalabToolHandlers,
-};
 // 에러 응답 헬퍼 함수
 function createErrorResponse(error) {
     const errorMessage = error instanceof Error ? error.message : String(error);
@@ -58,10 +56,73 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
         if (!args) {
             throw new Error("Arguments are required");
         }
-        const handler = toolHandlers[name];
-        if (!handler)
-            throw new Error(`Unknown tool: ${name}`);
-        const result = await handler(args);
+        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;
+            case "search_cafearticle":
+                result = await handleCafeArticleSearch(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}`);
+        }
         console.error(`Tool ${name} executed successfully`);
         return {
             content: [{ type: "text", text: JSON.stringify(result, null, 2) }],

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

@@ -0,0 +1,155 @@
+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/schemas/search.schemas.js

@@ -1,47 +1,17 @@
 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("검색어"),
-    display: z.number().optional().describe("한 번에 가져올 결과 수 (기본 10)"),
-    start: z.number().optional().describe("검색 시작 위치 (기본 1)"),
-    sort: z
-        .enum(["sim", "date"])
+    query: z.string().describe("Search query"),
+    display: z
+        .number()
         .optional()
-        .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({
+        .describe("Number of results to display (default: 10)"),
+    start: z
+        .number()
+        .optional()
+        .describe("Start position of search results (default: 1)"),
     sort: z
-        .enum(["random", "comment"])
+        .enum(["sim", "date"])
         .optional()
-        .describe("정렬 방식 (random: 정확도순, comment: 리뷰 많은순)"),
-    display: z.number().optional().describe("한 번에 가져올 결과 수 (최대 5)"),
-    start: z.number().optional().describe("검색 시작 위치 (최대 1)"),
+        .describe("Sort method (sim: similarity, date: date)"),
 });

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

@@ -1,5 +1,6 @@
 import { zodToJsonSchema } from "zod-to-json-schema";
-import { SearchArgsSchema, NaverLocalSearchParamsSchema, } from "../schemas/search.schemas.js";
+import { SearchArgsSchema } from "../schemas/search.schemas.js";
+import { NaverLocalSearchParamsSchema } from "../types/naver-search.types.js";
 /**
  * 검색 관련 도구 정의
  */

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

@@ -0,0 +1,61 @@
+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

@@ -0,0 +1,61 @@
+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

package/package.json

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

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

@@ -1,30 +0,0 @@
-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

@@ -1,100 +0,0 @@
-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/types/datalab.types.js

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

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

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