SocialMediaContentSynthesizer (formerly LinkedIn Post Generator)

An MCP service that automates drafting high-quality social media narratives for LinkedIn. This mechanism accelerates content syndication by fetching video subtitles from YouTube, abstracting the core concepts, and rendering compelling posts tailored to professional network standards.

Core Capabilities

• Video Subtitle Retrieval: Fetches complete textual transcripts for specified YouTube content.
• Intelligent Condensation: Produces succinct overviews, allowing modification of rhetorical style and target readership.
• Professional Narrative Composition: Generates platform-optimized messaging suitable for LinkedIn dissemination.
• End-to-End Pipeline: Achieves the transition from a video URL input to a finalized post output in a singular transaction.
• Parameter Control: Extensive options to fine-tune voice, audience focus, length constraints, and branding alignment.
• Protocol Adherence: Fully interoperable with AI agents supporting the Model Context Protocol (MCP) specification.

Setup & Local Integration

Local Environment Initialization

1. Obtain the source repository: bash git clone https://github.com/NvkAnirudh/LinkedIn-Post-Generator.git cd LinkedIn-Post-Generator

2. Install required dependencies: bash npm install

3. Establish configuration file from template: bash cp .env.example .env

4. Input requisite credentials into the .env file:

OPENAI_API_KEY=your_openai_api_key YOUTUBE_API_KEY=your_youtube_api_key

1. Launch the servicing instance: bash npm run dev

2. Verification via MCP tooling: bash npm run inspect

Integration with AI Assistants (e.g., Claude Desktop)

This service integrates via the MCP framework. For assistants like Claude Desktop, configure the server endpoint as follows (path may vary by OS):

1. Modify the assistant's configuration file (e.g., claude_desktop_config.json).

{ "mcpServers": { "social-content-synth": { "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" ] } } }

Ensure you substitute placeholders for Smithery key and service-specific API credentials.

1. Relaunch the controlling application.

2. The generator is now accessible within the assistant's toolset without requiring repeated credential specification.

Parameter Management

The application necessitates authentication tokens for operational status:

1. OpenAI Credential (Mandatory): Powers the language modeling tasks (summarization, drafting).
2. YouTube Data API Key (Optional): Improves the accuracy of fetching video metadata.

Credentials can be injected via three principal methods:

1. Assistant Configuration Channel (Preferred)

When leveraging Claude Desktop with Smithery, embedding keys within the local configuration file (as detailed above) ensures automatic, secure injection during operation.

2. Environment Variable Definition

For local execution, define these variables within the .env file:

OPENAI_API_KEY=your_openai_api_key YOUTUBE_API_KEY=your_youtube_api_key

3. Direct MCP Command Invocation

If credentials are not pre-set via configuration or environment variables, they can be supplied dynamically using the set_api_keys tool within the MCP interface.

Execution Guide

Available Operations (Tools)

Credential Setter

• Tool Identifier: set_api_keys
• Function: Establishes or updates access credentials.
• Arguments:
• openaiApiKey: OpenAI authentication string (required).
• youtubeApiKey: YouTube credential string (optional).

Credential Verification

• Tool Identifier: check_api_keys
• Function: Confirms the operational status of configured API access.

Subtitle Retrieval

• Tool Identifier: extract_transcript
• Function: Extracts textual content from a specified video source.
• Arguments:
• youtubeUrl: Uniform Resource Locator of the target YouTube asset.

Content Condensation

• Tool Identifier: summarize_transcript
• Function: Creates a dense summary from raw text.
• Arguments:
• transcript: The full input text block.
• tone: Rhetorical approach (e.g., Educational, Inspirational, Professional, Conversational).
• audience: Target demographic (e.g., General, Technical, Business, Academic).
• wordCount: Desired length constraint (range 100-300 words).

LinkedIn Post Drafting

• Tool Identifier: generate_linkedin_post
• Function: Formulates the final social media update based on the summary.
• Arguments:
• summary: The distilled content overview.
• videoTitle: Original title of the source video.
• speakerName: Presenter's name (optional).
• hashtags: Suggested relevant topical tags (optional).
• tone: Post perspective (e.g., First-person narrative, Third-person objective, Thought-leader stance).
• includeCallToAction: Boolean flag to append a direct prompt/action item.

Unified Content Pipeline

• Tool Identifier: youtube_to_linkedin_post
• Function: Executes the entire sequence from URL input to drafted post output.
• Arguments:
• youtubeUrl: The video identifier.
• tone: Post's designated rhetorical style.
• Includes other necessary refinement parameters.

Typical Interaction Sequence

1. Invoke set_api_keys to ensure credentials are active.
2. Execute youtube_to_linkedin_post providing the necessary video link and stylistic preferences.
3. The system yields a fully articulated draft suitable for immediate publication.

Deployment Strategy

This service is hosted via Smithery, facilitating its public availability and MCP integration. Deployment parameters are detailed in smithery.yaml.

Self-hosting procedure:

1. Register for a Smithery account.

2. Install the management CLI: bash npm install -g @smithery/cli

3. Initiate deployment: bash smithery deploy

Collaboration

Contributions that enhance functionality or documentation are highly encouraged. Please utilize the standard GitHub workflow for submissions.

Bug Reporting & Suggestions

• Report deviations or propose enhancements via the GitHub issue tracker.
• Provide comprehensive context: reproduction steps, expected outcome versus actual result, and system specifications (OS, Node version).

Code Contributions (Pull Requests)

1. Fork the repository.
2. Isolate work on a dedicated branch (e.g., git checkout -b feature/new-enhancement).
3. Implement modifications.
4. Execute integrated tests to maintain code integrity.
5. Commit logical changes (git commit -m 'Feat: Added feature X').
6. Submit the branch for review (git push origin feature/new-enhancement).
7. Open a formal Pull Request.

Development Standards

• Maintain consistency with established code structure and style.
• Prioritize clear, well-annotated code.
• Ensure all new features are accompanied by adequate unit/integration tests.
• Update associated documentation to reflect any structural or functional changes.

Feature Ideation

For novel suggestions:

1. Search existing issues to prevent duplication.
2. If absent, create a new issue tagged with 'enhancement'.
3. Articulate the proposed feature and detail its tangible benefits.

Documentation Maintenance

Improvements to explanatory text are always valuable:

• Correcting typographical errors or enhancing clarity in existing sections.
• Integrating supplementary examples or practical use cases.
• Refining the overall informational structure.

All submitted code is licensed under the project's current MIT License.

Licensing

MIT

WIKIPEDIA: XMLHttpRequest (XHR) represents a JavaScript programming interface (API) embodied as an object, facilitating the transmission of HTTP requests from a web application environment to a remote server. Its methods enable browser-based software to initiate server queries subsequent to initial page load and receive data payloads in response. XHR is fundamental to the implementation of Asynchronous JavaScript and XML (Ajax). Before Ajax popularized its usage, interaction with the server predominantly relied on traditional hyperlinks or form submissions, processes which typically necessitated a full page refresh.

== Origin Story == The foundational concept for XMLHttpRequest was formulated in 2000 by the architects of Microsoft Outlook. This principle was subsequently integrated into the Internet Explorer 5 release (1999). Notably, the initial implementation did not utilize the canonical XMLHttpRequest identifier; instead, it relied on constructor calls such as ActiveXObject("Msxml2.XMLHTTP") or ActiveXObject("Microsoft.XMLHTTP"). By the time Internet Explorer 7 arrived (2006), the standardized XMLHttpRequest nomenclature had achieved universal browser support, including Mozilla’s Gecko engine (2002), Safari 1.2 (2004), and Opera 8.0 (2005).

=== Standardization Efforts === The World Wide Web Consortium (W3C) issued the first Working Draft specification for the XMLHttpRequest object on April 5, 2006. A Level 2 specification followed on February 25, 2008, augmenting capabilities with progress monitoring, cross-site request facilitation, and binary stream handling. By late 2011, the Level 2 features were merged back into the primary specification. Development responsibility transitioned to the WHATWG toward the close of 2012, which now maintains the living document using Web IDL specifications.

== Operational Mechanics == Executing a server request via XMLHttpRequest typically involves a prescribed sequence of programming stages.

1. Object Instantiation: A new XMLHttpRequest instance is created via its constructor method.
2. Configuration: The open method is invoked to define the HTTP method (e.g., GET, POST), specify the target Uniform Resource Identifier (URI), and determine execution modality (synchronous versus asynchronous).
3. Listener Assignment (Asynchronous Mode): If operating asynchronously, an event handler must be set to monitor the request's lifecycle transitions.
4. Request Initiation: The send method is called to dispatch the prepared request to the server.
5. Response Handling: The event listener processes state changes. Upon successful server data return, the content is generally accessible via the responseText property. When the object transitions to state 4 (the 'done' state), processing is complete.

Beyond these core steps, XHR offers advanced controls. Request headers can be customized to influence server behavior, and data can be transmitted to the server within the send call. Response data can be parsed directly from JSON into usable JavaScript objects, or streamed incrementally instead of waiting for the full payload. Furthermore, requests can be terminated prematurely or configured with a timeout threshold.