@isnow890/naver-search-mcp 1.0.20 → 1.0.40

package/README.md

@@ -1,13 +1,30 @@
 # Naver Search MCP Server
 
 [![한국어](https://img.shields.io/badge/한국어-README-yellow)](README-ko.md)
+
+[![Trust Score](https://archestra.ai/mcp-catalog/api/badge/quality/isnow890/naver-search-mcp)](https://archestra.ai/mcp-catalog/isnow890__naver-search-mcp)
 [![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.
 
+> ⚠️ **Smithery Installation Notice**: Due to compatibility issues with the Smithery platform, **direct installation is recommended starting from version 1.0.40**. Smithery installation is only supported up to version 1.0.30.
+
 #### Version History
 
+###### 1.0.4 (2025-08-21)
+
+- `find_category` tool added - with fuzzy matching and ranking system support
+- Enhanced parameter validation with Zod schema
+- Improved category search workflow
+- Implemented level-based category ranking system (major categories prioritized)
+
+###### 1.0.30 (2025-08-04)
+
+- MCP SDK upgraded to 1.17.1
+- Fixed compatibility issues with Smithery specification changes
+- Added comprehensive DataLab shopping category code documentation
+
 ###### 1.0.2 (2025-04-26)
 
 - README updated: cafe article search tool and version history section improved
@@ -47,6 +64,12 @@ MCP server for Naver Search API and DataLab API integration, enabling comprehens
 
 ### Available tools:
 
+#### 🆕 Category Search
+
+- **find_category**: Category search tool - No more need to manually check category numbers via URL for trend and shopping insight searches.
+
+#### Search Tools
+
 - **search_webkr**: Search Naver web documents
 - **search_news**: Search Naver news
 - **search_blog**: Search Naver blogs
@@ -58,6 +81,9 @@ MCP server for Naver Search API and DataLab API integration, enabling comprehens
 - **search_encyc**: Search Naver encyclopedia
 - **search_academic**: Search Naver academic papers
 - **search_local**: Search Naver local places
+
+#### DataLab Tools
+
 - **datalab_search**: Analyze search term trends
 - **datalab_shopping_category**: Analyze shopping category trends
 - **datalab_shopping_by_device**: Analyze shopping trends by device
@@ -68,42 +94,249 @@ MCP server for Naver Search API and DataLab API integration, enabling comprehens
 - **datalab_shopping_keyword_by_gender**: Analyze shopping keyword trends by gender
 - **datalab_shopping_keyword_by_age**: Analyze shopping keyword trends by age group
 
+### DataLab Shopping Category Codes
+
+For DataLab shopping analysis tools, you need to use specific **8-digit category codes**. Here are some common examples:
+
+#### Popular Category Codes:
+
+- **50000000**: Fashion/Clothing (패션의류)
+- **50000002**: Cosmetics/Beauty (화장품/미용)
+- **50000003**: Digital/Home Appliances (디지털/가전)
+- **50000004**: Sports/Leisure (스포츠/레저)
+- **50000005**: Automotive/Tools (자동차/공구)
+- **50000006**: Books/Music/DVDs (도서/음반/DVD)
+- **50000007**: Toys/Hobbies (완구/취미)
+- **50000008**: Food/Beverages (식품/음료)
+- **50000009**: Health/Medical (건강/의료용품)
+- **50000010**: Household/Living (생활/주방용품)
+
+#### How to Find Category Codes:
+
+1. Visit [Naver Shopping](https://shopping.naver.com)
+2. Navigate to desired category
+3. Check the `cat_id` parameter in the URL
+4. Use the 8-digit code (e.g., `cat_id=50000000` → use `"50000000"`)
+
+#### Usage Example:
+
+When using shopping category tools, specify category like:
+
+```json
+{
+  "category": "50000000",
+  "startDate": "2024-01-01",
+  "endDate": "2024-01-31",
+  "timeUnit": "month"
+}
+```
+
+#### Complete Category List:
+
+For a complete list of category codes, you can download from Naver Shopping Partner Center or extract them by browsing Naver Shopping categories.
+
+### 🎯 Business Use Cases & Scenarios
+
+#### 🛍️ E-commerce Market Research
+
+```javascript
+// Fashion trend discovery
+find_category("fashion") → Check top fashion categories and codes
+datalab_shopping_category → Analyze seasonal fashion trends
+datalab_shopping_age → Identify fashion target demographics
+datalab_shopping_keywords → Compare "dress" vs "jacket" vs "coat"
+```
+
+#### 📱 Digital Marketing Strategy
+
+```javascript
+// Beauty industry analysis
+find_category("cosmetics") → Find beauty categories
+datalab_shopping_gender → 95% female vs 5% male shoppers
+datalab_shopping_device → Mobile dominance in beauty shopping
+datalab_shopping_keywords → "tint" vs "lipstick" keyword performance
+```
+
+#### 🏢 Business Intelligence & Competitive Analysis
+
+```javascript
+// Tech product insights
+find_category("smartphone") → Check electronics categories
+datalab_shopping_category → Track iPhone vs Galaxy trends
+datalab_shopping_age → 20-30s as main smartphone buyers
+datalab_shopping_device → PC vs mobile shopping behavior
+```
+
+#### 📊 Seasonal Business Planning
+
+```javascript
+// Holiday shopping analysis
+find_category("gift") → Gift categories
+datalab_shopping_category → Black Friday, Christmas trends
+datalab_shopping_keywords → "Mother's Day gift" vs "birthday gift"
+datalab_shopping_age → Age-based gift purchasing patterns
+```
+
+#### 🎯 Customer Persona Development
+
+```javascript
+// Fitness market analysis
+find_category("exercise") → Sports/fitness categories
+datalab_shopping_gender → Male vs female fitness spending
+datalab_shopping_age → Primary fitness demographics (20-40s)
+datalab_shopping_keywords → "home workout" vs "gym" trend analysis
+```
+
+### 📈 Advanced Analysis Scenarios
+
+#### Market Entry Strategy
+
+1. **Category Discovery**: Use `find_category` to explore market segments
+2. **Trend Analysis**: Identify growing vs declining categories
+3. **Demographic Targeting**: Age/gender analysis for customer targeting
+4. **Competitive Intelligence**: Keyword performance comparison
+5. **Device Strategy**: Mobile vs PC shopping optimization
+
+#### Product Launch Planning
+
+1. **Market Validation**: Category growth trends and seasonality
+2. **Target Customers**: Demographic analysis for product positioning
+3. **Marketing Channels**: Device preferences for advertising strategy
+4. **Competitive Landscape**: Keyword competition and opportunities
+5. **Pricing Strategy**: Category performance and price correlation
+
+#### Performance Monitoring
+
+1. **Category Health**: Monitor product category trends
+2. **Keyword Tracking**: Track brand and product keyword performance
+3. **Demographic Shifts**: Monitor changing customer demographics
+4. **Seasonal Patterns**: Plan inventory and marketing campaigns
+5. **Competitive Benchmarking**: Compare performance against category averages
+
+### Quick Reference: Popular Category Codes
+
+| Category            | Code     | Korean        |
+| ------------------- | -------- | ------------- |
+| Fashion/Clothing    | 50000000 | 패션의류      |
+| Cosmetics/Beauty    | 50000002 | 화장품/미용   |
+| Digital/Electronics | 50000003 | 디지털/가전   |
+| Sports/Leisure      | 50000004 | 스포츠/레저   |
+| Food/Beverages      | 50000008 | 식품/음료     |
+| Health/Medical      | 50000009 | 건강/의료용품 |
+
+💡 **Tip**: Use `find_category` with fuzzy searches like "beauty", "fashion", "electronics" to easily find categories.
+
 ## Installation
 
-### Option 1: Quick Install via Smithery (Recommended)
+### Step 1: Download Source Code
 
-To install Naver Search MCP Server automatically via Smithery, use one of these commands based on your AI client:
+To use this MCP server, you need to download the source code first:
 
-For Claude Desktop:
+#### Clone with Git
 
 ```bash
-npx -y @smithery/cli@latest install @isnow890/naver-search-mcp --client claude
+git clone https://github.com/isnow890/naver-search-mcp.git
+cd naver-search-mcp
+npm install
+npm run build
 ```
 
-For Cursor:
+#### Or Download ZIP File
+
+1. Download the latest version from [GitHub Releases](https://github.com/isnow890/naver-search-mcp/releases)
+2. Extract the ZIP file to your desired location
+3. Navigate to the extracted folder in terminal:
 
 ```bash
-npx -y @smithery/cli@latest install @isnow890/naver-search-mcp --client cursor
+cd /path/to/naver-search-mcp
+npm install
+npm run build
 ```
 
-For Windsurf:
+### Step 2: Claude Desktop Configuration
 
-```bash
-npx -y @smithery/cli@latest install @isnow890/naver-search-mcp --client windsurf
+After installation, you'll need the following information:
+
+- **NAVER_CLIENT_ID**: Client ID from Naver Developers
+- **NAVER_CLIENT_SECRET**: Client Secret from Naver Developers
+- **Installation Path**: Absolute path to the downloaded folder
+
+#### Windows Configuration
+
+Add to Claude Desktop config file (`%APPDATA%\Claude\claude_desktop_config.json`):
+
+```json
+{
+  "mcpServers": {
+    "naver-search": {
+      "type": "stdio",
+      "command": "cmd",
+      "args": [
+        "/c",
+        "node",
+        "C:\\path\\to\\naver-search-mcp\\dist\\src\\index.js"
+      ],
+      "cwd": "C:\\path\\to\\naver-search-mcp",
+      "env": {
+        "NAVER_CLIENT_ID": "your-naver-client-id",
+        "NAVER_CLIENT_SECRET": "your-naver-client-secret"
+      }
+    }
+  }
+}
+```
+
+#### macOS/Linux Configuration
+
+Add to Claude Desktop config file (`~/Library/Application Support/Claude/claude_desktop_config.json`):
+
+```json
+{
+  "mcpServers": {
+    "naver-search": {
+      "type": "stdio",
+      "command": "node",
+      "args": ["/path/to/naver-search-mcp/dist/src/index.js"],
+      "cwd": "/path/to/naver-search-mcp",
+      "env": {
+        "NAVER_CLIENT_ID": "your-naver-client-id",
+        "NAVER_CLIENT_SECRET": "your-naver-client-secret"
+      }
+    }
+  }
+}
 ```
 
-For Cline:
+### Step 3: Path Configuration Important Notes
+
+⚠️ **Important**: You must change the following paths in the above configuration to your actual installation paths:
+
+- **Windows**: Change `C:\\path\\to\\naver-search-mcp` to your actual downloaded folder path
+- **macOS/Linux**: Change `/path/to/naver-search-mcp` to your actual downloaded folder path
+
+Finding your path:
 
 ```bash
-npx -y @smithery/cli@latest install @isnow890/naver-search-mcp --client cline
+# Check current location
+pwd
+
+# Absolute path examples
+# Windows: C:\Users\username\Downloads\naver-search-mcp
+# macOS: /Users/username/Downloads/naver-search-mcp
+# Linux: /home/username/Downloads/naver-search-mcp
 ```
 
-The installer will prompt you for:
+### Step 4: Restart Claude Desktop
+
+After completing the configuration, completely close and restart Claude Desktop to activate the Naver Search MCP server.
+
+---
+
+## Alternative Installation Methods
 
-- NAVER_CLIENT_ID
-- NAVER_CLIENT_SECRET
+### Option 2: NPX Installation (For v1.0.30 and below)
 
-### Option 2: Manual Installation
+For older versions that support NPX installation:
 
 #### Environment Variables
 
@@ -117,22 +350,7 @@ export NAVER_CLIENT_ID=your_client_id
 export NAVER_CLIENT_SECRET=your_client_secret
 ```
 
-#### Run with NPX
-
-```bash
-npx @isnow890/naver-search-mcp
-```
-
-#### 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
-```
-
-## Claude Desktop Configuration
+#### Claude Desktop Configuration for NPX
 
 Add to `claude_desktop_config.json`:
 
@@ -151,7 +369,7 @@ Add to `claude_desktop_config.json`:
 }
 ```
 
-## Cursor AI Configuration
+#### Cursor AI Configuration for NPX
 
 Add to `mcp.json`:
 
@@ -170,7 +388,39 @@ Add to `mcp.json`:
 }
 ```
 
-For Docker:
+### Option 3: Legacy Smithery Installation (Only for v1.0.30 and below)
+
+⚠️ **Note**: This method only works for versions 1.0.30 and below due to platform compatibility issues.
+
+#### For Claude Desktop:
+```bash
+npx -y @smithery/cli@latest install @isnow890/naver-search-mcp --client claude
+```
+
+#### For other AI clients:
+```bash
+# Cursor
+npx -y @smithery/cli@latest install @isnow890/naver-search-mcp --client cursor
+
+# Windsurf
+npx -y @smithery/cli@latest install @isnow890/naver-search-mcp --client windsurf
+
+# Cline
+npx -y @smithery/cli@latest install @isnow890/naver-search-mcp --client cline
+```
+
+### Option 4: Docker Installation
+
+For containerized deployment:
+
+```bash
+docker run -i --rm \
+  -e NAVER_CLIENT_ID=your_client_id \
+  -e NAVER_CLIENT_SECRET=your_client_secret \
+  mcp/naver-search
+```
+
+Docker configuration for Claude Desktop:
 
 ```json
 {

package/dist/data/README.md

@@ -0,0 +1,26 @@
+# 카테고리 데이터 폴더
+
+이 폴더에 `categories.xlsx` 파일을 배치하세요.
+
+## 파일 구조
+
+```
+data/
+└── categories.xlsx
+```
+
+## Excel 파일 형식
+
+| 카테고리번호 | 대분류 | 중분류 | 소분류 | 세분류 |
+|-------------|--------|--------|--------|--------|
+| 50003307    | 가구/인테리어 | DIY자재/용품 | 가구부속품 | 가구다리 |
+
+- 첫 번째 행(헤더)은 자동으로 건너뜁니다
+- 카테고리번호는 필수입니다
+- 대분류는 필수, 나머지 분류는 선택사항입니다
+
+## 사용법
+
+1. `categories.xlsx` 파일을 이 폴더에 배치
+2. MCP 서버 시작시 자동으로 로드됨
+3. 파일 수정시 자동으로 캐시 갱신됨

package/dist/src/handlers/category.handlers.js

@@ -0,0 +1,240 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import { fileURLToPath } from 'url';
+import { createRequire } from 'module';
+// Bundle-safe directory resolution
+let __dirname;
+try {
+    if (typeof import.meta.url !== 'undefined') {
+        const __filename = fileURLToPath(import.meta.url);
+        __dirname = path.dirname(__filename);
+    }
+    else {
+        // Fallback for bundled environments
+        __dirname = path.join(process.cwd(), 'dist', 'src', 'handlers');
+    }
+}
+catch {
+    // Final fallback
+    __dirname = path.join(process.cwd(), 'dist', 'src', 'handlers');
+}
+// Cache management
+let categoryCache = null;
+let cacheTimestamp = 0;
+/**
+ * Load and cache category data from Excel file
+ */
+async function loadCategoryData() {
+    // Use __dirname to get the directory of the current module, then go to data folder
+    const dataPath = path.resolve(__dirname, '..', '..', 'data');
+    // Find any Excel file in data directory
+    const files = fs.readdirSync(dataPath);
+    const excelFiles = files.filter(file => file.endsWith('.xlsx') || file.endsWith('.xls'));
+    if (excelFiles.length === 0) {
+        throw new Error(`카테고리 Excel 파일을 찾을 수 없습니다. data 폴더에 .xlsx 또는 .xls 파일을 넣어주세요: ${dataPath}`);
+    }
+    // Use the first Excel file found
+    const filePath = path.join(dataPath, excelFiles[0]);
+    console.error(`Using Excel file: ${excelFiles[0]}`);
+    // Check if file exists (redundant but safe)
+    if (!fs.existsSync(filePath)) {
+        throw new Error(`카테고리 파일을 찾을 수 없습니다: ${filePath}`);
+    }
+    const fileStats = fs.statSync(filePath);
+    // Return cached data if file hasn't changed
+    if (categoryCache && fileStats.mtime.getTime() <= cacheTimestamp) {
+        return categoryCache;
+    }
+    console.error('Loading category data from Excel file...');
+    // Read Excel file - improved ES modules compatibility
+    let XLSX;
+    try {
+        // Try dynamic import first (modern ES modules)
+        try {
+            XLSX = await import('xlsx');
+            // Handle default export structure
+            if (XLSX.default) {
+                XLSX = XLSX.default;
+            }
+        }
+        catch (importError) {
+            // Fallback to createRequire for bundled environments
+            const require = createRequire(import.meta.url);
+            XLSX = require('xlsx');
+        }
+    }
+    catch (error) {
+        throw new Error(`xlsx 패키지 로드 실패. 패키지가 설치되지 않았거나 호환성 문제입니다. 세부사항: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    const workbook = XLSX.readFile(filePath);
+    const sheetName = workbook.SheetNames[0];
+    const worksheet = workbook.Sheets[sheetName];
+    // Convert to JSON (skip header row)
+    const rawData = XLSX.utils.sheet_to_json(worksheet, { header: 1 });
+    const dataRows = rawData.slice(1); // Skip header row
+    // Parse data
+    categoryCache = dataRows
+        .filter(row => row.length >= 2 && row[0]) // Filter out empty rows
+        .map(row => ({
+        code: String(row[0] || '').trim(),
+        level1: String(row[1] || '').trim(),
+        level2: String(row[2] || '').trim(),
+        level3: String(row[3] || '').trim(),
+        level4: String(row[4] || '').trim(),
+    }))
+        .filter(item => item.code); // Only include rows with valid codes
+    cacheTimestamp = fileStats.mtime.getTime();
+    console.error(`Loaded ${categoryCache.length} categories from Excel file`);
+    return categoryCache;
+}
+/**
+ * Smart category search with fuzzy matching and ranking
+ */
+async function smartCategorySearch(query, maxResults = 10) {
+    const categories = await loadCategoryData();
+    const searchQuery = query.toLowerCase().trim();
+    const results = [];
+    for (const category of categories) {
+        let bestScore = 0;
+        let bestMatchType = '';
+        // Check all levels for matches
+        const levels = [
+            { value: category.level1, name: '대분류' },
+            { value: category.level2, name: '중분류' },
+            { value: category.level3, name: '소분류' },
+            { value: category.level4, name: '세분류' }
+        ];
+        for (const level of levels) {
+            if (!level.value)
+                continue;
+            const levelText = level.value.toLowerCase();
+            let score = 0;
+            let matchType = '';
+            // Level-based bonus (대분류 우선)
+            let levelBonus = 0;
+            if (level.name === '대분류')
+                levelBonus = 50;
+            else if (level.name === '중분류')
+                levelBonus = 30;
+            else if (level.name === '소분류')
+                levelBonus = 20;
+            else if (level.name === '세분류')
+                levelBonus = 10;
+            // Exact match (highest priority)
+            if (levelText === searchQuery) {
+                score = 100 + levelBonus;
+                matchType = `정확일치(${level.name})`;
+            }
+            // Starts with (high priority)
+            else if (levelText.startsWith(searchQuery)) {
+                score = 80 + levelBonus;
+                matchType = `시작일치(${level.name})`;
+            }
+            // Contains (medium priority)
+            else if (levelText.includes(searchQuery)) {
+                score = 60 + levelBonus;
+                matchType = `포함일치(${level.name})`;
+            }
+            // Fuzzy match for similar terms
+            else {
+                const similarity = calculateSimilarity(searchQuery, levelText);
+                if (similarity > 0.6) {
+                    score = Math.floor(similarity * 40) + levelBonus; // 0.6-1.0 -> 24-40 points + level bonus
+                    matchType = `유사일치(${level.name})`;
+                }
+            }
+            if (score > bestScore) {
+                bestScore = score;
+                bestMatchType = matchType;
+            }
+        }
+        if (bestScore > 0) {
+            results.push({
+                ...category,
+                score: bestScore,
+                matchType: bestMatchType
+            });
+        }
+    }
+    // Sort by score (descending), then by category code (ascending for 대분류 priority)
+    return results
+        .sort((a, b) => {
+        if (b.score !== a.score) {
+            return b.score - a.score; // Higher score first
+        }
+        // If same score, prioritize by category code (대분류 codes are typically smaller)
+        return a.code.localeCompare(b.code);
+    })
+        .slice(0, maxResults);
+}
+/**
+ * Calculate similarity between two strings (simple implementation)
+ */
+function calculateSimilarity(str1, str2) {
+    const longer = str1.length > str2.length ? str1 : str2;
+    const shorter = str1.length > str2.length ? str2 : str1;
+    if (longer.length === 0)
+        return 1.0;
+    const editDistance = levenshteinDistance(longer, shorter);
+    return (longer.length - editDistance) / longer.length;
+}
+/**
+ * Calculate Levenshtein distance between two strings
+ */
+function levenshteinDistance(str1, str2) {
+    const matrix = Array(str2.length + 1).fill(null).map(() => Array(str1.length + 1).fill(null));
+    for (let i = 0; i <= str1.length; i++)
+        matrix[0][i] = i;
+    for (let j = 0; j <= str2.length; j++)
+        matrix[j][0] = j;
+    for (let j = 1; j <= str2.length; j++) {
+        for (let i = 1; i <= str1.length; i++) {
+            const substitutionCost = str1[i - 1] === str2[j - 1] ? 0 : 1;
+            matrix[j][i] = Math.min(matrix[j][i - 1] + 1, matrix[j - 1][i] + 1, matrix[j - 1][i - 1] + substitutionCost);
+        }
+    }
+    return matrix[str2.length][str1.length];
+}
+/**
+ * 카테고리 검색 핸들러
+ */
+export const findCategoryHandler = async ({ query, max_results = 10 }) => {
+    try {
+        const results = await smartCategorySearch(query, max_results);
+        if (results.length === 0) {
+            return {
+                message: `"${query}"와 관련된 카테고리를 찾을 수 없습니다. 다른 검색어를 시도해보세요.`,
+                suggestions: ["패션", "화장품", "가구", "스마트폰", "가전제품", "스포츠", "도서", "자동차", "식품", "뷰티"]
+            };
+        }
+        const responseData = {
+            message: `"${query}" 검색 결과 (${results.length}개, 관련도순 정렬)`,
+            total_found: results.length,
+            categories: results.map(cat => ({
+                code: cat.code,
+                category: [cat.level1, cat.level2, cat.level3, cat.level4].filter(Boolean).join(' > '),
+                match_type: cat.matchType,
+                score: cat.score,
+                levels: {
+                    대분류: cat.level1 || '',
+                    중분류: cat.level2 || '',
+                    소분류: cat.level3 || '',
+                    세분류: cat.level4 || ''
+                }
+            })),
+            next_steps: {
+                trend_analysis: `이제 datalab_shopping_category 도구로 각 카테고리의 트렌드 분석이 가능합니다`,
+                age_analysis: `datalab_shopping_age 도구로 연령별 쇼핑 패턴을 분석할 수 있습니다`,
+                gender_analysis: `datalab_shopping_gender 도구로 성별 쇼핑 패턴을 분석할 수 있습니다`,
+                device_analysis: `datalab_shopping_device 도구로 디바이스별 쇼핑 패턴을 분석할 수 있습니다`
+            }
+        };
+        return responseData;
+    }
+    catch (error) {
+        throw new Error(`카테고리 검색 중 오류 발생: ${error.message}`);
+    }
+};
+export const categoryToolHandlers = {
+    find_category: findCategoryHandler,
+};

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

@@ -7,15 +7,42 @@ 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), // 쇼핑 키워드 연령별 트렌드
+    datalab_search: (args) => {
+        console.error("datalab_search called with args:", JSON.stringify(args, null, 2));
+        return handleSearchTrend(args);
+    },
+    datalab_shopping_category: (args) => {
+        console.error("datalab_shopping_category called with args:", JSON.stringify(args, null, 2));
+        return handleShoppingCategoryTrend(args);
+    },
+    datalab_shopping_by_device: (args) => {
+        console.error("datalab_shopping_by_device called with args:", JSON.stringify(args, null, 2));
+        return handleShoppingByDeviceTrend(args);
+    },
+    datalab_shopping_by_gender: (args) => {
+        console.error("datalab_shopping_by_gender called with args:", JSON.stringify(args, null, 2));
+        return handleShoppingByGenderTrend(args);
+    },
+    datalab_shopping_by_age: (args) => {
+        console.error("datalab_shopping_by_age called with args:", JSON.stringify(args, null, 2));
+        return handleShoppingByAgeTrend(args);
+    },
+    datalab_shopping_keywords: (args) => {
+        console.error("datalab_shopping_keywords called with args:", JSON.stringify(args, null, 2));
+        return handleShoppingKeywordsTrend(args);
+    },
+    datalab_shopping_keyword_by_device: (args) => {
+        console.error("datalab_shopping_keyword_by_device called with args:", JSON.stringify(args, null, 2));
+        return handleShoppingKeywordByDeviceTrend(args);
+    },
+    datalab_shopping_keyword_by_gender: (args) => {
+        console.error("datalab_shopping_keyword_by_gender called with args:", JSON.stringify(args, null, 2));
+        return handleShoppingKeywordByGenderTrend(args);
+    },
+    datalab_shopping_keyword_by_age: (args) => {
+        console.error("datalab_shopping_keyword_by_age called with args:", JSON.stringify(args, null, 2));
+        return handleShoppingKeywordByAgeTrend(args);
+    },
 };
 /**
  * 검색어 트렌드 핸들러

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

@@ -3,17 +3,50 @@ import { SearchArgsSchema } from "../schemas/search.schemas.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),
+    search_webkr: (args) => {
+        console.error("search_webkr called with args:", JSON.stringify(args, null, 2));
+        return handleWebKrSearch(SearchArgsSchema.parse(args));
+    },
+    search_news: (args) => {
+        console.error("search_news called with args:", JSON.stringify(args, null, 2));
+        return handleNewsSearch(SearchArgsSchema.parse(args));
+    },
+    search_blog: (args) => {
+        console.error("search_blog called with args:", JSON.stringify(args, null, 2));
+        return handleBlogSearch(SearchArgsSchema.parse(args));
+    },
+    search_shop: (args) => {
+        console.error("search_shop called with args:", JSON.stringify(args, null, 2));
+        return handleShopSearch(SearchArgsSchema.parse(args));
+    },
+    search_image: (args) => {
+        console.error("search_image called with args:", JSON.stringify(args, null, 2));
+        return handleImageSearch(SearchArgsSchema.parse(args));
+    },
+    search_kin: (args) => {
+        console.error("search_kin called with args:", JSON.stringify(args, null, 2));
+        return handleKinSearch(SearchArgsSchema.parse(args));
+    },
+    search_book: (args) => {
+        console.error("search_book called with args:", JSON.stringify(args, null, 2));
+        return handleBookSearch(SearchArgsSchema.parse(args));
+    },
+    search_encyc: (args) => {
+        console.error("search_encyc called with args:", JSON.stringify(args, null, 2));
+        return handleEncycSearch(SearchArgsSchema.parse(args));
+    },
+    search_academic: (args) => {
+        console.error("search_academic called with args:", JSON.stringify(args, null, 2));
+        return handleAcademicSearch(SearchArgsSchema.parse(args));
+    },
+    search_local: (args) => {
+        console.error("search_local called with args:", JSON.stringify(args, null, 2));
+        return handleLocalSearch(args);
+    },
+    search_cafearticle: (args) => {
+        console.error("search_cafearticle called with args:", JSON.stringify(args, null, 2));
+        return handleCafeArticleSearch(SearchArgsSchema.parse(args));
+    },
 };
 /**
  * 전문자료 검색 핸들러

package/dist/src/index.js

@@ -1,20 +1,29 @@
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { z } from "zod";
 import { NaverSearchClient } from "./clients/naver-search.client.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";
+import { SearchArgsSchema, NaverLocalSearchParamsSchema, } from "./schemas/search.schemas.js";
+import { DatalabSearchSchema, DatalabShoppingSchema, DatalabShoppingDeviceSchema, DatalabShoppingGenderSchema, DatalabShoppingAgeSchema, DatalabShoppingKeywordsSchema, DatalabShoppingKeywordDeviceSchema, DatalabShoppingKeywordGenderSchema, DatalabShoppingKeywordAgeSchema, } from "./schemas/datalab.schemas.js";
+import { FindCategorySchema } from "./schemas/category.schemas.js";
+import { findCategoryHandler } from "./handlers/category.handlers.js";
 // Configuration schema for Smithery
 export const configSchema = z.object({
     NAVER_CLIENT_ID: z.string().describe("Naver API Client ID"),
-    NAVER_CLIENT_SECRET: z.string().describe("Naver API Client Secret")
+    NAVER_CLIENT_SECRET: z.string().describe("Naver API Client Secret"),
 });
-export default function ({ config }) {
-    // Create a new MCP server per MCP spec
+// Global server instance to prevent memory leaks
+let globalServerInstance = null;
+export function createNaverSearchServer({ config, }) {
+    // Reuse existing server instance to prevent memory leaks
+    if (globalServerInstance) {
+        return globalServerInstance;
+    }
+    // Create a new MCP server only once
     const server = new McpServer({
         name: "naver-search",
-        version: "1.0.18",
+        version: "1.0.40",
     });
     // Initialize Naver client with config
     const client = NaverSearchClient.getInstance();
@@ -22,51 +31,292 @@ export default function ({ config }) {
         clientId: config.NAVER_CLIENT_ID,
         clientSecret: config.NAVER_CLIENT_SECRET,
     });
-    const toolHandlers = {
-        ...searchToolHandlers,
-        ...datalabToolHandlers,
-    };
-    // Add all search tools
-    searchTools.forEach(tool => {
-        server.tool(tool.name, tool.description, tool.inputSchema, async (args) => {
-            try {
-                const handler = toolHandlers[tool.name];
-                if (!handler)
-                    throw new Error(`Unknown tool: ${tool.name}`);
-                const result = await handler(args);
-                return {
-                    content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
-                };
-            }
-            catch (error) {
-                const errorMessage = error instanceof Error ? error.message : String(error);
-                return {
-                    content: [{ type: "text", text: `Error: ${errorMessage}` }],
-                    isError: true,
-                };
-            }
-        });
+    server.registerTool("search_news", {
+        description: "📰 Search latest Korean news articles from major outlets. Perfect for current events, breaking news, and recent developments. Covers politics, economy, society, and international news. (네이버 뉴스 검색 - 최신 뉴스와 시사 정보)",
+        inputSchema: SearchArgsSchema.shape,
+    }, async (args) => {
+        const result = await searchToolHandlers.search_news(args);
+        return {
+            content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+        };
     });
-    // Add all datalab tools
-    datalabTools.forEach(tool => {
-        server.tool(tool.name, tool.description, tool.inputSchema, async (args) => {
-            try {
-                const handler = toolHandlers[tool.name];
-                if (!handler)
-                    throw new Error(`Unknown tool: ${tool.name}`);
-                const result = await handler(args);
-                return {
-                    content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
-                };
-            }
-            catch (error) {
-                const errorMessage = error instanceof Error ? error.message : String(error);
-                return {
-                    content: [{ type: "text", text: `Error: ${errorMessage}` }],
-                    isError: true,
-                };
-            }
-        });
+    server.registerTool("search_blog", {
+        description: "✍️ Search personal blogs and reviews for authentic user experiences. Great for product reviews, personal stories, detailed tutorials, and real user opinions. Find genuine Korean perspectives. (네이버 블로그 검색 - 실제 사용자 후기와 개인적 경험)",
+        inputSchema: SearchArgsSchema.shape,
+    }, async (args) => {
+        const result = await searchToolHandlers.search_blog(args);
+        return {
+            content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+        };
+    });
+    server.registerTool("search_shop", {
+        description: "🛒 Search Naver Shopping for products, prices, and shopping deals. Compare prices across vendors, find product specifications, and discover shopping trends in Korea. (네이버 쇼핑 검색 - 상품 정보와 가격 비교)",
+        inputSchema: SearchArgsSchema.shape,
+    }, async (args) => {
+        const result = await searchToolHandlers.search_shop(args);
+        return {
+            content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+        };
+    });
+    server.registerTool("search_image", {
+        description: "🖼️ Search for images with Korean context and relevance. Find visual content, infographics, charts, and photos related to your search terms. Great for visual research and content discovery. (네이버 이미지 검색 - 시각적 컨텐츠 발견)",
+        inputSchema: SearchArgsSchema.shape,
+    }, async (args) => {
+        const result = await searchToolHandlers.search_image(args);
+        return {
+            content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+        };
+    });
+    server.registerTool("search_kin", {
+        description: "❓ Search Naver KnowledgeiN for Q&A and community-driven answers. Find solutions to problems, get expert advice, and discover community insights on various topics. (네이버 지식iN 검색 - 질문과 답변, 커뮤니티 지식)",
+        inputSchema: SearchArgsSchema.shape,
+    }, async (args) => {
+        const result = await searchToolHandlers.search_kin(args);
+        return {
+            content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+        };
+    });
+    server.registerTool("search_book", {
+        description: "📚 Search for books, publications, and literary content. Find book reviews, author information, publication details, and reading recommendations in Korean literature and translated works. (네이버 책 검색 - 도서 정보와 서평)",
+        inputSchema: SearchArgsSchema.shape,
+    }, async (args) => {
+        const result = await searchToolHandlers.search_book(args);
+        return {
+            content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+        };
+    });
+    server.registerTool("search_encyc", {
+        description: "📖 Search Naver Encyclopedia for authoritative knowledge and definitions. Best for academic research, getting reliable information, and understanding Korean concepts and terminology. (네이버 지식백과 검색 - 신뢰할 수 있는 정보와 정의)",
+        inputSchema: SearchArgsSchema.shape,
+    }, async (args) => {
+        const result = await searchToolHandlers.search_encyc(args);
+        return {
+            content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+        };
+    });
+    server.registerTool("search_academic", {
+        description: "🎓 Search academic papers, research documents, and scholarly content. Access Korean academic resources, research papers, theses, and professional publications. (네이버 전문자료 검색 - 학술 논문과 전문 자료)",
+        inputSchema: SearchArgsSchema.shape,
+    }, async (args) => {
+        const result = await searchToolHandlers.search_academic(args);
+        return {
+            content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+        };
+    });
+    server.registerTool("search_local", {
+        description: "📍 Search for local businesses, restaurants, and places in Korea. Find location information, reviews, contact details, and business hours for Korean establishments. (네이버 지역 검색 - 지역 업체와 장소 정보)",
+        inputSchema: NaverLocalSearchParamsSchema.shape,
+    }, async (args) => {
+        const result = await searchToolHandlers.search_local(args);
+        return {
+            content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+        };
+    });
+    server.registerTool("search_cafearticle", {
+        description: "☕ Search Naver Cafe articles for community discussions and specialized content. Find niche communities, hobby groups, and specialized discussions on various topics. (네이버 카페글 검색 - 커뮤니티 토론과 전문 정보)",
+        inputSchema: SearchArgsSchema.shape,
+    }, async (args) => {
+        const result = await searchToolHandlers.search_cafearticle(args);
+        return {
+            content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+        };
+    });
+    // Register datalab tools
+    server.registerTool("datalab_search", {
+        description: "📊 Analyze search keyword trends over time using Naver DataLab. Track popularity changes, seasonal patterns, and compare multiple keywords. Perfect for market research and trend analysis. (네이버 데이터랩 검색어 트렌드 분석)",
+        inputSchema: DatalabSearchSchema.shape,
+    }, async (args) => {
+        const result = await datalabToolHandlers.datalab_search(args);
+        return {
+            content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+        };
+    });
+    server.registerTool("datalab_shopping_category", {
+        description: "🛍️ STEP 2: Analyze shopping category trends over time. Use find_category first to get category codes. BUSINESS CASES: Market size analysis, seasonal trend identification, category performance comparison. EXAMPLE: Compare '패션의류' vs '화장품' trends over 6 months. (네이버 쇼핑 카테고리별 트렌드 분석 - 먼저 find_category 도구로 카테고리 코드를 찾으세요)",
+        inputSchema: DatalabShoppingSchema.shape,
+    }, async (args) => {
+        const result = await datalabToolHandlers.datalab_shopping_category(args);
+        return {
+            content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+        };
+    });
+    server.registerTool("datalab_shopping_by_device", {
+        description: "📱 Analyze shopping trends by device (PC vs Mobile). Use find_category first. BUSINESS CASES: Mobile commerce strategy, responsive design priority, device-specific campaigns. EXAMPLE: 'PC 사용자가 더 많이 구매하는 카테고리는?' (기기별 쇼핑 트렌드 분석 - 먼저 find_category 도구로 카테고리 코드를 찾으세요)",
+        inputSchema: DatalabShoppingDeviceSchema.pick({
+            startDate: true,
+            endDate: true,
+            timeUnit: true,
+            category: true,
+            device: true,
+        }).shape,
+    }, async (args) => {
+        const result = await datalabToolHandlers.datalab_shopping_by_device(args);
+        return {
+            content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+        };
+    });
+    server.registerTool("datalab_shopping_by_gender", {
+        description: "👥 Analyze shopping trends by gender (Male vs Female). Use find_category first. BUSINESS CASES: Gender-targeted marketing, product positioning, demographic analysis. EXAMPLE: '화장품 쇼핑에서 남녀 비율은?' (성별 쇼핑 트렌드 분석 - 먼저 find_category 도구로 카테고리 코드를 찾으세요)",
+        inputSchema: DatalabShoppingGenderSchema.pick({
+            startDate: true,
+            endDate: true,
+            timeUnit: true,
+            category: true,
+            gender: true,
+        }).shape,
+    }, async (args) => {
+        const result = await datalabToolHandlers.datalab_shopping_by_gender(args);
+        return {
+            content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+        };
     });
+    server.registerTool("datalab_shopping_by_age", {
+        description: "👶👦👨👴 Analyze shopping trends by age groups (10s, 20s, 30s, 40s, 50s, 60s+). Use find_category first. BUSINESS CASES: Age-targeted products, generational preferences, lifecycle marketing. EXAMPLE: '개발 도구는 어느 연령대가 많이 구매하나?' (연령별 쇼핑 트렌드 - 먼저 find_category 도구로 카테고리 코드를 찾으세요)",
+        inputSchema: DatalabShoppingAgeSchema.pick({
+            startDate: true,
+            endDate: true,
+            timeUnit: true,
+            category: true,
+            ages: true,
+        }).shape,
+    }, async (args) => {
+        const result = await datalabToolHandlers.datalab_shopping_by_age(args);
+        return {
+            content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+        };
+    });
+    server.registerTool("datalab_shopping_keywords", {
+        description: "🔍 Compare specific keywords within a shopping category. Use find_category first. BUSINESS CASES: Product keyword optimization, competitor analysis, search trend identification. EXAMPLE: Within '패션' category, compare '원피스' vs '자켓' vs '드레스' trends. (카테고리 내 키워드 비교 - 먼저 find_category 도구로 카테고리 코드를 찾으세요)",
+        inputSchema: DatalabShoppingKeywordsSchema.shape,
+    }, async (args) => {
+        const result = await datalabToolHandlers.datalab_shopping_keywords(args);
+        return {
+            content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+        };
+    });
+    server.registerTool("datalab_shopping_keyword_by_device", {
+        description: "📱🔍 Analyze keyword performance by device within shopping categories. Use find_category first to get category codes. Perfect for understanding mobile vs desktop shopping behavior for specific products. (쇼핑 키워드 기기별 트렌드 - 먼저 find_category 도구로 카테고리 코드를 찾으세요)",
+        inputSchema: DatalabShoppingKeywordDeviceSchema.shape,
+    }, async (args) => {
+        const result = await datalabToolHandlers.datalab_shopping_keyword_by_device(args);
+        return {
+            content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+        };
+    });
+    server.registerTool("datalab_shopping_keyword_by_gender", {
+        description: "👥🔍 Analyze keyword performance by gender within shopping categories. Use find_category first to get category codes. Essential for gender-targeted marketing and product positioning strategies. (쇼핑 키워드 성별 트렌드 - 먼저 find_category 도구로 카테고리 코드를 찾으세요)",
+        inputSchema: DatalabShoppingKeywordGenderSchema.shape,
+    }, async (args) => {
+        const result = await datalabToolHandlers.datalab_shopping_keyword_by_gender(args);
+        return {
+            content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+        };
+    });
+    server.registerTool("datalab_shopping_keyword_by_age", {
+        description: "👶👦👨👴🔍 Analyze keyword performance by age groups within shopping categories. Use find_category first to get category codes. Perfect for age-targeted marketing and understanding generational shopping preferences. (쇼핑 키워드 연령별 트렌드 - 먼저 find_category 도구로 카테고리 코드를 찾으세요)",
+        inputSchema: DatalabShoppingKeywordAgeSchema.shape,
+    }, async (args) => {
+        const result = await datalabToolHandlers.datalab_shopping_keyword_by_age(args);
+        return {
+            content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+        };
+    });
+    // Register category search tool
+    server.registerTool("find_category", {
+        description: "🚀 STEP 1: Find shopping categories with Korean search terms. Search in KOREAN (패션, 화장품, 가전제품, etc.) to find category codes needed for datalab tools. Smart fuzzy matching finds similar categories even with partial matches. (카테고리 검색: 한국어로 검색하여 데이터랩 분석에 필요한 카테고리 코드를 찾아주는 필수 도구)",
+        inputSchema: FindCategorySchema.shape,
+    }, async (args) => {
+        const result = await findCategoryHandler(args);
+        return {
+            content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+        };
+    });
+    // Cache the server instance
+    globalServerInstance = server;
     return server.server;
 }
+// Export default for Smithery compatibility
+export default createNaverSearchServer;
+// Main function to run the server when executed directly
+async function main() {
+    try {
+        console.error("Starting Naver Search MCP Server...");
+        // Get config from environment variables - check for empty strings too
+        const clientId = process.env.NAVER_CLIENT_ID?.trim();
+        const clientSecret = process.env.NAVER_CLIENT_SECRET?.trim();
+        console.error("Environment variables:", {
+            NAVER_CLIENT_ID: process.env.NAVER_CLIENT_ID
+                ? `[${process.env.NAVER_CLIENT_ID.length} chars]`
+                : "undefined",
+            NAVER_CLIENT_SECRET: process.env.NAVER_CLIENT_SECRET
+                ? `[${process.env.NAVER_CLIENT_SECRET.length} chars]`
+                : "undefined",
+        });
+        if (!clientId || !clientSecret) {
+            throw new Error(`Missing required environment variables:
+        NAVER_CLIENT_ID: ${clientId ? "provided" : "missing"}
+        NAVER_CLIENT_SECRET: ${clientSecret ? "provided" : "missing"}
+        
+        Please set these environment variables before running the server.`);
+        }
+        const config = {
+            NAVER_CLIENT_ID: clientId,
+            NAVER_CLIENT_SECRET: clientSecret,
+        };
+        console.error("Config loaded successfully");
+        // Validate config
+        const validatedConfig = configSchema.parse(config);
+        console.error("Config validated successfully");
+        // Create server instance
+        const serverFactory = createNaverSearchServer({ config: validatedConfig });
+        console.error("Server factory created");
+        // Create transport and run server
+        const transport = new StdioServerTransport();
+        console.error("Transport created, connecting...");
+        await serverFactory.connect(transport);
+        console.error("Server connected and running");
+    }
+    catch (error) {
+        console.error("Error in main function:", error);
+        throw error;
+    }
+}
+// Run main function if this file is executed directly
+// Note: Always run main in CLI mode since this is an MCP server
+console.error("Starting MCP server initialization...");
+console.error("process.argv:", process.argv);
+// Check if running as main module - compatible with both ESM and CommonJS
+let isMainModule = false;
+try {
+    // Try ESM approach first
+    if (typeof import.meta !== "undefined" && import.meta.url) {
+        console.error("import.meta.url:", import.meta.url);
+        isMainModule =
+            import.meta.url === `file://${process.argv[1]}` ||
+                import.meta.url.endsWith(process.argv[1]) ||
+                process.argv[1].endsWith("index.js");
+    }
+    else {
+        // Fallback for CommonJS or when import.meta is not available
+        isMainModule =
+            process.argv[1].endsWith("index.js") ||
+                process.argv[1].includes("naver-search-mcp");
+    }
+}
+catch (error) {
+    // Fallback for environments where import.meta causes issues
+    isMainModule =
+        process.argv[1].endsWith("index.js") ||
+            process.argv[1].includes("naver-search-mcp");
+}
+console.error("isMainModule:", isMainModule);
+if (isMainModule) {
+    console.error("Running as main module, starting server...");
+    main().catch((error) => {
+        console.error("Server failed to start:", error);
+        process.exit(1);
+    });
+}
+else {
+    console.error("Not running as main module, skipping server start");
+}

package/dist/src/schemas/category.schemas.js

@@ -0,0 +1,6 @@
+import { z } from "zod";
+// Find category schema - Simple and powerful!
+export const FindCategorySchema = z.object({
+    query: z.string().describe("Korean category search query (한국어 카테고리 검색어, 예: '패션', '화장품', '가구', '스마트폰'). Supports exact match and fuzzy search with level-based priority"),
+    max_results: z.number().optional().default(10).describe("Maximum number of results to return (반환할 최대 결과 수, 기본값: 10)")
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@isnow890/naver-search-mcp",
-  "version": "1.0.20",
+  "version": "1.0.40",
   "description": "Naver Search MCP Server",
   "main": "dist/index.js",
   "module": "./src/index.ts",
@@ -9,8 +9,8 @@
     "dist"
   ],
   "scripts": {
-    "prebuild": "shx rm -rf dist",
-    "build": "tsc",
+    "prebuild": "npx shx rm -rf dist",
+    "build": "tsc && shx cp -r data dist/",
     "prepare": "npm run build",
     "watch": "tsc --watch",
     "start": "node dist/src/index.js"
@@ -19,12 +19,13 @@
     "node": ">=18"
   },
   "dependencies": {
-    "@modelcontextprotocol/sdk": "1.10.2",
+    "@modelcontextprotocol/sdk": "1.17.1",
     "axios": "^1.6.7",
-    "zod": "^3.22.4",
-    "zod-to-json-schema": "^3.23.5",
+    "zod": "^3.23.0",
+    "zod-to-json-schema": "^3.23.0",
     "sharp": "^0.33.2",
-    "dotenv": "^16.4.5"
+    "dotenv": "^16.4.5",
+    "xlsx": "0.18.5"
   },
   "devDependencies": {
     "@types/node": "^22",

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

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

@@ -1,62 +0,0 @@
-import { zodToJsonSchema } from "zod-to-json-schema";
-import { SearchArgsSchema, NaverLocalSearchParamsSchema, } from "../schemas/search.schemas.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),
-    },
-    {
-        name: "search_cafearticle",
-        description: "Perform a search on Naver Cafe Articles. (네이버 카페글 검색)",
-        inputSchema: zodToJsonSchema(SearchArgsSchema),
-    },
-];