@yilin-jing/youtube-mcp-server 1.0.0 → 1.3.0

package/README.md

@@ -1,7 +1,8 @@
 # YouTube MCP Server
-[![smithery badge](https://smithery.ai/badge/@ZubeidHendricks/youtube)](https://smithery.ai/server/@ZubeidHendricks/youtube)
 
-A Model Context Protocol (MCP) server implementation for YouTube, enabling AI language models to interact with YouTube content through a standardized interface.
+[![npm version](https://img.shields.io/npm/v/@yilin-jing/youtube-mcp-server.svg)](https://www.npmjs.com/package/@yilin-jing/youtube-mcp-server)
+
+A Model Context Protocol (MCP) server implementation for YouTube, enabling AI language models to interact with YouTube content through a standardized interface. Updated to support MCP SDK 1.23.
 
 ## Features
 
@@ -26,8 +27,7 @@ A Model Context Protocol (MCP) server implementation for YouTube, enabling AI la
 ### Playlist Management
 * List playlist items
 * Get playlist details
-* Search within playlists
-* Get playlist video transcripts
+* Search playlists
 
 ## Installation
 
@@ -35,7 +35,7 @@ A Model Context Protocol (MCP) server implementation for YouTube, enabling AI la
 
 1. Install the package:
 ```bash
-npm install -g zubeid-youtube-mcp-server
+npm install -g @yilin-jing/youtube-mcp-server
 ```
 
 2. Add to your Claude Desktop configuration (`~/Library/Application Support/Claude/claude_desktop_config.json` on macOS or `%APPDATA%\Claude\claude_desktop_config.json` on Windows):
@@ -43,8 +43,8 @@ npm install -g zubeid-youtube-mcp-server
 ```json
 {
   "mcpServers": {
-    "zubeid-youtube-mcp-server": {
-      "command": "zubeid-youtube-mcp-server",
+    "youtube": {
+      "command": "youtube-mcp-server",
       "env": {
         "YOUTUBE_API_KEY": "your_youtube_api_key_here"
       }
@@ -62,7 +62,7 @@ Add this to your Claude Desktop configuration:
   "mcpServers": {
     "youtube": {
       "command": "npx",
-      "args": ["-y", "zubeid-youtube-mcp-server"],
+      "args": ["-y", "@yilin-jing/youtube-mcp-server"],
       "env": {
         "YOUTUBE_API_KEY": "your_youtube_api_key_here"
       }
@@ -71,118 +71,70 @@ Add this to your Claude Desktop configuration:
 }
 ```
 
-### Installing via Smithery
-
-To install YouTube MCP Server for Claude Desktop automatically via [Smithery](https://smithery.ai/server/@ZubeidHendricks/youtube):
-
-```bash
-npx -y @smithery/cli install @ZubeidHendricks/youtube --client claude
-```
-
 ## Configuration
+
 Set the following environment variables:
 * `YOUTUBE_API_KEY`: Your YouTube Data API key (required)
 * `YOUTUBE_TRANSCRIPT_LANG`: Default language for transcripts (optional, defaults to 'en')
-### Using with VS Code
-
-For one-click installation, click one of the install buttons below:
-
-[![Install with NPX in VS Code](https://img.shields.io/badge/VS_Code-NPM-0098FF?style=flat-square&logo=visualstudiocode&logoColor=white)](https://insiders.vscode.dev/redirect/mcp/install?name=youtube&config=%7B%22command%22%3A%22npx%22%2C%22args%22%3A%5B%22-y%22%2C%22zubeid-youtube-mcp-server%22%5D%2C%22env%22%3A%7B%22YOUTUBE_API_KEY%22%3A%22%24%7Binput%3AapiKey%7D%22%7D%7D&inputs=%5B%7B%22type%22%3A%22promptString%22%2C%22id%22%3A%22apiKey%22%2C%22description%22%3A%22YouTube+API+Key%22%2C%22password%22%3Atrue%7D%5D) [![Install with NPX in VS Code Insiders](https://img.shields.io/badge/VS_Code_Insiders-NPM-24bfa5?style=flat-square&logo=visualstudiocode&logoColor=white)](https://insiders.vscode.dev/redirect/mcp/install?name=youtube&config=%7B%22command%22%3A%22npx%22%2C%22args%22%3A%5B%22-y%22%2C%22zubeid-youtube-mcp-server%22%5D%2C%22env%22%3A%7B%22YOUTUBE_API_KEY%22%3A%22%24%7Binput%3AapiKey%7D%22%7D%7D&inputs=%5B%7B%22type%22%3A%22promptString%22%2C%22id%22%3A%22apiKey%22%2C%22description%22%3A%22YouTube+API+Key%22%2C%22password%22%3Atrue%7D%5D&quality=insiders)
-
-### Manual Installation
-
-If you prefer manual installation, first check the install buttons at the top of this section. Otherwise, follow these steps:
-
-Add the following JSON block to your User Settings (JSON) file in VS Code. You can do this by pressing `Ctrl + Shift + P` and typing `Preferences: Open User Settings (JSON)`.
-
-```json
-{
-  "mcp": {
-    "inputs": [
-      {
-        "type": "promptString",
-        "id": "apiKey",
-        "description": "YouTube API Key",
-        "password": true
-      }
-    ],
-    "servers": {
-      "youtube": {
-        "command": "npx",
-        "args": ["-y", "zubeid-youtube-mcp-server"],
-        "env": {
-          "YOUTUBE_API_KEY": "${input:apiKey}"
-        }
-      }
-    }
-  }
-}
-```
-
-Optionally, you can add it to a file called `.vscode/mcp.json` in your workspace:
 
-```json
-{
-  "inputs": [
-    {
-      "type": "promptString",
-      "id": "apiKey",
-      "description": "YouTube API Key",
-      "password": true
-    }
-  ],
-  "servers": {
-    "youtube": {
-      "command": "npx",
-      "args": ["-y", "zubeid-youtube-mcp-server"],
-      "env": {
-        "YOUTUBE_API_KEY": "${input:apiKey}"
-      }
-    }
-  }
-}
-```
 ## YouTube API Setup
-1. Go to Google Cloud Console
+
+1. Go to [Google Cloud Console](https://console.cloud.google.com/)
 2. Create a new project or select an existing one
 3. Enable the YouTube Data API v3
 4. Create API credentials (API key)
 5. Copy the API key for configuration
 
+## Available Tools
+
+| Tool | Description |
+|------|-------------|
+| `videos_getVideo` | Get detailed information about a YouTube video |
+| `videos_searchVideos` | Search for videos on YouTube |
+| `transcripts_getTranscript` | Get the transcript of a YouTube video |
+| `channels_getChannel` | Get information about a YouTube channel |
+| `channels_listVideos` | Get videos from a specific channel |
+| `playlists_getPlaylist` | Get information about a YouTube playlist |
+| `playlists_getPlaylistItems` | Get videos in a YouTube playlist |
+
 ## Examples
 
 ### Managing Videos
 
 ```javascript
 // Get video details
-const video = await youtube.videos.getVideo({
-  videoId: "video-id"
-});
-
-// Get video transcript
-const transcript = await youtube.transcripts.getTranscript({
-  videoId: "video-id",
-  language: "en"
+const video = await youtube.videos_getVideo({
+  videoId: "dQw4w9WgXcQ"
 });
 
 // Search videos
-const searchResults = await youtube.videos.searchVideos({
-  query: "search term",
+const searchResults = await youtube.videos_searchVideos({
+  query: "TypeScript tutorial",
   maxResults: 10
 });
 ```
 
+### Managing Transcripts
+
+```javascript
+// Get video transcript
+const transcript = await youtube.transcripts_getTranscript({
+  videoId: "dQw4w9WgXcQ",
+  language: "en"
+});
+```
+
 ### Managing Channels
 
 ```javascript
 // Get channel details
-const channel = await youtube.channels.getChannel({
-  channelId: "channel-id"
+const channel = await youtube.channels_getChannel({
+  channelId: "UC_x5XG1OV2P6uZZ5FSM9Ttw"
 });
 
 // List channel videos
-const videos = await youtube.channels.listVideos({
-  channelId: "channel-id",
+const videos = await youtube.channels_listVideos({
+  channelId: "UC_x5XG1OV2P6uZZ5FSM9Ttw",
   maxResults: 50
 });
 ```
@@ -191,14 +143,14 @@ const videos = await youtube.channels.listVideos({
 
 ```javascript
 // Get playlist items
-const playlistItems = await youtube.playlists.getPlaylistItems({
-  playlistId: "playlist-id",
+const playlistItems = await youtube.playlists_getPlaylistItems({
+  playlistId: "PLrAXtmErZgOeiKm4sgNOknGvNjby9efdf",
   maxResults: 50
 });
 
 // Get playlist details
-const playlist = await youtube.playlists.getPlaylist({
-  playlistId: "playlist-id"
+const playlist = await youtube.playlists_getPlaylist({
+  playlistId: "PLrAXtmErZgOeiKm4sgNOknGvNjby9efdf"
 });
 ```
 
@@ -207,19 +159,32 @@ const playlist = await youtube.playlists.getPlaylist({
 ```bash
 # Install dependencies
 npm install
-
-# Run tests
-npm test
+# or
+bun install
 
 # Build
 npm run build
 
-# Lint
-npm run lint
+# Run tests
+bun test
+
+# Start server
+npm start
 ```
 
-## Contributing
-See CONTRIBUTING.md for information about contributing to this repository.
+## Testing
+
+This project includes 50 comprehensive tests covering all services:
+
+```bash
+# Run tests with bun
+YOUTUBE_API_KEY="your_api_key" bun test
+```
 
 ## License
+
 This project is licensed under the MIT License - see the LICENSE file for details.
+
+## Credits
+
+Originally forked from [ZubeidHendricks/youtube-mcp-server](https://github.com/ZubeidHendricks/youtube-mcp-server), updated with MCP SDK 1.23 support and comprehensive test coverage.

package/dist/cleaners.d.ts

@@ -0,0 +1,13 @@
+export declare const DataCleaners: {
+    cleanVideo: (video: any) => any;
+    cleanSearchResult: (item: any) => any;
+    cleanChannel: (channel: any) => any;
+    cleanPlaylist: (playlist: any) => any;
+    cleanPlaylistItem: (item: any) => any;
+    cleanTranscript: (result: any) => any;
+    cleanVideoList: (videos: any[]) => any[];
+    cleanSearchResults: (items: any[]) => any[];
+    cleanPlaylistItems: (items: any[]) => any[];
+    cleanComment: (item: any) => any;
+    cleanComments: (result: any) => any;
+};

package/dist/cleaners.js

@@ -0,0 +1,145 @@
+// Data cleaners for YouTube entities - removes redundant data for token efficiency
+export const DataCleaners = {
+    cleanVideo: (video) => {
+        if (!video)
+            return null;
+        const snippet = video.snippet || {};
+        const stats = video.statistics || {};
+        const content = video.contentDetails || {};
+        return {
+            id: video.id,
+            title: snippet.title,
+            channel: snippet.channelTitle,
+            channelId: snippet.channelId,
+            published: snippet.publishedAt,
+            description: snippet.description?.substring(0, 300),
+            duration: content.duration,
+            views: stats.viewCount ? parseInt(stats.viewCount) : undefined,
+            likes: stats.likeCount ? parseInt(stats.likeCount) : undefined,
+            comments: stats.commentCount ? parseInt(stats.commentCount) : undefined,
+            tags: snippet.tags?.slice(0, 5),
+        };
+    },
+    cleanSearchResult: (item) => {
+        if (!item)
+            return null;
+        const snippet = item.snippet || {};
+        return {
+            id: item.id?.videoId || item.id,
+            title: snippet.title,
+            channel: snippet.channelTitle,
+            channelId: snippet.channelId,
+            published: snippet.publishedAt,
+            description: snippet.description?.substring(0, 200),
+        };
+    },
+    cleanChannel: (channel) => {
+        if (!channel)
+            return null;
+        const snippet = channel.snippet || {};
+        const stats = channel.statistics || {};
+        return {
+            id: channel.id,
+            title: snippet.title,
+            description: snippet.description?.substring(0, 300),
+            customUrl: snippet.customUrl,
+            published: snippet.publishedAt,
+            country: snippet.country,
+            subscribers: stats.subscriberCount ? parseInt(stats.subscriberCount) : undefined,
+            videos: stats.videoCount ? parseInt(stats.videoCount) : undefined,
+            views: stats.viewCount ? parseInt(stats.viewCount) : undefined,
+        };
+    },
+    cleanPlaylist: (playlist) => {
+        if (!playlist)
+            return null;
+        const snippet = playlist.snippet || {};
+        const content = playlist.contentDetails || {};
+        return {
+            id: playlist.id,
+            title: snippet.title,
+            channel: snippet.channelTitle,
+            channelId: snippet.channelId,
+            description: snippet.description?.substring(0, 200),
+            published: snippet.publishedAt,
+            itemCount: content.itemCount,
+        };
+    },
+    cleanPlaylistItem: (item) => {
+        if (!item)
+            return null;
+        const snippet = item.snippet || {};
+        return {
+            id: snippet.resourceId?.videoId,
+            title: snippet.title,
+            channel: snippet.videoOwnerChannelTitle,
+            position: snippet.position,
+            published: snippet.publishedAt,
+        };
+    },
+    cleanTranscript: (result) => {
+        if (!result)
+            return null;
+        const segments = result.transcript || result;
+        if (!Array.isArray(segments))
+            return { videoId: result.videoId, segments: [] };
+        return {
+            videoId: result.videoId,
+            language: result.language,
+            segments: segments.map(s => ({
+                text: s.text,
+                start: s.offset ?? s.start,
+                duration: s.duration,
+            })),
+        };
+    },
+    cleanVideoList: (videos) => {
+        if (!Array.isArray(videos))
+            return [];
+        return videos.map(DataCleaners.cleanVideo).filter(Boolean);
+    },
+    cleanSearchResults: (items) => {
+        if (!Array.isArray(items))
+            return [];
+        return items.map(DataCleaners.cleanSearchResult).filter(Boolean);
+    },
+    cleanPlaylistItems: (items) => {
+        if (!Array.isArray(items))
+            return [];
+        return items.map(DataCleaners.cleanPlaylistItem).filter(Boolean);
+    },
+    cleanComment: (item) => {
+        if (!item)
+            return null;
+        const snippet = item.snippet || {};
+        const topComment = snippet.topLevelComment?.snippet || {};
+        return {
+            id: item.id,
+            author: topComment.authorDisplayName,
+            authorChannelId: topComment.authorChannelId?.value,
+            text: topComment.textDisplay,
+            likes: topComment.likeCount ? parseInt(topComment.likeCount) : 0,
+            published: topComment.publishedAt,
+            updated: topComment.updatedAt,
+            replyCount: snippet.totalReplyCount || 0,
+            replies: item.replies?.comments?.map((reply) => ({
+                id: reply.id,
+                author: reply.snippet?.authorDisplayName,
+                authorChannelId: reply.snippet?.authorChannelId?.value,
+                text: reply.snippet?.textDisplay,
+                likes: reply.snippet?.likeCount ? parseInt(reply.snippet.likeCount) : 0,
+                published: reply.snippet?.publishedAt,
+            })) || [],
+        };
+    },
+    cleanComments: (result) => {
+        if (!result)
+            return { comments: [], nextPageToken: null };
+        const items = result.items || [];
+        return {
+            comments: items.map(DataCleaners.cleanComment).filter(Boolean),
+            nextPageToken: result.nextPageToken || null,
+            totalResults: result.pageInfo?.totalResults,
+        };
+    },
+};

package/dist/server.js

@@ -1,106 +1,125 @@
 import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
 import { z } from 'zod';
+import { encode } from '@toon-format/toon';
+import * as fs from 'fs';
+import * as path from 'path';
 import { VideoService } from './services/video.js';
 import { TranscriptService } from './services/transcript.js';
 import { PlaylistService } from './services/playlist.js';
 import { ChannelService } from './services/channel.js';
+import { CommentService } from './services/comment.js';
+import { DataCleaners } from './cleaners.js';
+function saveData(data, dir, toolName) {
+    try {
+        if (!fs.existsSync(dir))
+            fs.mkdirSync(dir, { recursive: true });
+        const filename = `${toolName}_${new Date().toISOString().replace(/[:.]/g, '-')}.json`;
+        const filepath = path.join(dir, filename);
+        fs.writeFileSync(filepath, JSON.stringify(data, null, 2));
+        return filepath;
+    }
+    catch (e) {
+        return `Error saving: ${e}`;
+    }
+}
+function formatResponse(cleanedData, options) {
+    const output = { data: cleanedData };
+    let savedPath = '';
+    if (options.saveDir && options.toolName) {
+        savedPath = saveData(output, options.saveDir, options.toolName);
+    }
+    let text = encode(output);
+    if (savedPath)
+        text += `\n\n[Cleaned data saved to: ${savedPath}]`;
+    return { content: [{ type: 'text', text }] };
+}
 export async function startMcpServer() {
     const server = new McpServer({
-        name: 'zubeid-youtube-mcp-server',
-        version: '1.0.0',
+        name: 'youtube-mcp-server',
+        version: '1.3.0',
     });
     const videoService = new VideoService();
     const transcriptService = new TranscriptService();
     const playlistService = new PlaylistService();
     const channelService = new ChannelService();
-    // Register tools using the new McpServer API
-    server.tool('videos_getVideo', 'Get detailed information about a YouTube video', {
+    const commentService = new CommentService();
+    server.tool('videos_getVideo', 'Get video info. Returns cleaned data in TOON format.', {
         videoId: z.string().describe('The YouTube video ID'),
-        parts: z.array(z.string()).optional().describe('Parts of the video to retrieve'),
-    }, async ({ videoId, parts }) => {
+        parts: z.array(z.string()).optional().describe('Parts to retrieve'),
+        save_dir: z.string().optional().describe('Directory to save cleaned JSON'),
+    }, async ({ videoId, parts, save_dir }) => {
         const result = await videoService.getVideo({ videoId, parts });
-        return {
-            content: [{
-                    type: 'text',
-                    text: JSON.stringify(result, null, 2)
-                }]
-        };
+        const cleaned = DataCleaners.cleanVideo(result);
+        return formatResponse(cleaned, { ...(save_dir && { saveDir: save_dir }), toolName: 'videos_getVideo' });
     });
-    server.tool('videos_searchVideos', 'Search for videos on YouTube', {
+    server.tool('videos_searchVideos', 'Search videos. Returns cleaned data in TOON format.', {
         query: z.string().describe('Search query'),
-        maxResults: z.number().optional().describe('Maximum number of results to return'),
-    }, async ({ query, maxResults }) => {
+        maxResults: z.number().optional().describe('Max results (default: 10)'),
+        save_dir: z.string().optional().describe('Directory to save cleaned JSON'),
+    }, async ({ query, maxResults, save_dir }) => {
         const result = await videoService.searchVideos({ query, maxResults });
-        return {
-            content: [{
-                    type: 'text',
-                    text: JSON.stringify(result, null, 2)
-                }]
-        };
+        const cleaned = DataCleaners.cleanSearchResults(result);
+        return formatResponse(cleaned, { ...(save_dir && { saveDir: save_dir }), toolName: 'videos_searchVideos' });
     });
-    server.tool('transcripts_getTranscript', 'Get the transcript of a YouTube video', {
+    server.tool('transcripts_getTranscript', 'Get video transcript. Returns cleaned data in TOON format.', {
         videoId: z.string().describe('The YouTube video ID'),
-        language: z.string().optional().describe('Language code for the transcript'),
-    }, async ({ videoId, language }) => {
+        language: z.string().optional().describe('Language code'),
+        save_dir: z.string().optional().describe('Directory to save cleaned JSON'),
+    }, async ({ videoId, language, save_dir }) => {
         const result = await transcriptService.getTranscript({ videoId, language });
-        return {
-            content: [{
-                    type: 'text',
-                    text: JSON.stringify(result, null, 2)
-                }]
-        };
+        const cleaned = DataCleaners.cleanTranscript(result);
+        return formatResponse(cleaned, { ...(save_dir && { saveDir: save_dir }), toolName: 'transcripts_getTranscript' });
     });
-    server.tool('channels_getChannel', 'Get information about a YouTube channel', {
+    server.tool('channels_getChannel', 'Get channel info. Returns cleaned data in TOON format.', {
         channelId: z.string().describe('The YouTube channel ID'),
-    }, async ({ channelId }) => {
+        save_dir: z.string().optional().describe('Directory to save cleaned JSON'),
+    }, async ({ channelId, save_dir }) => {
         const result = await channelService.getChannel({ channelId });
-        return {
-            content: [{
-                    type: 'text',
-                    text: JSON.stringify(result, null, 2)
-                }]
-        };
+        const cleaned = DataCleaners.cleanChannel(result);
+        return formatResponse(cleaned, { ...(save_dir && { saveDir: save_dir }), toolName: 'channels_getChannel' });
     });
-    server.tool('channels_listVideos', 'Get videos from a specific channel', {
+    server.tool('channels_listVideos', 'List channel videos. Returns cleaned data in TOON format.', {
         channelId: z.string().describe('The YouTube channel ID'),
-        maxResults: z.number().optional().describe('Maximum number of results to return'),
-    }, async ({ channelId, maxResults }) => {
+        maxResults: z.number().optional().describe('Max results'),
+        save_dir: z.string().optional().describe('Directory to save cleaned JSON'),
+    }, async ({ channelId, maxResults, save_dir }) => {
         const result = await channelService.listVideos({ channelId, maxResults });
-        return {
-            content: [{
-                    type: 'text',
-                    text: JSON.stringify(result, null, 2)
-                }]
-        };
+        const cleaned = DataCleaners.cleanSearchResults(result);
+        return formatResponse(cleaned, { ...(save_dir && { saveDir: save_dir }), toolName: 'channels_listVideos' });
     });
-    server.tool('playlists_getPlaylist', 'Get information about a YouTube playlist', {
+    server.tool('playlists_getPlaylist', 'Get playlist info. Returns cleaned data in TOON format.', {
         playlistId: z.string().describe('The YouTube playlist ID'),
-    }, async ({ playlistId }) => {
+        save_dir: z.string().optional().describe('Directory to save cleaned JSON'),
+    }, async ({ playlistId, save_dir }) => {
         const result = await playlistService.getPlaylist({ playlistId });
-        return {
-            content: [{
-                    type: 'text',
-                    text: JSON.stringify(result, null, 2)
-                }]
-        };
+        const cleaned = DataCleaners.cleanPlaylist(result);
+        return formatResponse(cleaned, { ...(save_dir && { saveDir: save_dir }), toolName: 'playlists_getPlaylist' });
     });
-    server.tool('playlists_getPlaylistItems', 'Get videos in a YouTube playlist', {
+    server.tool('playlists_getPlaylistItems', 'Get playlist videos. Returns cleaned data in TOON format.', {
         playlistId: z.string().describe('The YouTube playlist ID'),
-        maxResults: z.number().optional().describe('Maximum number of results to return'),
-    }, async ({ playlistId, maxResults }) => {
+        maxResults: z.number().optional().describe('Max results'),
+        save_dir: z.string().optional().describe('Directory to save cleaned JSON'),
+    }, async ({ playlistId, maxResults, save_dir }) => {
         const result = await playlistService.getPlaylistItems({ playlistId, maxResults });
-        return {
-            content: [{
-                    type: 'text',
-                    text: JSON.stringify(result, null, 2)
-                }]
-        };
+        const cleaned = DataCleaners.cleanPlaylistItems(result);
+        return formatResponse(cleaned, { ...(save_dir && { saveDir: save_dir }), toolName: 'playlists_getPlaylistItems' });
+    });
+    server.tool('comments_getComments', 'Get video comments. Returns cleaned data in TOON format.', {
+        videoId: z.string().describe('The YouTube video ID'),
+        maxResults: z.number().optional().describe('Max results (1-100, default: 100)'),
+        order: z.enum(['time', 'relevance']).optional().describe('Sort order (default: relevance)'),
+        pageToken: z.string().optional().describe('Page token for pagination'),
+        textFormat: z.enum(['html', 'plainText']).optional().describe('Text format (default: plainText)'),
+        save_dir: z.string().optional().describe('Directory to save cleaned JSON'),
+    }, async ({ videoId, maxResults, order, pageToken, textFormat, save_dir }) => {
+        const result = await commentService.getComments({ videoId, maxResults, order, pageToken, textFormat });
+        const cleaned = DataCleaners.cleanComments(result);
+        return formatResponse(cleaned, { ...(save_dir && { saveDir: save_dir }), toolName: 'comments_getComments' });
     });
-    // Create transport and connect
     const transport = new StdioServerTransport();
     await server.connect(transport);
-    console.error(`YouTube MCP Server v1.0.0 started successfully`);
+    console.error(`YouTube MCP Server v1.2.0 started successfully`);
     console.error(`Server will validate YouTube API key when tools are called`);
     return server;
 }

package/dist/services/comment.d.ts

@@ -0,0 +1,17 @@
+import { CommentParams } from '../types.js';
+/**
+ * Service for interacting with YouTube comments
+ */
+export declare class CommentService {
+    private youtube;
+    private initialized;
+    constructor();
+    /**
+     * Initialize the YouTube client only when needed
+     */
+    private initialize;
+    /**
+     * Get comments for a YouTube video
+     */
+    getComments({ videoId, maxResults, order, pageToken, textFormat }: CommentParams): Promise<any>;
+}

package/dist/services/comment.js

@@ -0,0 +1,47 @@
+import { google } from 'googleapis';
+/**
+ * Service for interacting with YouTube comments
+ */
+export class CommentService {
+    youtube;
+    initialized = false;
+    constructor() {
+        // Don't initialize in constructor
+    }
+    /**
+     * Initialize the YouTube client only when needed
+     */
+    initialize() {
+        if (this.initialized)
+            return;
+        const apiKey = process.env.YOUTUBE_API_KEY;
+        if (!apiKey) {
+            throw new Error('YOUTUBE_API_KEY environment variable is not set.');
+        }
+        this.youtube = google.youtube({
+            version: 'v3',
+            auth: apiKey
+        });
+        this.initialized = true;
+    }
+    /**
+     * Get comments for a YouTube video
+     */
+    async getComments({ videoId, maxResults = 100, order = 'relevance', pageToken, textFormat = 'plainText' }) {
+        try {
+            this.initialize();
+            const response = await this.youtube.commentThreads.list({
+                part: ['snippet', 'replies'],
+                videoId,
+                maxResults,
+                order,
+                pageToken,
+                textFormat
+            });
+            return response.data;
+        }
+        catch (error) {
+            throw new Error(`Failed to get comments: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+}

package/dist/types.d.ts

@@ -68,3 +68,13 @@ export interface PlaylistItemsParams {
     playlistId: string;
     maxResults?: number;
 }
+/**
+ * Comment parameters
+ */
+export interface CommentParams {
+    videoId: string;
+    maxResults?: number;
+    order?: 'time' | 'relevance';
+    pageToken?: string;
+    textFormat?: 'html' | 'plainText';
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@yilin-jing/youtube-mcp-server",
-  "version": "1.0.0",
-  "description": "YouTube MCP Server Implementation with SDK 1.23 support",
+  "version": "1.3.0",
+  "description": "YouTube MCP Server with TOON format for 90%+ token savings",
   "type": "module",
   "main": "dist/index.js",
   "bin": {
@@ -21,9 +21,10 @@
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.23.0",
+    "@toon-format/toon": "^2.0.1",
     "googleapis": "^129.0.0",
-    "ytdl-core": "^4.11.5",
     "youtube-transcript": "^1.0.6",
+    "ytdl-core": "^4.11.5",
     "zod": "^3.23.0"
   },
   "devDependencies": {
@@ -39,7 +40,9 @@
     "model-context-protocol",
     "ai",
     "claude",
-    "anthropic"
+    "anthropic",
+    "toon",
+    "token-efficient"
   ],
   "author": "Yilin Jing",
   "license": "MIT",
@@ -51,4 +54,4 @@
     "url": "https://github.com/Jing-yilin/youtube-mcp-server/issues"
   },
   "homepage": "https://github.com/Jing-yilin/youtube-mcp-server#readme"
-}
+}