@yilin-jing/youtube-mcp-server 1.0.0

package/README.md

@@ -0,0 +1,225 @@
+# 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.
+
+## Features
+
+### Video Information
+* Get video details (title, description, duration, etc.)
+* List channel videos
+* Get video statistics (views, likes, comments)
+* Search videos across YouTube
+
+### Transcript Management
+* Retrieve video transcripts
+* Support for multiple languages
+* Get timestamped captions
+* Search within transcripts
+
+### Channel Management
+* Get channel details
+* List channel playlists
+* Get channel statistics
+* Search within channel content
+
+### Playlist Management
+* List playlist items
+* Get playlist details
+* Search within playlists
+* Get playlist video transcripts
+
+## Installation
+
+### Quick Setup for Claude Desktop
+
+1. Install the package:
+```bash
+npm install -g zubeid-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):
+
+```json
+{
+  "mcpServers": {
+    "zubeid-youtube-mcp-server": {
+      "command": "zubeid-youtube-mcp-server",
+      "env": {
+        "YOUTUBE_API_KEY": "your_youtube_api_key_here"
+      }
+    }
+  }
+}
+```
+
+### Alternative: Using NPX (No Installation Required)
+
+Add this to your Claude Desktop configuration:
+
+```json
+{
+  "mcpServers": {
+    "youtube": {
+      "command": "npx",
+      "args": ["-y", "zubeid-youtube-mcp-server"],
+      "env": {
+        "YOUTUBE_API_KEY": "your_youtube_api_key_here"
+      }
+    }
+  }
+}
+```
+
+### 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
+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
+
+## 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"
+});
+
+// Search videos
+const searchResults = await youtube.videos.searchVideos({
+  query: "search term",
+  maxResults: 10
+});
+```
+
+### Managing Channels
+
+```javascript
+// Get channel details
+const channel = await youtube.channels.getChannel({
+  channelId: "channel-id"
+});
+
+// List channel videos
+const videos = await youtube.channels.listVideos({
+  channelId: "channel-id",
+  maxResults: 50
+});
+```
+
+### Managing Playlists
+
+```javascript
+// Get playlist items
+const playlistItems = await youtube.playlists.getPlaylistItems({
+  playlistId: "playlist-id",
+  maxResults: 50
+});
+
+// Get playlist details
+const playlist = await youtube.playlists.getPlaylist({
+  playlistId: "playlist-id"
+});
+```
+
+## Development
+
+```bash
+# Install dependencies
+npm install
+
+# Run tests
+npm test
+
+# Build
+npm run build
+
+# Lint
+npm run lint
+```
+
+## Contributing
+See CONTRIBUTING.md for information about contributing to this repository.
+
+## License
+This project is licensed under the MIT License - see the LICENSE file for details.

package/dist/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/cli.js

@@ -0,0 +1,17 @@
+#!/usr/bin/env node
+import { startMcpServer } from './server.js';
+// Check for required environment variables
+if (!process.env.YOUTUBE_API_KEY) {
+    console.error('Error: YOUTUBE_API_KEY environment variable is required.');
+    console.error('Please set it before running this server.');
+    process.exit(1);
+}
+// Start the MCP server
+startMcpServer()
+    .then(() => {
+    console.log('YouTube MCP Server started successfully');
+})
+    .catch(error => {
+    console.error('Failed to start YouTube MCP Server:', error);
+    process.exit(1);
+});

package/dist/index.d.ts

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

package/dist/index.js

@@ -0,0 +1,16 @@
+import { startMcpServer } from './server.js';
+// Check for required environment variables
+if (!process.env.YOUTUBE_API_KEY) {
+    console.error('Error: YOUTUBE_API_KEY environment variable is required.');
+    console.error('Please set it before running this server.');
+    process.exit(1);
+}
+// Start the MCP server
+startMcpServer()
+    .then(() => {
+    console.log('YouTube MCP Server started successfully');
+})
+    .catch(error => {
+    console.error('Failed to start YouTube MCP Server:', error);
+    process.exit(1);
+});

package/dist/server.d.ts

@@ -0,0 +1,2 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+export declare function startMcpServer(): Promise<McpServer>;

package/dist/server.js

@@ -0,0 +1,106 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { z } from 'zod';
+import { VideoService } from './services/video.js';
+import { TranscriptService } from './services/transcript.js';
+import { PlaylistService } from './services/playlist.js';
+import { ChannelService } from './services/channel.js';
+export async function startMcpServer() {
+    const server = new McpServer({
+        name: 'zubeid-youtube-mcp-server',
+        version: '1.0.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', {
+        videoId: z.string().describe('The YouTube video ID'),
+        parts: z.array(z.string()).optional().describe('Parts of the video to retrieve'),
+    }, async ({ videoId, parts }) => {
+        const result = await videoService.getVideo({ videoId, parts });
+        return {
+            content: [{
+                    type: 'text',
+                    text: JSON.stringify(result, null, 2)
+                }]
+        };
+    });
+    server.tool('videos_searchVideos', 'Search for videos on YouTube', {
+        query: z.string().describe('Search query'),
+        maxResults: z.number().optional().describe('Maximum number of results to return'),
+    }, async ({ query, maxResults }) => {
+        const result = await videoService.searchVideos({ query, maxResults });
+        return {
+            content: [{
+                    type: 'text',
+                    text: JSON.stringify(result, null, 2)
+                }]
+        };
+    });
+    server.tool('transcripts_getTranscript', 'Get the transcript of a YouTube video', {
+        videoId: z.string().describe('The YouTube video ID'),
+        language: z.string().optional().describe('Language code for the transcript'),
+    }, async ({ videoId, language }) => {
+        const result = await transcriptService.getTranscript({ videoId, language });
+        return {
+            content: [{
+                    type: 'text',
+                    text: JSON.stringify(result, null, 2)
+                }]
+        };
+    });
+    server.tool('channels_getChannel', 'Get information about a YouTube channel', {
+        channelId: z.string().describe('The YouTube channel ID'),
+    }, async ({ channelId }) => {
+        const result = await channelService.getChannel({ channelId });
+        return {
+            content: [{
+                    type: 'text',
+                    text: JSON.stringify(result, null, 2)
+                }]
+        };
+    });
+    server.tool('channels_listVideos', 'Get videos from a specific channel', {
+        channelId: z.string().describe('The YouTube channel ID'),
+        maxResults: z.number().optional().describe('Maximum number of results to return'),
+    }, async ({ channelId, maxResults }) => {
+        const result = await channelService.listVideos({ channelId, maxResults });
+        return {
+            content: [{
+                    type: 'text',
+                    text: JSON.stringify(result, null, 2)
+                }]
+        };
+    });
+    server.tool('playlists_getPlaylist', 'Get information about a YouTube playlist', {
+        playlistId: z.string().describe('The YouTube playlist ID'),
+    }, async ({ playlistId }) => {
+        const result = await playlistService.getPlaylist({ playlistId });
+        return {
+            content: [{
+                    type: 'text',
+                    text: JSON.stringify(result, null, 2)
+                }]
+        };
+    });
+    server.tool('playlists_getPlaylistItems', 'Get videos in a YouTube playlist', {
+        playlistId: z.string().describe('The YouTube playlist ID'),
+        maxResults: z.number().optional().describe('Maximum number of results to return'),
+    }, async ({ playlistId, maxResults }) => {
+        const result = await playlistService.getPlaylistItems({ playlistId, maxResults });
+        return {
+            content: [{
+                    type: 'text',
+                    text: JSON.stringify(result, null, 2)
+                }]
+        };
+    });
+    // Create transport and connect
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    console.error(`YouTube MCP Server v1.0.0 started successfully`);
+    console.error(`Server will validate YouTube API key when tools are called`);
+    return server;
+}

package/dist/services/channel.d.ts

@@ -0,0 +1,29 @@
+import { ChannelParams, ChannelVideosParams } from '../types.js';
+/**
+ * Service for interacting with YouTube channels
+ */
+export declare class ChannelService {
+    private youtube;
+    private initialized;
+    constructor();
+    /**
+     * Initialize the YouTube client only when needed
+     */
+    private initialize;
+    /**
+     * Get channel details
+     */
+    getChannel({ channelId }: ChannelParams): Promise<any>;
+    /**
+     * Get channel playlists
+     */
+    getPlaylists({ channelId, maxResults }: ChannelVideosParams): Promise<any[]>;
+    /**
+     * Get channel videos
+     */
+    listVideos({ channelId, maxResults }: ChannelVideosParams): Promise<any[]>;
+    /**
+     * Get channel statistics
+     */
+    getStatistics({ channelId }: ChannelParams): Promise<any>;
+}

package/dist/services/channel.js

@@ -0,0 +1,95 @@
+import { google } from 'googleapis';
+/**
+ * Service for interacting with YouTube channels
+ */
+export class ChannelService {
+    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 channel details
+     */
+    async getChannel({ channelId }) {
+        try {
+            this.initialize();
+            const response = await this.youtube.channels.list({
+                part: ['snippet', 'statistics', 'contentDetails'],
+                id: [channelId]
+            });
+            return response.data.items?.[0] || null;
+        }
+        catch (error) {
+            throw new Error(`Failed to get channel: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    /**
+     * Get channel playlists
+     */
+    async getPlaylists({ channelId, maxResults = 50 }) {
+        try {
+            this.initialize();
+            const response = await this.youtube.playlists.list({
+                part: ['snippet', 'contentDetails'],
+                channelId,
+                maxResults
+            });
+            return response.data.items || [];
+        }
+        catch (error) {
+            throw new Error(`Failed to get channel playlists: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    /**
+     * Get channel videos
+     */
+    async listVideos({ channelId, maxResults = 50 }) {
+        try {
+            this.initialize();
+            const response = await this.youtube.search.list({
+                part: ['snippet'],
+                channelId,
+                maxResults,
+                order: 'date',
+                type: ['video']
+            });
+            return response.data.items || [];
+        }
+        catch (error) {
+            throw new Error(`Failed to list channel videos: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    /**
+     * Get channel statistics
+     */
+    async getStatistics({ channelId }) {
+        try {
+            this.initialize();
+            const response = await this.youtube.channels.list({
+                part: ['statistics'],
+                id: [channelId]
+            });
+            return response.data.items?.[0]?.statistics || null;
+        }
+        catch (error) {
+            throw new Error(`Failed to get channel statistics: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+}

package/dist/services/playlist.d.ts

@@ -0,0 +1,25 @@
+import { PlaylistParams, PlaylistItemsParams, SearchParams } from '../types.js';
+/**
+ * Service for interacting with YouTube playlists
+ */
+export declare class PlaylistService {
+    private youtube;
+    private initialized;
+    constructor();
+    /**
+     * Initialize the YouTube client only when needed
+     */
+    private initialize;
+    /**
+     * Get information about a YouTube playlist
+     */
+    getPlaylist({ playlistId }: PlaylistParams): Promise<any>;
+    /**
+     * Get videos in a YouTube playlist
+     */
+    getPlaylistItems({ playlistId, maxResults }: PlaylistItemsParams): Promise<any[]>;
+    /**
+     * Search for playlists on YouTube
+     */
+    searchPlaylists({ query, maxResults }: SearchParams): Promise<any[]>;
+}

package/dist/services/playlist.js

@@ -0,0 +1,78 @@
+import { google } from 'googleapis';
+/**
+ * Service for interacting with YouTube playlists
+ */
+export class PlaylistService {
+    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 information about a YouTube playlist
+     */
+    async getPlaylist({ playlistId }) {
+        try {
+            this.initialize();
+            const response = await this.youtube.playlists.list({
+                part: ['snippet', 'contentDetails'],
+                id: [playlistId]
+            });
+            return response.data.items?.[0] || null;
+        }
+        catch (error) {
+            throw new Error(`Failed to get playlist: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    /**
+     * Get videos in a YouTube playlist
+     */
+    async getPlaylistItems({ playlistId, maxResults = 50 }) {
+        try {
+            this.initialize();
+            const response = await this.youtube.playlistItems.list({
+                part: ['snippet', 'contentDetails'],
+                playlistId,
+                maxResults
+            });
+            return response.data.items || [];
+        }
+        catch (error) {
+            throw new Error(`Failed to get playlist items: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    /**
+     * Search for playlists on YouTube
+     */
+    async searchPlaylists({ query, maxResults = 10 }) {
+        try {
+            this.initialize();
+            const response = await this.youtube.search.list({
+                part: ['snippet'],
+                q: query,
+                maxResults,
+                type: ['playlist']
+            });
+            return response.data.items || [];
+        }
+        catch (error) {
+            throw new Error(`Failed to search playlists: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+}

package/dist/services/transcript.d.ts

@@ -0,0 +1,21 @@
+import { TranscriptParams, SearchTranscriptParams } from '../types.js';
+/**
+ * Service for interacting with YouTube video transcripts
+ */
+export declare class TranscriptService {
+    private initialized;
+    constructor();
+    private initialize;
+    /**
+     * Get the transcript of a YouTube video
+     */
+    getTranscript({ videoId, language }: TranscriptParams): Promise<any>;
+    /**
+     * Search within a transcript
+     */
+    searchTranscript({ videoId, query, language }: SearchTranscriptParams): Promise<any>;
+    /**
+     * Get transcript with timestamps
+     */
+    getTimestampedTranscript({ videoId, language }: TranscriptParams): Promise<any>;
+}

package/dist/services/transcript.js

@@ -0,0 +1,85 @@
+import { YoutubeTranscript } from "youtube-transcript";
+/**
+ * Service for interacting with YouTube video transcripts
+ */
+export class TranscriptService {
+    // No YouTube API key needed for transcripts, but we'll implement the same pattern
+    initialized = false;
+    constructor() {
+        // No initialization needed
+    }
+    initialize() {
+        if (this.initialized)
+            return;
+        // No API key needed for transcripts, but we'll check if language is set
+        this.initialized = true;
+    }
+    /**
+     * Get the transcript of a YouTube video
+     */
+    async getTranscript({ videoId, language = process.env.YOUTUBE_TRANSCRIPT_LANG || 'en' }) {
+        try {
+            this.initialize();
+            // YoutubeTranscript.fetchTranscript only accepts videoId
+            const transcript = await YoutubeTranscript.fetchTranscript(videoId);
+            return {
+                videoId,
+                language,
+                transcript
+            };
+        }
+        catch (error) {
+            throw new Error(`Failed to get transcript: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    /**
+     * Search within a transcript
+     */
+    async searchTranscript({ videoId, query, language = process.env.YOUTUBE_TRANSCRIPT_LANG || 'en' }) {
+        try {
+            this.initialize();
+            const transcript = await YoutubeTranscript.fetchTranscript(videoId);
+            // Search through transcript for the query
+            const matches = transcript.filter(item => item.text.toLowerCase().includes(query.toLowerCase()));
+            return {
+                videoId,
+                query,
+                matches,
+                totalMatches: matches.length
+            };
+        }
+        catch (error) {
+            throw new Error(`Failed to search transcript: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    /**
+     * Get transcript with timestamps
+     */
+    async getTimestampedTranscript({ videoId, language = process.env.YOUTUBE_TRANSCRIPT_LANG || 'en' }) {
+        try {
+            this.initialize();
+            const transcript = await YoutubeTranscript.fetchTranscript(videoId);
+            // Format timestamps in human-readable format
+            const timestampedTranscript = transcript.map(item => {
+                const seconds = item.offset / 1000;
+                const minutes = Math.floor(seconds / 60);
+                const remainingSeconds = Math.floor(seconds % 60);
+                const formattedTime = `${minutes}:${remainingSeconds.toString().padStart(2, '0')}`;
+                return {
+                    timestamp: formattedTime,
+                    text: item.text,
+                    startTimeMs: item.offset,
+                    durationMs: item.duration
+                };
+            });
+            return {
+                videoId,
+                language,
+                timestampedTranscript
+            };
+        }
+        catch (error) {
+            throw new Error(`Failed to get timestamped transcript: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+}

package/dist/services/video.d.ts

@@ -0,0 +1,35 @@
+import { VideoParams, SearchParams, TrendingParams, RelatedVideosParams } from '../types.js';
+/**
+ * Service for interacting with YouTube videos
+ */
+export declare class VideoService {
+    private youtube;
+    private initialized;
+    constructor();
+    /**
+     * Initialize the YouTube client only when needed
+     */
+    private initialize;
+    /**
+     * Get detailed information about a YouTube video
+     */
+    getVideo({ videoId, parts }: VideoParams): Promise<any>;
+    /**
+     * Search for videos on YouTube
+     */
+    searchVideos({ query, maxResults }: SearchParams): Promise<any[]>;
+    /**
+     * Get video statistics like views, likes, and comments
+     */
+    getVideoStats({ videoId }: {
+        videoId: string;
+    }): Promise<any>;
+    /**
+     * Get trending videos
+     */
+    getTrendingVideos({ regionCode, maxResults, videoCategoryId }: TrendingParams): Promise<any[]>;
+    /**
+     * Get related videos for a specific video
+     */
+    getRelatedVideos({ videoId, maxResults }: RelatedVideosParams): Promise<any[]>;
+}

package/dist/services/video.js

@@ -0,0 +1,117 @@
+import { google } from 'googleapis';
+/**
+ * Service for interacting with YouTube videos
+ */
+export class VideoService {
+    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 detailed information about a YouTube video
+     */
+    async getVideo({ videoId, parts = ['snippet', 'contentDetails', 'statistics'] }) {
+        try {
+            this.initialize();
+            const response = await this.youtube.videos.list({
+                part: parts,
+                id: [videoId]
+            });
+            return response.data.items?.[0] || null;
+        }
+        catch (error) {
+            throw new Error(`Failed to get video: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    /**
+     * Search for videos on YouTube
+     */
+    async searchVideos({ query, maxResults = 10 }) {
+        try {
+            this.initialize();
+            const response = await this.youtube.search.list({
+                part: ['snippet'],
+                q: query,
+                maxResults,
+                type: ['video']
+            });
+            return response.data.items || [];
+        }
+        catch (error) {
+            throw new Error(`Failed to search videos: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    /**
+     * Get video statistics like views, likes, and comments
+     */
+    async getVideoStats({ videoId }) {
+        try {
+            this.initialize();
+            const response = await this.youtube.videos.list({
+                part: ['statistics'],
+                id: [videoId]
+            });
+            return response.data.items?.[0]?.statistics || null;
+        }
+        catch (error) {
+            throw new Error(`Failed to get video stats: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    /**
+     * Get trending videos
+     */
+    async getTrendingVideos({ regionCode = 'US', maxResults = 10, videoCategoryId = '' }) {
+        try {
+            this.initialize();
+            const params = {
+                part: ['snippet', 'contentDetails', 'statistics'],
+                chart: 'mostPopular',
+                regionCode,
+                maxResults
+            };
+            if (videoCategoryId) {
+                params.videoCategoryId = videoCategoryId;
+            }
+            const response = await this.youtube.videos.list(params);
+            return response.data.items || [];
+        }
+        catch (error) {
+            throw new Error(`Failed to get trending videos: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    /**
+     * Get related videos for a specific video
+     */
+    async getRelatedVideos({ videoId, maxResults = 10 }) {
+        try {
+            this.initialize();
+            const response = await this.youtube.search.list({
+                part: ['snippet'],
+                relatedToVideoId: videoId,
+                maxResults,
+                type: ['video']
+            });
+            return response.data.items || [];
+        }
+        catch (error) {
+            throw new Error(`Failed to get related videos: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+}

package/dist/types.d.ts

@@ -0,0 +1,70 @@
+/**
+ * Video details parameters
+ */
+export interface VideoParams {
+    videoId: string;
+    parts?: string[];
+}
+/**
+ * Search videos parameters
+ */
+export interface SearchParams {
+    query: string;
+    maxResults?: number;
+}
+/**
+ * Trending videos parameters
+ */
+export interface TrendingParams {
+    regionCode?: string;
+    maxResults?: number;
+    videoCategoryId?: string;
+}
+/**
+ * Related videos parameters
+ */
+export interface RelatedVideosParams {
+    videoId: string;
+    maxResults?: number;
+}
+/**
+ * Transcript parameters
+ */
+export interface TranscriptParams {
+    videoId: string;
+    language?: string;
+}
+/**
+ * Search transcript parameters
+ */
+export interface SearchTranscriptParams {
+    videoId: string;
+    query: string;
+    language?: string;
+}
+/**
+ * Channel parameters
+ */
+export interface ChannelParams {
+    channelId: string;
+}
+/**
+ * Channel videos parameters
+ */
+export interface ChannelVideosParams {
+    channelId: string;
+    maxResults?: number;
+}
+/**
+ * Playlist parameters
+ */
+export interface PlaylistParams {
+    playlistId: string;
+}
+/**
+ * Playlist items parameters
+ */
+export interface PlaylistItemsParams {
+    playlistId: string;
+    maxResults?: number;
+}

package/dist/types.js

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

package/package.json

@@ -0,0 +1,54 @@
+{
+  "name": "@yilin-jing/youtube-mcp-server",
+  "version": "1.0.0",
+  "description": "YouTube MCP Server Implementation with SDK 1.23 support",
+  "type": "module",
+  "main": "dist/index.js",
+  "bin": {
+    "youtube-mcp-server": "dist/cli.js"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "start": "node ./dist/index.js",
+    "build": "tsc",
+    "dev": "nodemon --exec \"npm run build && npm start\" --ext ts",
+    "test": "bun test",
+    "prepublishOnly": "npm run build"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.23.0",
+    "googleapis": "^129.0.0",
+    "ytdl-core": "^4.11.5",
+    "youtube-transcript": "^1.0.6",
+    "zod": "^3.23.0"
+  },
+  "devDependencies": {
+    "@types/node": "^18.0.0",
+    "bun-types": "^1.3.3",
+    "nodemon": "^3.0.0",
+    "ts-node": "^10.9.1",
+    "typescript": "^5.0.0"
+  },
+  "keywords": [
+    "youtube",
+    "mcp",
+    "model-context-protocol",
+    "ai",
+    "claude",
+    "anthropic"
+  ],
+  "author": "Yilin Jing",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Jing-yilin/youtube-mcp-server.git"
+  },
+  "bugs": {
+    "url": "https://github.com/Jing-yilin/youtube-mcp-server/issues"
+  },
+  "homepage": "https://github.com/Jing-yilin/youtube-mcp-server#readme"
+}