@iflow-mcp/nvkanirudh-linkedin-post-generator 1.0.0

package/.dockerignore

@@ -0,0 +1,6 @@
+node_modules
+    npm-debug.log
+    .env
+    .git
+    .gitignore
+    README.md

package/.env.example

@@ -0,0 +1,5 @@
+# OpenAI API Key
+    OPENAI_API_KEY=your_openai_api_key_here
+
+    # YouTube API Key (optional, used as fallback)
+    YOUTUBE_API_KEY=your_youtube_api_key_here

package/Dockerfile

@@ -0,0 +1,19 @@
+FROM node:18-slim
+
+    WORKDIR /app
+
+    # Copy package files and install dependencies
+    COPY package*.json ./
+    RUN npm install
+
+    # Copy application code
+    COPY . .
+
+    # Set executable permissions for the entry point
+    RUN chmod +x src/index.js
+
+    # Expose the port the app runs on
+    EXPOSE 8000
+
+    # Set the entry point
+    ENTRYPOINT ["node", "src/index.js"]

package/LICENSE

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

package/README.md

@@ -0,0 +1,252 @@
+[![MseeP.ai Security Assessment Badge](https://mseep.net/pr/nvkanirudh-linkedin-post-generator-badge.png)](https://mseep.ai/app/nvkanirudh-linkedin-post-generator)
+
+[![Verified on MseeP](https://mseep.ai/badge.svg)](https://mseep.ai/app/a222762a-577e-431d-a7d3-0b5474d7973e)
+
+# LinkedIn Post Generator
+
+[![smithery badge](https://smithery.ai/badge/@NvkAnirudh/linkedin-post-generator)](https://smithery.ai/server/@NvkAnirudh/linkedin-post-generator)
+
+A Model Context Protocol (MCP) server that automates generating professional LinkedIn post drafts from YouTube videos. This tool streamlines content repurposing by extracting transcripts from YouTube videos, summarizing the content, and generating engaging LinkedIn posts tailored to your preferences.
+
+<a href="https://glama.ai/mcp/servers/@NvkAnirudh/LinkedIn-Post-Generator">
+  <img width="380" height="200" src="https://glama.ai/mcp/servers/@NvkAnirudh/LinkedIn-Post-Generator/badge" />
+</a>
+
+## Table of Contents
+- [Features](#features)
+- [Installation](#installation)
+  - [Local Development](#local-development)
+  - [Using with Claude Desktop](#using-with-claude-desktop)
+- [Configuration](#configuration)
+- [Usage](#usage)
+  - [Available Tools](#available-tools)
+  - [Workflow Example](#workflow-example)
+- [Deployment](#deployment)
+- [License](#license)
+
+## Features
+
+- **YouTube Transcript Extraction**: Automatically extract transcripts from any YouTube video
+- **Content Summarization**: Generate concise summaries with customizable tone and target audience
+- **LinkedIn Post Generation**: Create professional LinkedIn posts with customizable style and tone
+- **All-in-One Workflow**: Go from YouTube URL to LinkedIn post in a single operation
+- **Customization Options**: Adjust tone, audience, word count, and more to match your personal brand
+- **MCP Integration**: Works seamlessly with AI assistants that support the Model Context Protocol
+
+## Installation
+
+### Local Development
+
+1. Clone the repository:
+   ```bash
+   git clone https://github.com/NvkAnirudh/LinkedIn-Post-Generator.git
+   cd LinkedIn-Post-Generator
+   ```
+
+2. Install dependencies:
+   ```bash
+   npm install
+   ```
+
+3. Create a `.env` file based on the example:
+   ```bash
+   cp .env.example .env
+   ```
+
+4. Add your API keys to the `.env` file:
+   ```
+   OPENAI_API_KEY=your_openai_api_key
+   YOUTUBE_API_KEY=your_youtube_api_key
+   ```
+
+5. Run the server:
+   ```bash
+   npm run dev
+   ```
+
+6. Test with MCP Inspector:
+   ```bash
+   npm run inspect
+   ```
+
+### Using with Claude Desktop
+
+This MCP server is designed to work with Claude Desktop and other AI assistants that support the Model Context Protocol. To use it with Claude Desktop:
+
+1. Configure Claude Desktop by editing the configuration file at `~/Library/Application Support/Claude/claude_desktop_config.json` (Mac) or `%APPDATA%\Claude\claude_desktop_config.json` (Windows):
+
+   ```json
+   {
+     "mcpServers": {
+       "linkedin-post-generator": {
+         "command": "npx",
+         "args": [
+           "-y",
+           "@smithery/cli@latest",
+           "run",
+           "@NvkAnirudh/linkedin-post-generator",
+           "--key",
+           "YOUR_SMITHERY_API_KEY",
+           "--config",
+           "{\"OPENAI_API_KEY\":\"YOUR_OPENAI_API_KEY\",\"YOUTUBE_API_KEY\":\"YOUR_YOUTUBE_API_KEY\"}",
+           "--transport",
+           "stdio"
+         ]
+       }
+     }
+   }
+   ```
+
+   Replace:
+   - `YOUR_SMITHERY_API_KEY` with your Smithery API key
+   - `YOUR_OPENAI_API_KEY` with your OpenAI API key
+   - `YOUR_YOUTUBE_API_KEY` with your YouTube API key (optional)
+
+2. Restart Claude Desktop
+
+3. In Claude Desktop, you can now access the LinkedIn Post Generator tools without needing to set API keys again
+
+## Configuration
+
+The application requires API keys to function properly:
+
+1. **OpenAI API Key** (required): Used for content summarization and post generation
+2. **YouTube API Key** (optional): Enhances YouTube metadata retrieval
+
+You can provide these keys in three ways:
+
+### 1. Via Claude Desktop Configuration (Recommended)
+
+When using with Claude Desktop and Smithery, the best approach is to include your API keys in the Claude Desktop configuration file as shown in the [Using with Claude Desktop](#using-with-claude-desktop) section. This way, the keys are automatically passed to the MCP server, and you don't need to set them again.
+
+### 2. As Environment Variables
+
+When running locally, you can set API keys as environment variables in a `.env` file:
+```
+OPENAI_API_KEY=your_openai_api_key
+YOUTUBE_API_KEY=your_youtube_api_key
+```
+
+### 3. Using the Set API Keys Tool
+
+If you haven't provided API keys through the configuration or environment variables, you can set them directly through the MCP interface using the `set_api_keys` tool.
+
+## Usage
+
+### Available Tools
+
+#### Set API Keys
+- Tool: `set_api_keys`
+- Purpose: Configure your API keys
+- Parameters:
+  - `openaiApiKey`: Your OpenAI API key (required)
+  - `youtubeApiKey`: Your YouTube API key (optional)
+
+#### Check API Keys
+- Tool: `check_api_keys`
+- Purpose: Verify your API key configuration status
+
+#### Extract Transcript
+- Tool: `extract_transcript`
+- Purpose: Get the transcript from a YouTube video
+- Parameters:
+  - `youtubeUrl`: URL of the YouTube video
+
+#### Summarize Transcript
+- Tool: `summarize_transcript`
+- Purpose: Create a concise summary of the video content
+- Parameters:
+  - `transcript`: The video transcript text
+  - `tone`: Educational, inspirational, professional, or conversational
+  - `audience`: General, technical, business, or academic
+  - `wordCount`: Approximate word count for the summary (100-300)
+
+#### Generate LinkedIn Post
+- Tool: `generate_linkedin_post`
+- Purpose: Create a LinkedIn post from a summary
+- Parameters:
+  - `summary`: Summary of the video content
+  - `videoTitle`: Title of the YouTube video
+  - `speakerName`: Name of the speaker (optional)
+  - `hashtags`: Relevant hashtags (optional)
+  - `tone`: First-person, third-person, or thought-leader
+  - `includeCallToAction`: Whether to include a call to action
+
+#### All-in-One: YouTube to LinkedIn Post
+- Tool: `youtube_to_linkedin_post`
+- Purpose: Complete workflow from YouTube URL to LinkedIn post
+- Parameters:
+  - `youtubeUrl`: YouTube video URL
+  - `tone`: Desired tone for the post
+  - Plus additional customization options
+
+### Workflow Example
+
+1. Set your API keys using the `set_api_keys` tool
+2. Use the `youtube_to_linkedin_post` tool with a YouTube URL
+3. Receive a complete LinkedIn post draft ready to publish
+
+## Deployment
+
+This server is deployed on [Smithery](https://smithery.ai), a platform for hosting and sharing MCP servers. The deployment configuration is defined in the `smithery.yaml` file.
+
+To deploy your own instance:
+
+1. Create an account on Smithery
+2. Install the Smithery CLI:
+   ```bash
+   npm install -g @smithery/cli
+   ```
+3. Deploy the server:
+   ```bash
+   smithery deploy
+   ```
+
+## Contributing
+
+Contributions are welcome and appreciated! Here's how you can contribute to the LinkedIn Post Generator:
+
+### Reporting Issues
+
+- Use the [GitHub issue tracker](https://github.com/NvkAnirudh/LinkedIn-Post-Generator/issues) to report bugs or suggest features
+- Please provide detailed information about the issue, including steps to reproduce, expected behavior, and actual behavior
+- Include your environment details (OS, Node.js version, etc.) when reporting bugs
+
+### Pull Requests
+
+1. Fork the repository
+2. Create a new branch (`git checkout -b feature/your-feature-name`)
+3. Make your changes
+4. Run tests to ensure your changes don't break existing functionality
+5. Commit your changes (`git commit -m 'Add some feature'`)
+6. Push to the branch (`git push origin feature/your-feature-name`)
+7. Open a Pull Request
+
+### Development Guidelines
+
+- Follow the existing code style and conventions
+- Write clear, commented code
+- Include tests for new features
+- Update documentation to reflect your changes
+
+### Feature Suggestions
+
+If you have ideas for new features or improvements:
+
+1. Check existing issues to see if your suggestion has already been proposed
+2. If not, open a new issue with the label 'enhancement'
+3. Clearly describe the feature and its potential benefits
+
+### Documentation
+
+Improvements to documentation are always welcome:
+
+- Fix typos or clarify existing documentation
+- Add examples or use cases
+- Improve the structure or organization of the documentation
+
+By contributing to this project, you agree that your contributions will be licensed under the project's MIT License.
+
+## License
+
+[MIT](https://github.com/NvkAnirudh/LinkedIn-Post-Generator/blob/main/LICENSE)

package/language.json

@@ -0,0 +1 @@
+nodejs

package/package.json

@@ -0,0 +1 @@
+{"name": "@iflow-mcp/nvkanirudh-linkedin-post-generator", "version": "1.0.0", "type": "module", "bin": {"iflow-mcp-nvkanirudh-linkedin-post-generator": "src/index.js"}, "scripts": {"start": "node src/index.js", "dev": "node --watch src/index.js", "inspect": "npx -y @modelcontextprotocol/inspector node src/index.js"}, "dependencies": {"@modelcontextprotocol/sdk": "^1.0.0", "dotenv": "^16.3.1", "node-fetch": "^3.3.2", "openai": "^4.20.1", "youtube-transcript": "^1.0.6", "zod": "^3.22.4"}}

package/package_name

@@ -0,0 +1 @@
+@iflow-mcp/nvkanirudh-linkedin-post-generator

package/push_info.json

@@ -0,0 +1,5 @@
+{
+  "push_platform": "github",
+  "fork_url": "https://github.com/iflow-mcp/nvkanirudh-linkedin-post-generator",
+  "fork_branch": "iflow"
+}

package/smithery.config.json

@@ -0,0 +1,20 @@
+{
+  "name": "linkedin-post-generator",
+  "description": "Generate LinkedIn post drafts from YouTube videos",
+  "version": "1.0.0",
+  "type": "mcp",
+  "configSchema": {
+    "type": "object",
+    "required": ["OPENAI_API_KEY"],
+    "properties": {
+      "OPENAI_API_KEY": {
+        "type": "string",
+        "description": "Your OpenAI API key (required)"
+      },
+      "YOUTUBE_API_KEY": {
+        "type": "string",
+        "description": "Your YouTube API key (optional)"
+      }
+    }
+  }
+}

package/smithery.json

@@ -0,0 +1,20 @@
+{
+  "name": "linkedin-post-generator",
+  "description": "Generate LinkedIn post drafts from YouTube videos",
+  "version": "1.0.0",
+  "type": "mcp",
+  "configSchema": {
+    "type": "object",
+    "required": ["OPENAI_API_KEY"],
+    "properties": {
+      "OPENAI_API_KEY": {
+        "type": "string",
+        "description": "Your OpenAI API key (required)"
+      },
+      "YOUTUBE_API_KEY": {
+        "type": "string",
+        "description": "Your YouTube API key (optional)"
+      }
+    }
+  }
+}

package/smithery.yaml

@@ -0,0 +1,49 @@
+# Smithery.ai configuration
+name: yt-to-linkedin-mcp
+description: Model Context Protocol server that automates generating LinkedIn post drafts from YouTube videos
+version: 1.0.0
+tags:
+  - youtube
+  - linkedin
+  - content-generation
+  - mcp
+
+startCommand:
+  type: stdio
+  configSchema:
+    type: object
+    properties:
+      OPENAI_API_KEY:
+        type: string
+        description: OpenAI API key for summarization and post generation (optional, can be provided in requests)
+      YOUTUBE_API_KEY:
+        type: string
+        description: YouTube Data API key for fetching video metadata (optional, can be provided in requests)
+      # PORT:
+      #   type: string
+      #   description: Port to run the server on
+      #   default: "8000"
+    required: []
+  commandFunction: |-
+    (config) => ({
+      "command": "node",
+      "args": ["src/index.js"],
+      "env": {
+        "OPENAI_API_KEY": config.OPENAI_API_KEY || "",
+        "YOUTUBE_API_KEY": config.YOUTUBE_API_KEY || "",
+        "PORT": config.PORT || "8000"
+      }
+    })
+
+# Specify the MCP configuration
+mcp:
+  type: "stdio"
+
+resources:
+  cpu: 1
+  memory: 1Gi
+
+ports:
+  - name: http
+    port: 8000
+    protocol: TCP

package/src/index.js

@@ -0,0 +1,61 @@
+#!/usr/bin/env node
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { server } from './server.js';
+import dotenv from 'dotenv';
+import fs from 'fs';
+import path from 'path';
+
+/**
+ * LinkedIn Post Generator MCP Server
+ * 
+ * Configuration Requirements:
+ * - OPENAI_API_KEY: Required for generating content
+ * - YOUTUBE_API_KEY: Optional for enhanced YouTube data fetching
+ */
+
+// Load environment variables (but they're now optional)
+dotenv.config();
+
+// Check for Smithery configuration
+const args = process.argv;
+let smitheryConfig = null;
+
+// Look for --config argument
+for (let i = 0; i < args.length; i++) {
+  if (args[i] === '--config' && i + 1 < args.length) {
+    try {
+      smitheryConfig = JSON.parse(args[i + 1]);
+      console.log('Smithery configuration detected');
+      
+      // Set environment variables from Smithery config
+      if (smitheryConfig.OPENAI_API_KEY) {
+        process.env.OPENAI_API_KEY = smitheryConfig.OPENAI_API_KEY;
+        console.log('OpenAI API key set from Smithery config');
+      }
+      
+      if (smitheryConfig.YOUTUBE_API_KEY) {
+        process.env.YOUTUBE_API_KEY = smitheryConfig.YOUTUBE_API_KEY;
+        console.log('YouTube API key set from Smithery config');
+      }
+      
+      break;
+    } catch (error) {
+      console.error('Error parsing Smithery config:', error.message);
+    }
+  }
+}
+
+console.log('Starting LinkedIn Post Generator MCP server...');
+if (!process.env.OPENAI_API_KEY) {
+  console.log('Note: You will need to set your API keys using the set_api_keys tool before using other functionality.');
+}
+
+// Start receiving messages on stdin and sending messages on stdout
+const transport = new StdioServerTransport();
+await server.connect(transport);
+
+// Keep the process alive
+process.on('SIGINT', () => {
+  console.log('Shutting down server...');
+  process.exit(0);
+});

package/src/modules/api-key-manager.js

@@ -0,0 +1,91 @@
+/**
+     * Manages API keys for the application
+     */
+    export class ApiKeyManager {
+      constructor() {
+        // Initialize API keys from environment variables
+        this.openaiApiKey = process.env.OPENAI_API_KEY || null;
+        this.youtubeApiKey = process.env.YOUTUBE_API_KEY || null;
+        
+        // Log initialization status
+        if (this.openaiApiKey) {
+          console.log('OpenAI API key initialized from environment');
+        }
+        if (this.youtubeApiKey) {
+          console.log('YouTube API key initialized from environment');
+        }
+      }
+      
+      /**
+       * Set the OpenAI API key
+       * @param {string} key - The OpenAI API key
+       */
+      setOpenAIKey(key) {
+        if (!key || typeof key !== 'string' || key.trim() === '') {
+          throw new Error("Invalid OpenAI API key");
+        }
+        this.openaiApiKey = key.trim();
+        console.log("OpenAI API key set successfully");
+      }
+      
+      /**
+       * Set the YouTube API key
+       * @param {string} key - The YouTube API key
+       */
+      setYouTubeKey(key) {
+        if (!key || typeof key !== 'string' || key.trim() === '') {
+          throw new Error("Invalid YouTube API key");
+        }
+        this.youtubeApiKey = key.trim();
+        console.log("YouTube API key set successfully");
+      }
+      
+      /**
+       * Get the OpenAI API key
+       * @returns {string|null} - The OpenAI API key or null if not set
+       */
+      getOpenAIKey() {
+        return this.openaiApiKey;
+      }
+      
+      /**
+       * Get the YouTube API key
+       * @returns {string|null} - The YouTube API key or null if not set
+       */
+      getYouTubeKey() {
+        return this.youtubeApiKey;
+      }
+      
+      /**
+       * Check if OpenAI API key is set
+       * @returns {boolean} - True if the key is set
+       */
+      hasOpenAIKey() {
+        return !!this.openaiApiKey;
+      }
+      
+      /**
+       * Check if YouTube API key is set
+       * @returns {boolean} - True if the key is set
+       */
+      hasYouTubeKey() {
+        return !!this.youtubeApiKey;
+      }
+      
+      /**
+       * Get the status of API keys
+       * @returns {Object} - Status object with key information
+       */
+      getStatus() {
+        return {
+          openai: {
+            set: this.hasOpenAIKey(),
+            key: this.hasOpenAIKey() ? "********" + this.openaiApiKey.slice(-4) : null
+          },
+          youtube: {
+            set: this.hasYouTubeKey(),
+            key: this.hasYouTubeKey() ? "********" + this.youtubeApiKey.slice(-4) : null
+          }
+        };
+      }
+    }

package/src/modules/post-generator.js

@@ -0,0 +1,99 @@
+import { OpenAI } from 'openai';
+
+    /**
+     * Generate a LinkedIn post from a video summary
+     * @param {string} summary - Summary of the video content
+     * @param {string} videoTitle - Title of the YouTube video
+     * @param {string} speakerName - Name of the speaker (optional)
+     * @param {string[]} hashtags - Relevant hashtags (optional)
+     * @param {string} tone - Tone for the post (first-person, third-person, thought-leader)
+     * @param {boolean} includeCallToAction - Whether to include a call to action
+     * @param {string} apiKey - OpenAI API key
+     * @returns {Promise<string>} - The generated LinkedIn post
+     */
+    export async function generateLinkedInPost(
+      summary, 
+      videoTitle, 
+      speakerName = null, 
+      hashtags = [], 
+      tone = "first-person", 
+      includeCallToAction = true,
+      apiKey
+    ) {
+      if (!apiKey) {
+        throw new Error("OpenAI API key not provided");
+      }
+      
+      if (!summary || summary.trim().length === 0) {
+        throw new Error("Empty summary provided");
+      }
+      
+      console.log(`Generating LinkedIn post with tone: ${tone}`);
+      
+      try {
+        // Initialize OpenAI client with provided API key
+        const openai = new OpenAI({
+          apiKey: apiKey,
+        });
+        
+        // Prepare hashtag string
+        const hashtagString = hashtags && hashtags.length > 0 
+          ? hashtags.map(tag => tag.startsWith('#') ? tag : `#${tag}`).join(' ')
+          : '';
+        
+        // Prepare speaker reference
+        const speakerReference = speakerName ? `by ${speakerName}` : '';
+        
+        const response = await openai.chat.completions.create({
+          model: "gpt-3.5-turbo",
+          messages: [
+            {
+              role: "system",
+              content: `You are a professional LinkedIn content creator. 
+              Create a compelling LinkedIn post in a ${tone} tone based on the provided video summary.
+              The post should be between 500-1200 characters (not including hashtags).
+              
+              Structure the post with:
+              1. An attention-grabbing hook
+              2. 2-3 key insights from the video
+              3. A personal reflection or takeaway
+              ${includeCallToAction ? '4. A soft call to action (e.g., asking a question, inviting comments)' : ''}
+              
+              The post should feel authentic, professional, and valuable to LinkedIn readers.
+              Avoid clickbait or overly promotional language.`
+            },
+            {
+              role: "user",
+              content: `Create a LinkedIn post based on this YouTube video:
+              
+              Title: ${videoTitle} ${speakerReference}
+              
+              Summary:
+              ${summary}
+              
+              ${hashtagString ? `Suggested hashtags: ${hashtagString}` : ''}
+              
+              Please format the post ready to copy and paste to LinkedIn.`
+            }
+          ],
+          temperature: 0.7,
+          max_tokens: 700
+        });
+        
+        if (response.choices && response.choices.length > 0) {
+          let post = response.choices[0].message.content.trim();
+          
+          // Ensure hashtags are at the end if they weren't included
+          if (hashtagString && !post.includes(hashtagString)) {
+            post += `\n\n${hashtagString}`;
+          }
+          
+          return post;
+        } else {
+          throw new Error("No post generated");
+        }
+      } catch (error) {
+        console.error("Post generation error:", error);
+        throw new Error(`Failed to generate LinkedIn post: ${error.message}`);
+      }
+    }

package/src/modules/transcript-extractor.js

@@ -0,0 +1,104 @@
+import { YoutubeTranscript } from 'youtube-transcript';
+    import fetch from 'node-fetch';
+
+    /**
+     * Extract transcript from a YouTube video
+     * @param {string} youtubeUrl - The YouTube video URL
+     * @param {string} youtubeApiKey - Optional YouTube API key
+     * @returns {Promise<string>} - The extracted transcript text
+     */
+    export async function extractTranscript(youtubeUrl, youtubeApiKey = null) {
+      try {
+        console.log(`Extracting transcript from: ${youtubeUrl}`);
+        
+        // Extract video ID from URL
+        const videoId = extractVideoId(youtubeUrl);
+        if (!videoId) {
+          throw new Error("Invalid YouTube URL. Could not extract video ID.");
+        }
+        
+        // Try to get transcript using youtube-transcript package
+        try {
+          const transcriptItems = await YoutubeTranscript.fetchTranscript(videoId);
+          if (!transcriptItems || transcriptItems.length === 0) {
+            throw new Error("No transcript available");
+          }
+          
+          // Combine transcript segments into a single text
+          const fullTranscript = transcriptItems
+            .map(item => item.text)
+            .join(' ')
+            .replace(/\s+/g, ' '); // Clean up extra spaces
+          
+          return fullTranscript;
+        } catch (error) {
+          console.error("Error with primary transcript method:", error);
+          
+          // Fallback to YouTube API if available
+          if (youtubeApiKey) {
+            return await fetchTranscriptWithYouTubeAPI(videoId, youtubeApiKey);
+          } else {
+            throw new Error("Failed to extract transcript: " + error.message);
+          }
+        }
+      } catch (error) {
+        console.error("Transcript extraction error:", error);
+        throw new Error(`Failed to extract transcript: ${error.message}`);
+      }
+    }
+
+    /**
+     * Extract video ID from YouTube URL
+     * @param {string} url - YouTube URL
+     * @returns {string|null} - Video ID or null if not found
+     */
+    function extractVideoId(url) {
+      try {
+        const urlObj = new URL(url);
+        
+        // Standard YouTube URL (youtube.com/watch?v=VIDEO_ID)
+        if (urlObj.hostname.includes('youtube.com')) {
+          return urlObj.searchParams.get('v');
+        }
+        
+        // Short YouTube URL (youtu.be/VIDEO_ID)
+        if (urlObj.hostname === 'youtu.be') {
+          return urlObj.pathname.substring(1);
+        }
+        
+        return null;
+      } catch (error) {
+        console.error("Error extracting video ID:", error);
+        return null;
+      }
+    }
+
+    /**
+     * Fallback method to fetch transcript using YouTube API
+     * @param {string} videoId - YouTube video ID
+     * @param {string} apiKey - YouTube API key
+     * @returns {Promise<string>} - Transcript text
+     */
+    async function fetchTranscriptWithYouTubeAPI(videoId, apiKey) {
+      if (!apiKey) {
+        throw new Error("YouTube API key not provided");
+      }
+      
+      // First, get the caption track
+      const captionUrl = `https://www.googleapis.com/youtube/v3/captions?part=snippet&videoId=${videoId}&key=${apiKey}`;
+      
+      const response = await fetch(captionUrl);
+      if (!response.ok) {
+        throw new Error(`YouTube API error: ${response.statusText}`);
+      }
+      
+      const data = await response.json();
+      
+      if (!data.items || data.items.length === 0) {
+        throw new Error("No captions available for this video");
+      }
+      
+      // Note: Actually downloading the caption track requires OAuth2 authentication
+      // which is beyond the scope of this example
+      throw new Error("YouTube API fallback requires OAuth2 authentication");
+    }

package/src/modules/transcript-summarizer.js

@@ -0,0 +1,79 @@
+import { OpenAI } from 'openai';
+
+    /**
+     * Summarize a transcript using OpenAI
+     * @param {string} transcript - The transcript text to summarize
+     * @param {string} tone - Desired tone (educational, inspirational, etc.)
+     * @param {string} audience - Target audience (general, technical, etc.)
+     * @param {number} wordCount - Approximate word count for summary
+     * @param {string} apiKey - OpenAI API key
+     * @returns {Promise<string>} - The summarized text
+     */
+    export async function summarizeTranscript(transcript, tone, audience, wordCount, apiKey) {
+      if (!apiKey) {
+        throw new Error("OpenAI API key not provided");
+      }
+      
+      if (!transcript || transcript.trim().length === 0) {
+        throw new Error("Empty transcript provided");
+      }
+      
+      console.log(`Summarizing transcript (${transcript.length} chars) with tone: ${tone}, audience: ${audience}`);
+      
+      try {
+        // Initialize OpenAI client with provided API key
+        const openai = new OpenAI({
+          apiKey: apiKey,
+        });
+        
+        // Truncate transcript if it's too long (to fit within token limits)
+        const truncatedTranscript = truncateText(transcript, 15000);
+        
+        const response = await openai.chat.completions.create({
+          model: "gpt-3.5-turbo",
+          messages: [
+            {
+              role: "system",
+              content: `You are a professional content summarizer. Summarize the provided transcript in a ${tone} tone for a ${audience} audience. 
+              The summary should be approximately ${wordCount} words and capture the key points, insights, and valuable information from the transcript.
+              Focus on making the summary concise, informative, and engaging.`
+            },
+            {
+              role: "user",
+              content: `Please summarize the following video transcript:\n\n${truncatedTranscript}`
+            }
+          ],
+          temperature: 0.7,
+          max_tokens: 500
+        });
+        
+        if (response.choices && response.choices.length > 0) {
+          return response.choices[0].message.content.trim();
+        } else {
+          throw new Error("No summary generated");
+        }
+      } catch (error) {
+        console.error("Summarization error:", error);
+        throw new Error(`Failed to summarize transcript: ${error.message}`);
+      }
+    }
+
+    /**
+     * Truncate text to a maximum character length
+     * @param {string} text - Text to truncate
+     * @param {number} maxLength - Maximum length in characters
+     * @returns {string} - Truncated text
+     */
+    function truncateText(text, maxLength) {
+      if (text.length <= maxLength) return text;
+      
+      // Try to truncate at a sentence boundary
+      const truncated = text.substring(0, maxLength);
+      const lastPeriod = truncated.lastIndexOf('.');
+      
+      if (lastPeriod > maxLength * 0.8) {
+        return truncated.substring(0, lastPeriod + 1);
+      }
+      
+      return truncated + "...";
+    }

package/src/server.js

@@ -0,0 +1,319 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+    import { z } from 'zod';
+    import { extractTranscript } from './modules/transcript-extractor.js';
+    import { summarizeTranscript } from './modules/transcript-summarizer.js';
+    import { generateLinkedInPost } from './modules/post-generator.js';
+    import { ApiKeyManager } from './modules/api-key-manager.js';
+
+    // Create API key manager
+    const apiKeyManager = new ApiKeyManager();
+
+    // Create an MCP server for LinkedIn post generation
+    const server = new McpServer({
+      name: "LinkedIn Post Generator",
+      version: "1.0.0",
+      description: "Generate LinkedIn post drafts from YouTube videos"
+    });
+
+    // Set API keys tool
+    server.tool(
+      "set_api_keys",
+      { 
+        openaiApiKey: z.string().min(1).describe("Your OpenAI API key"),
+        youtubeApiKey: z.string().optional().describe("Your YouTube API key (optional)")
+      },
+      async ({ openaiApiKey, youtubeApiKey }) => {
+        try {
+          apiKeyManager.setOpenAIKey(openaiApiKey);
+          if (youtubeApiKey) {
+            apiKeyManager.setYouTubeKey(youtubeApiKey);
+          }
+          
+          return {
+            content: [{ 
+              type: "text", 
+              text: JSON.stringify({
+                success: true,
+                message: "API keys set successfully. You can now use the other tools."
+              }, null, 2)
+            }]
+          };
+        } catch (error) {
+          return {
+            content: [{ 
+              type: "text", 
+              text: JSON.stringify({
+                success: false,
+                error: error.message
+              }, null, 2)
+            }],
+            isError: true
+          };
+        }
+      },
+      { description: "Set your API keys for OpenAI and YouTube (optional)" }
+    );
+
+    // Check API keys status
+    server.tool(
+      "check_api_keys",
+      {},
+      async () => {
+        const status = apiKeyManager.getStatus();
+        return {
+          content: [{ 
+            type: "text", 
+            text: JSON.stringify(status, null, 2)
+          }]
+        };
+      },
+      { description: "Check the status of your API keys" }
+    );
+
+    // Extract transcript tool
+    server.tool(
+      "extract_transcript",
+      { 
+        youtubeUrl: z.string().url().describe("YouTube video URL")
+      },
+      async ({ youtubeUrl }) => {
+        try {
+          // Check if YouTube API key is set (if needed)
+          if (!apiKeyManager.hasYouTubeKey()) {
+            console.log("No YouTube API key set, will try without it");
+          }
+          
+          const transcript = await extractTranscript(youtubeUrl, apiKeyManager.getYouTubeKey());
+          return {
+            content: [{ 
+              type: "text", 
+              text: JSON.stringify({
+                success: true,
+                transcript
+              }, null, 2)
+            }]
+          };
+        } catch (error) {
+          return {
+            content: [{ 
+              type: "text", 
+              text: JSON.stringify({
+                success: false,
+                error: error.message
+              }, null, 2)
+            }],
+            isError: true
+          };
+        }
+      },
+      { description: "Extract transcript from a YouTube video" }
+    );
+
+    // Summarize transcript tool
+    server.tool(
+      "summarize_transcript",
+      { 
+        transcript: z.string().describe("Video transcript text"),
+        tone: z.enum(["educational", "inspirational", "professional", "conversational"])
+          .default("professional")
+          .describe("Tone of the summary"),
+        audience: z.enum(["general", "technical", "business", "academic"])
+          .default("general")
+          .describe("Target audience for the summary"),
+        wordCount: z.number().min(100).max(300).default(200)
+          .describe("Approximate word count for the summary")
+      },
+      async ({ transcript, tone, audience, wordCount }) => {
+        try {
+          // Check if OpenAI API key is set
+          if (!apiKeyManager.hasOpenAIKey()) {
+            throw new Error("OpenAI API key not set. Please use the set_api_keys tool first.");
+          }
+          
+          const summary = await summarizeTranscript(
+            transcript, 
+            tone, 
+            audience, 
+            wordCount, 
+            apiKeyManager.getOpenAIKey()
+          );
+          
+          return {
+            content: [{ 
+              type: "text", 
+              text: JSON.stringify({
+                success: true,
+                summary
+              }, null, 2)
+            }]
+          };
+        } catch (error) {
+          return {
+            content: [{ 
+              type: "text", 
+              text: JSON.stringify({
+                success: false,
+                error: error.message
+              }, null, 2)
+            }],
+            isError: true
+          };
+        }
+      },
+      { description: "Summarize a video transcript" }
+    );
+
+    // Generate LinkedIn post tool
+    server.tool(
+      "generate_linkedin_post",
+      { 
+        summary: z.string().describe("Summary of the video content"),
+        videoTitle: z.string().describe("Title of the YouTube video"),
+        speakerName: z.string().optional().describe("Name of the speaker in the video (optional)"),
+        hashtags: z.array(z.string()).optional().describe("Relevant hashtags (optional)"),
+        tone: z.enum(["first-person", "third-person", "thought-leader"])
+          .default("first-person")
+          .describe("Tone of the LinkedIn post"),
+        includeCallToAction: z.boolean().default(true)
+          .describe("Whether to include a call to action")
+      },
+      async ({ summary, videoTitle, speakerName, hashtags, tone, includeCallToAction }) => {
+        try {
+          // Check if OpenAI API key is set
+          if (!apiKeyManager.hasOpenAIKey()) {
+            throw new Error("OpenAI API key not set. Please use the set_api_keys tool first.");
+          }
+          
+          const post = await generateLinkedInPost(
+            summary, 
+            videoTitle, 
+            speakerName, 
+            hashtags, 
+            tone, 
+            includeCallToAction,
+            apiKeyManager.getOpenAIKey()
+          );
+          
+          return {
+            content: [{ 
+              type: "text", 
+              text: JSON.stringify({
+                success: true,
+                post
+              }, null, 2)
+            }]
+          };
+        } catch (error) {
+          return {
+            content: [{ 
+              type: "text", 
+              text: JSON.stringify({
+                success: false,
+                error: error.message
+              }, null, 2)
+            }],
+            isError: true
+          };
+        }
+      },
+      { description: "Generate a LinkedIn post draft from a video summary" }
+    );
+
+    // All-in-one tool: YouTube URL to LinkedIn post
+    server.tool(
+      "youtube_to_linkedin_post",
+      { 
+        youtubeUrl: z.string().url().describe("YouTube video URL"),
+        tone: z.enum(["first-person", "third-person", "thought-leader"])
+          .default("first-person")
+          .describe("Tone of the LinkedIn post"),
+        summaryTone: z.enum(["educational", "inspirational", "professional", "conversational"])
+          .default("professional")
+          .describe("Tone of the summary"),
+        audience: z.enum(["general", "technical", "business", "academic"])
+          .default("general")
+          .describe("Target audience"),
+        hashtags: z.array(z.string()).optional().describe("Relevant hashtags (optional)"),
+        includeCallToAction: z.boolean().default(true)
+          .describe("Whether to include a call to action")
+      },
+      async ({ youtubeUrl, tone, summaryTone, audience, hashtags, includeCallToAction }) => {
+        try {
+          // Check if API keys are set
+          if (!apiKeyManager.hasOpenAIKey()) {
+            throw new Error("OpenAI API key not set. Please use the set_api_keys tool first.");
+          }
+          
+          // Step 1: Extract transcript
+          const transcript = await extractTranscript(youtubeUrl, apiKeyManager.getYouTubeKey());
+          
+          // Step 2: Get video metadata (title, etc.)
+          const videoTitle = await getVideoTitle(youtubeUrl);
+          
+          // Step 3: Summarize transcript
+          const summary = await summarizeTranscript(
+            transcript, 
+            summaryTone, 
+            audience, 
+            200, 
+            apiKeyManager.getOpenAIKey()
+          );
+          
+          // Step 4: Generate LinkedIn post
+          const post = await generateLinkedInPost(
+            summary, 
+            videoTitle, 
+            undefined, // speaker name not available without additional API calls
+            hashtags, 
+            tone, 
+            includeCallToAction,
+            apiKeyManager.getOpenAIKey()
+          );
+          
+          return {
+            content: [{ 
+              type: "text", 
+              text: JSON.stringify({
+                success: true,
+                videoTitle,
+                transcript: transcript.substring(0, 300) + "...", // Preview only
+                summary,
+                post
+              }, null, 2)
+            }]
+          };
+        } catch (error) {
+          return {
+            content: [{ 
+              type: "text", 
+              text: JSON.stringify({
+                success: false,
+                error: error.message
+              }, null, 2)
+            }],
+            isError: true
+          };
+        }
+      },
+      { description: "Generate a LinkedIn post draft directly from a YouTube video URL" }
+    );
+
+    // Helper function to extract video title from URL
+    async function getVideoTitle(youtubeUrl) {
+      try {
+        // Extract video ID from URL
+        const videoId = new URL(youtubeUrl).searchParams.get('v');
+        if (!videoId) {
+          throw new Error("Could not extract video ID from URL");
+        }
+        
+        // For now, return a placeholder. In a production environment,
+        // you would use the YouTube API to get the actual title
+        return `YouTube Video (${videoId})`;
+      } catch (error) {
+        console.error("Error getting video title:", error);
+        return "YouTube Video";
+      }
+    }
+
+    export { server };