@isnow890/naver-search-mcp 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 isnow890
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE. 

package/README.md

@@ -0,0 +1,166 @@
+# Naver Search MCP Server
+
+[![한국어](https://img.shields.io/badge/한국어-README-yellow)](README-ko.md)
+[![smithery badge](https://smithery.ai/badge/@isnow890/naver-search-mcp)](https://smithery.ai/server/@isnow890/naver-search-mcp)
+[![MCP.so](https://img.shields.io/badge/MCP.so-Naver%20Search%20MCP-blue)](https://mcp.so/server/naver-search-mcp/isnow890)
+
+MCP server for Naver Search API and DataLab API integration, enabling comprehensive search across various Naver services and data trend analysis.
+
+#### Prerequisites
+
+- Naver Developers API Key (Client ID and Secret)
+- Node.js 18 or higher
+- NPM 8 or higher
+- Docker (optional, for container deployment)
+
+#### Getting API Keys
+
+1. Visit [Naver Developers](https://developers.naver.com/apps/#/register)
+2. Click "Register Application"
+3. Enter application name and select ALL of the following APIs:
+   - Search (for blog, news, book search, etc.)
+   - DataLab (Search Trends)
+   - DataLab (Shopping Insight)
+4. Set the obtained Client ID and Client Secret as environment variables
+
+## Tool Details
+
+### Available tools:
+
+- **search_webkr**: Search Naver web documents
+- **search_news**: Search Naver news
+- **search_blog**: Search Naver blogs
+- **search_shop**: Search Naver shopping
+- **search_image**: Search Naver images
+- **search_kin**: Search Naver KnowledgeiN
+- **search_book**: Search Naver books
+- **search_encyc**: Search Naver encyclopedia
+- **search_academic**: Search Naver academic papers
+- **search_local**: Search Naver local places
+- **datalab_search**: Analyze search term trends
+- **datalab_shopping_category**: Analyze shopping category trends
+- **datalab_shopping_by_device**: Analyze shopping trends by device
+- **datalab_shopping_by_gender**: Analyze shopping trends by gender
+- **datalab_shopping_by_age**: Analyze shopping trends by age group
+- **datalab_shopping_keywords**: Analyze shopping keyword trends
+- **datalab_shopping_keyword_by_device**: Analyze shopping keyword trends by device
+- **datalab_shopping_keyword_by_gender**: Analyze shopping keyword trends by gender
+- **datalab_shopping_keyword_by_age**: Analyze shopping keyword trends by age group
+
+## Installation
+
+### Option 1: Quick Install via Smithery (Recommended)
+
+To install Naver Search MCP Server automatically via Smithery, use one of these commands based on your AI client:
+
+For Claude Desktop:
+
+```bash
+npx -y @smithery/cli@latest install @isnow890/naver-search-mcp --client claude
+```
+
+For Cursor:
+
+```bash
+npx -y @smithery/cli@latest install @isnow890/naver-search-mcp --client cursor
+```
+
+For Windsurf:
+
+```bash
+npx -y @smithery/cli@latest install @isnow890/naver-search-mcp --client windsurf
+```
+
+For Cline:
+
+```bash
+npx -y @smithery/cli@latest install @isnow890/naver-search-mcp --client cline
+```
+
+The installer will prompt you for:
+
+- NAVER_CLIENT_ID
+- NAVER_CLIENT_SECRET
+
+### Option 2: Manual Installation
+
+#### Environment Variables
+
+```bash
+# Windows
+set NAVER_CLIENT_ID=your_client_id
+set NAVER_CLIENT_SECRET=your_client_secret
+
+# Linux/Mac
+export NAVER_CLIENT_ID=your_client_id
+export NAVER_CLIENT_SECRET=your_client_secret
+```
+
+#### Run with NPX
+
+```bash
+npx @modelcontextprotocol/server-naver-search
+```
+
+#### Run with Docker
+
+```bash
+docker run -i --rm \
+  -e NAVER_CLIENT_ID=your_client_id \
+  -e NAVER_CLIENT_SECRET=your_client_secret \
+  mcp/naver-search
+```
+
+## Cursor Desktop Configuration
+
+Add to `claude_desktop_config.json`:
+
+```json
+{
+  "mcpServers": {
+    "naver-search": {
+      "command": "npx",
+      "args": ["-y", "@modelcontextprotocol/server-naver-search"],
+      "env": {
+        "NAVER_CLIENT_ID": "your_client_id",
+        "NAVER_CLIENT_SECRET": "your_client_secret"
+      }
+    }
+  }
+}
+```
+
+For Docker:
+
+```json
+{
+  "mcpServers": {
+    "naver-search": {
+      "command": "docker",
+      "args": [
+        "run",
+        "-i",
+        "--rm",
+        "-e",
+        "NAVER_CLIENT_ID=your_client_id",
+        "-e",
+        "NAVER_CLIENT_SECRET=your_client_secret",
+        "mcp/naver-search"
+      ]
+    }
+  }
+}
+```
+## Build
+
+Docker build:
+
+```bash
+docker build -t mcp/naver-search .
+```
+
+
+
+## License
+
+MIT License

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

@@ -0,0 +1,104 @@
+import { NaverSearchClient } from "../naver-search.client.js";
+// 클라이언트 인스턴스
+const client = NaverSearchClient.getInstance();
+/**
+ * 검색어 트렌드 핸들러
+ */
+export async function handleSearchTrend(params) {
+    return client.searchTrend(params);
+}
+/**
+ * 쇼핑 카테고리 트렌드 핸들러
+ */
+export async function handleShoppingCategoryTrend(params) {
+    return client.datalabShoppingCategory(params);
+}
+/**
+ * 쇼핑 기기별 트렌드 핸들러
+ */
+export async function handleShoppingByDeviceTrend(params) {
+    return client.datalabShoppingByDevice({
+        startDate: params.startDate,
+        endDate: params.endDate,
+        timeUnit: params.timeUnit,
+        category: params.category,
+        device: params.device,
+    });
+}
+/**
+ * 쇼핑 성별 트렌드 핸들러
+ */
+export async function handleShoppingByGenderTrend(params) {
+    return client.datalabShoppingByGender({
+        startDate: params.startDate,
+        endDate: params.endDate,
+        timeUnit: params.timeUnit,
+        category: params.category,
+        gender: params.gender,
+    });
+}
+/**
+ * 쇼핑 연령별 트렌드 핸들러
+ */
+export async function handleShoppingByAgeTrend(params) {
+    return client.datalabShoppingByAge({
+        startDate: params.startDate,
+        endDate: params.endDate,
+        timeUnit: params.timeUnit,
+        category: params.category,
+        ages: params.ages,
+    });
+}
+/**
+ * 쇼핑 키워드 트렌드 핸들러
+ * 복수 키워드 그룹을 지원합니다.
+ */
+export async function handleShoppingKeywordsTrend(params) {
+    // 키워드 배열을 네이버 API에 맞는 형식으로 변환
+    return client.datalabShoppingKeywords({
+        startDate: params.startDate,
+        endDate: params.endDate,
+        timeUnit: params.timeUnit,
+        category: params.category,
+        keyword: params.keyword
+    });
+}
+/**
+ * 쇼핑 키워드 기기별 트렌드 핸들러
+ */
+export async function handleShoppingKeywordByDeviceTrend(params) {
+    return client.datalabShoppingKeywordByDevice({
+        startDate: params.startDate,
+        endDate: params.endDate,
+        timeUnit: params.timeUnit,
+        category: params.category,
+        keyword: params.keyword,
+        device: params.device,
+    });
+}
+/**
+ * 쇼핑 키워드 성별 트렌드 핸들러
+ */
+export async function handleShoppingKeywordByGenderTrend(params) {
+    return client.datalabShoppingKeywordByGender({
+        startDate: params.startDate,
+        endDate: params.endDate,
+        timeUnit: params.timeUnit,
+        category: params.category,
+        keyword: params.keyword,
+        gender: params.gender,
+    });
+}
+/**
+ * 쇼핑 키워드 연령별 트렌드 핸들러
+ */
+export async function handleShoppingKeywordByAgeTrend(params) {
+    return client.datalabShoppingKeywordByAge({
+        startDate: params.startDate,
+        endDate: params.endDate,
+        timeUnit: params.timeUnit,
+        category: params.category,
+        keyword: params.keyword,
+        ages: params.ages,
+    });
+}

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

@@ -0,0 +1,79 @@
+import { NaverSearchClient } from "../naver-search.client.js";
+// 클라이언트 인스턴스
+const client = NaverSearchClient.getInstance();
+/**
+ * 기본 검색 핸들러
+ */
+export async function handleSearch(params) {
+    return client.search({ ...params });
+}
+/**
+ * 전문자료 검색 핸들러
+ */
+export async function handleAcademicSearch(params) {
+    return client.searchAcademic(params);
+}
+/**
+ * 도서 검색 핸들러
+ */
+export async function handleBookSearch(params) {
+    return client.search({ type: "book", ...params });
+}
+/**
+ * 지식백과 검색 핸들러
+ */
+export async function handleEncycSearch(params) {
+    return client.search({ type: "encyc", ...params });
+}
+/**
+ * 이미지 검색 핸들러
+ */
+export async function handleImageSearch(params) {
+    return client.search({ type: "image", ...params });
+}
+/**
+ * 지식iN 검색 핸들러
+ */
+export async function handleKinSearch(params) {
+    return client.search({ type: "kin", ...params });
+}
+/**
+ * 지역 검색 핸들러
+ */
+export async function handleLocalSearch(params) {
+    return client.searchLocal(params);
+}
+/**
+ * 뉴스 검색 핸들러
+ */
+export async function handleNewsSearch(params) {
+    return client.search({ type: "news", ...params });
+}
+/**
+ * 블로그 검색 핸들러
+ */
+export async function handleBlogSearch(params) {
+    return client.search({ type: "blog", ...params });
+}
+/**
+ * 쇼핑 검색 핸들러
+ */
+export async function handleShopSearch(params) {
+    return client.search({ type: "shop", ...params });
+}
+/**
+ * 웹문서 검색 핸들러
+ */
+export async function handleWebSearch(params) {
+    return client.search({ type: "webkr", ...params });
+}
+/**
+ * 카페글 검색 핸들러
+ */
+export async function handleCafeArticleSearch(params) {
+    return client.search({ type: "cafearticle", ...params });
+}
+export async function handleWebKrSearch(args) {
+    const client = NaverSearchClient.getInstance();
+    return await client.search({ type: "webkr", ...args });
+}

package/dist/src/index.js

@@ -0,0 +1,154 @@
+#!/usr/bin/env node
+import * as dotenv from "dotenv";
+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 "./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 { 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";
+// 환경 변수 유효성 검사
+const NAVER_CLIENT_ID = process.env.NAVER_CLIENT_ID;
+const NAVER_CLIENT_SECRET = process.env.NAVER_CLIENT_SECRET;
+if (!NAVER_CLIENT_ID || !NAVER_CLIENT_SECRET) {
+    console.error("Error: NAVER_CLIENT_ID and NAVER_CLIENT_SECRET environment variables are required");
+    process.exit(1);
+}
+// 네이버 검색 클라이언트 초기화
+const client = NaverSearchClient.getInstance();
+client.initialize({
+    clientId: NAVER_CLIENT_ID,
+    clientSecret: NAVER_CLIENT_SECRET,
+});
+// MCP 서버 인스턴스 생성
+const server = new Server({
+    name: "naver-search",
+    version: "1.0.0",
+}, {
+    capabilities: {
+        tools: {},
+    },
+});
+// 도구 목록을 반환하는 핸들러 등록
+server.setRequestHandler(ListToolsRequestSchema, async () => {
+    return {
+        tools: [...searchTools, ...datalabTools],
+    };
+});
+// 에러 응답 헬퍼 함수
+function createErrorResponse(error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    console.error("API Error:", errorMessage);
+    return {
+        content: [{ type: "text", text: `Error: ${errorMessage}` }],
+        isError: true,
+    };
+}
+// 도구 실행 요청 핸들러 등록
+server.setRequestHandler(CallToolRequestSchema, async (request) => {
+    try {
+        const { name, arguments: args } = request.params;
+        console.error(`Executing tool: ${name} with args:`, args);
+        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}`);
+        }
+        console.error(`Tool ${name} executed successfully`);
+        return {
+            content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+        };
+    }
+    catch (error) {
+        return createErrorResponse(error);
+    }
+});
+// 서버 시작 함수
+async function runServer() {
+    try {
+        const transport = new StdioServerTransport();
+        // 서버 에러 핸들링
+        process.on("uncaughtException", (error) => {
+            console.error("Uncaught Exception:", error);
+        });
+        process.on("unhandledRejection", (reason, promise) => {
+            console.error("Unhandled Rejection at:", promise, "reason:", reason);
+        });
+        await server.connect(transport);
+        console.error("Naver Search MCP Server running on stdio");
+    }
+    catch (error) {
+        console.error("Fatal error running server:", error);
+        process.exit(1);
+    }
+}
+// 서버 시작
+runServer().catch((error) => {
+    console.error("Fatal error running server:", error);
+    process.exit(1);
+});

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/datalab.schemas.js

@@ -0,0 +1,103 @@
+import { z } from "zod";
+// 기본 DataLab 스키마
+export const DatalabBaseSchema = z.object({
+    startDate: z.string().describe("Start date (yyyy-mm-dd)"),
+    endDate: z.string().describe("End date (yyyy-mm-dd)"),
+    timeUnit: z.enum(["date", "week", "month"]).describe("Time unit"),
+});
+// 검색어 트렌드 스키마
+export const DatalabSearchSchema = DatalabBaseSchema.extend({
+    keywordGroups: z
+        .array(z.object({
+        groupName: z.string().describe("Group name"),
+        keywords: z.array(z.string()).describe("List of keywords"),
+    }))
+        .describe("Keyword groups"),
+});
+// 쇼핑 카테고리 스키마
+export const DatalabShoppingSchema = DatalabBaseSchema.extend({
+    category: z
+        .array(z.object({
+        name: z.string().describe("Category name"),
+        param: z.array(z.string()).describe("Category codes"),
+    }))
+        .describe("Array of category name and code pairs"),
+});
+// 기기별 트렌드 스키마
+export const DatalabShoppingDeviceSchema = DatalabBaseSchema.extend({
+    category: z.string().describe("Category code"),
+    device: z.enum(["pc", "mo"]).describe("Device type"),
+});
+// 성별 트렌드 스키마
+export const DatalabShoppingGenderSchema = DatalabBaseSchema.extend({
+    category: z.string().describe("Category code"),
+    gender: z.enum(["f", "m"]).describe("Gender"),
+});
+// 연령별 트렌드 스키마
+export const DatalabShoppingAgeSchema = DatalabBaseSchema.extend({
+    category: z.string().describe("Category code"),
+    ages: z
+        .array(z.enum(["10", "20", "30", "40", "50", "60"]))
+        .describe("Age groups"),
+});
+// 키워드 트렌드 스키마
+export const DatalabShoppingKeywordsSchema = DatalabBaseSchema.extend({
+    category: z.string().describe("Category code"),
+    keyword: z
+        .array(z.object({
+        name: z.string().describe("Keyword name"),
+        param: z.array(z.string()).describe("Keyword values"),
+    }))
+        .describe("Array of keyword name and value pairs"),
+});
+// 키워드 기기별 트렌드 스키마
+export const DatalabShoppingKeywordDeviceSchema = DatalabBaseSchema.extend({
+    category: z.string().describe("Category code"),
+    keyword: z.string().describe("Search keyword"),
+    device: z.enum(["pc", "mo"]).describe("Device type"),
+});
+// 키워드 성별 트렌드 스키마
+export const DatalabShoppingKeywordGenderSchema = DatalabBaseSchema.extend({
+    category: z.string().describe("Category code"),
+    keyword: z.string().describe("Search keyword"),
+    gender: z.enum(["f", "m"]).describe("Gender"),
+});
+// 키워드 연령별 트렌드 스키마
+export const DatalabShoppingKeywordAgeSchema = DatalabBaseSchema.extend({
+    category: z.string().describe("Category code"),
+    keyword: z.string().describe("Search keyword"),
+    ages: z
+        .array(z.enum(["10", "20", "30", "40", "50", "60"]))
+        .describe("Age groups"),
+});
+// 카테고리 디바이스/성별/연령별 트렌드 스키마
+export const DatalabShoppingCategoryDeviceSchema = DatalabBaseSchema.extend({
+    category: z
+        .array(z.object({
+        name: z.string().describe("Category name"),
+        param: z.array(z.string()).describe("Category codes"),
+    }))
+        .describe("Array of category name and code pairs"),
+    device: z.enum(["pc", "mo"]).optional().describe("Device type"),
+    gender: z.enum(["f", "m"]).optional().describe("Gender"),
+    ages: z
+        .array(z.enum(["10", "20", "30", "40", "50", "60"]))
+        .optional()
+        .describe("Age groups"),
+});
+// 키워드 디바이스/성별/연령별 트렌드 스키마
+export const DatalabShoppingKeywordTrendSchema = DatalabBaseSchema.extend({
+    category: z.string().describe("Category code"),
+    keyword: z
+        .array(z.object({
+        name: z.string().describe("Keyword name"),
+        param: z.array(z.string()).describe("Keyword values"),
+    }))
+        .describe("Array of keyword name and value pairs"),
+    device: z.enum(["pc", "mo"]).optional().describe("Device type"),
+    gender: z.enum(["f", "m"]).optional().describe("Gender"),
+    ages: z
+        .array(z.enum(["10", "20", "30", "40", "50", "60"]))
+        .optional()
+        .describe("Age groups"),
+});

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

@@ -0,0 +1,17 @@
+import { z } from "zod";
+// 기본 검색 파라미터 스키마
+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)"),
+    sort: z
+        .enum(["sim", "date"])
+        .optional()
+        .describe("Sort method (sim: similarity, date: date)"),
+});

package/dist/src/tools/datalab.tools.js

@@ -0,0 +1,70 @@
+import { zodToJsonSchema } from "zod-to-json-schema";
+import { DatalabSearchSchema, DatalabShoppingSchema, DatalabShoppingDeviceSchema, DatalabShoppingGenderSchema, DatalabShoppingAgeSchema, DatalabShoppingKeywordsSchema, DatalabShoppingKeywordDeviceSchema, DatalabShoppingKeywordGenderSchema, DatalabShoppingKeywordAgeSchema } from "../schemas/datalab.schemas.js";
+/**
+ * 데이터랩 관련 도구 정의
+ */
+export const datalabTools = [
+    {
+        name: "datalab_search",
+        description: "Perform a trend analysis on Naver search keywords. (네이버 검색어 트렌드 분석)",
+        inputSchema: zodToJsonSchema(DatalabSearchSchema),
+    },
+    {
+        name: "datalab_shopping_category",
+        description: "Perform a trend analysis on Naver Shopping category. (네이버 쇼핑 카테고리별 트렌드 분석)",
+        inputSchema: zodToJsonSchema(DatalabShoppingSchema),
+    },
+    {
+        name: "datalab_shopping_by_device",
+        description: "Perform a trend analysis on Naver Shopping by device. (네이버 쇼핑 기기별 트렌드 분석)",
+        inputSchema: zodToJsonSchema(DatalabShoppingDeviceSchema.pick({
+            startDate: true,
+            endDate: true,
+            timeUnit: true,
+            category: true,
+            device: true,
+        })),
+    },
+    {
+        name: "datalab_shopping_by_gender",
+        description: "Perform a trend analysis on Naver Shopping by gender. (네이버 쇼핑 성별 트렌드 분석)",
+        inputSchema: zodToJsonSchema(DatalabShoppingGenderSchema.pick({
+            startDate: true,
+            endDate: true,
+            timeUnit: true,
+            category: true,
+            gender: true,
+        })),
+    },
+    {
+        name: "datalab_shopping_by_age",
+        description: "Perform a trend analysis on Naver Shopping by age. (네이버 쇼핑 연령별 트렌드 분석)",
+        inputSchema: zodToJsonSchema(DatalabShoppingAgeSchema.pick({
+            startDate: true,
+            endDate: true,
+            timeUnit: true,
+            category: true,
+            ages: true,
+        })),
+    },
+    {
+        name: "datalab_shopping_keywords",
+        description: "Perform a trend analysis on Naver Shopping keywords. (네이버 쇼핑 키워드별 트렌드 분석)",
+        inputSchema: zodToJsonSchema(DatalabShoppingKeywordsSchema),
+    },
+    {
+        name: "datalab_shopping_keyword_by_device",
+        description: "Perform a trend analysis on Naver Shopping keywords by device. (네이버 쇼핑 키워드 기기별 트렌드 분석)",
+        inputSchema: zodToJsonSchema(DatalabShoppingKeywordDeviceSchema),
+    },
+    {
+        name: "datalab_shopping_keyword_by_gender",
+        description: "Perform a trend analysis on Naver Shopping keywords by gender. (네이버 쇼핑 키워드 성별 트렌드 분석)",
+        inputSchema: zodToJsonSchema(DatalabShoppingKeywordGenderSchema),
+    },
+    {
+        name: "datalab_shopping_keyword_by_age",
+        description: "Perform a trend analysis on Naver Shopping keywords by age. (네이버 쇼핑 키워드 연령별 트렌드 분석)",
+        inputSchema: zodToJsonSchema(DatalabShoppingKeywordAgeSchema),
+    },
+];

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

@@ -0,0 +1,58 @@
+import { zodToJsonSchema } from "zod-to-json-schema";
+import { SearchArgsSchema } from "../schemas/search.schemas.js";
+import { NaverLocalSearchParamsSchema } from "../types/naver-search.types.js";
+/**
+ * 검색 관련 도구 정의
+ */
+export const searchTools = [
+    {
+        name: "search_webkr",
+        description: "Perform a search on Naver Web Documents. (네이버 웹문서 검색)",
+        inputSchema: zodToJsonSchema(SearchArgsSchema),
+    },
+    {
+        name: "search_news",
+        description: "Perform a search on Naver News. (네이버 뉴스 검색)",
+        inputSchema: zodToJsonSchema(SearchArgsSchema),
+    },
+    {
+        name: "search_blog",
+        description: "Perform a search on Naver Blog. (네이버 블로그 검색)",
+        inputSchema: zodToJsonSchema(SearchArgsSchema),
+    },
+    {
+        name: "search_shop",
+        description: "Perform a search on Naver Shopping. (네이버 쇼핑 검색)",
+        inputSchema: zodToJsonSchema(SearchArgsSchema),
+    },
+    {
+        name: "search_image",
+        description: "Perform a search on Naver Image. (네이버 이미지 검색)",
+        inputSchema: zodToJsonSchema(SearchArgsSchema),
+    },
+    {
+        name: "search_kin",
+        description: "Perform a search on Naver KnowledgeiN. (네이버 지식iN 검색)",
+        inputSchema: zodToJsonSchema(SearchArgsSchema),
+    },
+    {
+        name: "search_book",
+        description: "Perform a search on Naver Book. (네이버 책 검색)",
+        inputSchema: zodToJsonSchema(SearchArgsSchema),
+    },
+    {
+        name: "search_encyc",
+        description: "Perform a search on Naver Encyclopedia. (네이버 지식백과 검색)",
+        inputSchema: zodToJsonSchema(SearchArgsSchema),
+    },
+    {
+        name: "search_academic",
+        description: "Perform a search on Naver Academic. (네이버 전문자료 검색)",
+        inputSchema: zodToJsonSchema(SearchArgsSchema),
+    },
+    {
+        name: "search_local",
+        description: "Perform a search on Naver Local. (네이버 지역 검색)",
+        inputSchema: zodToJsonSchema(NaverLocalSearchParamsSchema),
+    },
+];

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

@@ -0,0 +1,39 @@
+{
+  "name": "@isnow890/naver-search-mcp",
+  "version": "1.0.0",
+  "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"
+}