Skip to main content
Glama
LinkedIn MCP Pro Max

LinkedIn MCP Pro Max

by mdnaimul22

Quick Start

1. Prerequisites

Ensure you have uv installed:

curl -LsSf https://astral.sh/uv/install.sh | sh

2. Installation & Setup

chmod +x scripts/setup.sh
./scripts/setup.sh

The script handles dependency syncing, .env bootstrapping, and stealth browser provisioning.

Method B: Manual Setup

uv sync
uv run python -m patchright install chromium
cp .env.example .env

Edit .env with your LinkedIn credentials:

LINKEDIN_EMAIL="your-email@example.com"
LINKEDIN_PASSWORD="your-secure-password"
LINKEDIN_USERNAME="your-profile-slug"

4. First-Run Authentication

uv run linkedin-mcp-pro-max --login

5. Connect to Claude Desktop (or any MCP client)

Add to your claude_desktop_config.json:

{
    "mcpServers": {
        "linkedin-mcp-pro-max": {
            "command": "/home/naimul/.local/bin/uv",
            "args": [
                "--directory",
                "/home/naimul/linkedin-mcp-pro-max",
                "run",
                "linkedin-mcp-pro-max"
            ]
        }
    }
}

Related MCP server: linkedin-mcp-pro

The MCP Toolkit (14 Unified Tools)

Category

Tool

Actions

Description

Profile

profile

get, analyze, update, update_cover_image

Manage deep profile data, AI analysis, and identity updates

experience

add, update, delete

Manage professional experience entries

education

add, update, delete

Manage education entries

skills

add, delete

Manage skills on your profile

company

-

Get detailed corporate metadata and insights

Jobs & Intel

job

search, details, recommended, apply

Discover, analyze, and apply for job postings

application

list, track, update

Manage internal job application tracking

Content

create_linkedin_post

-

Publish AI-generated posts autonomously

interact_with_post

read, like, comment

Engage with feed posts via URL

Documents

generate_resume

-

Generate a professional resume from your profile

tailor_resume

-

Target your resume to match a specific Job ID

generate_cover_letter

-

Create a personalized contextual cover letter

list_templates

-

View all available document templates

System

server

restart

Manage the MCP server lifecycle


Architecture

Built on Clean Architecture with a one-way dependency rule and a Unified Component Registry that eliminates all manual wiring.

[tools/]  →  [services/]  →  [browser/actors/ + browser/scrapers/]
              ctx.my_svc        manager.my_actor / manager.my_scraper

Directory Structure

src/
├── app.py                  # Composition root — auto-wires from registry
├── helpers/
│   └── registry.py         # Unified discovery engine (ServiceMeta, ActorMeta, ScraperMeta)
├── tools/                  # MCP tool definitions (@mcp.tool) — auto-discovered
├── services/               # Business logic layer — auto-wired via SERVICE markers
├── browser/
│   ├── actors/             # Write operations (UI interaction) — auto-registered
│   ├── scrapers/           # Read operations (data extraction) — auto-registered
│   ├── manager.py          # Orchestrator — auto-instantiates actors/scrapers
│   └── helpers/            # Low-level browser utilities (driver, sniffer, dom)
├── api/                    # LinkedIn internal API client
├── db/                     # Database repositories
├── schema/                 # Pydantic domain models
├── config/                 # Settings and environment
└── providers/              # AI provider wrappers (OpenAI, Claude)

The Zero-Config Flow

At startup, helpers/registry.py scans services/, browser/actors/, and browser/scrapers/ automatically:

discover_all()
├── services/*.py     → SERVICE = ServiceMeta(...)   → injected into AppContext
├── browser/actors/*  → ACTOR   = ActorMeta(...)     → instantiated in BrowserManager
└── browser/scrapers/ → SCRAPER = ScraperMeta(...)   → instantiated in BrowserManager

No manual registration. No editing app.py or manager.py.


Adding New Features

For the complete development pipeline, debugging guide, and working examples, see the Tool Development Guide.

A full feature (scraper + service + tool) requires exactly 3 new files. No existing file is modified.

1. Browser Scraper — src/browser/scrapers/my_feature.py

from helpers.registry import ScraperMeta

class MyFeatureScraper:
    def __init__(self, page): ...
    async def scrape(self): ...

SCRAPER = ScraperMeta(attr="my_feature_scraper", cls=MyFeatureScraper)

2. Service — src/services/my_feature.py

from helpers.registry import ServiceMeta

class MyFeatureService:
    def __init__(self, browser=None): ...
    async def do_work(self): ...

SERVICE = ServiceMeta(attr="my_feature", cls=MyFeatureService, deps=["browser"], lazy=True)

3. Tool — src/tools/my_feature.py

from app import mcp, get_ctx

@mcp.tool()
async def my_feature_tool(param: str) -> str:
    """Description the AI reads to decide when to use this tool."""
    ctx = await get_ctx()
    await ctx.initialize_browser()
    result = await ctx.my_feature.do_work()
    return json.dumps(result)

app.py, manager.py, services/__init__.py, tools/__init__.py — never touched.


uv run linkedin-mcp-pro-max             # Start MCP server
uv run linkedin-mcp-pro-max --login     # Autonomous headless login
uv run linkedin-mcp-pro-max --status    # Check authentication status
uv run linkedin-mcp-pro-max --logout    # Clear session and cookies

Documentation

Document

Description

Tool Development Guide

Full pipeline: creating tools, services, actors, scrapers. Debugging guide.

Services README

Service layer conventions and dependency rules

Actors README

Actor conventions and browser interaction patterns

Schema README

Pydantic model conventions


Available Tools

14 tools
applicationA

Manage tracked job applications locally.

Args: action: 'list', 'track', or 'update', job_id: LinkedIn job ID, job_title: Job title, company: Company name, status: Application status (interested/applied/interviewing/offered/rejected/withdrawn). For 'list', filters results. notes: Optional notes, url: Optional job URL,

allowed_args_for_action = { "list": ["status"], "track": ["job_id", "job_title", "company", "status", "notes", "url"], "update": ["job_id", "status", "notes"] }

Inputs: action (required), url, notes, job_id, +3 more. Returns: result

companyB

Get company information from LinkedIn.

Args: company_id: LinkedIn company ID or URL slug,

Inputs: company_id (required). Returns: result

create_linkedin_postA

Generate and publish a new LinkedIn post using an internal AI writer.

The AI will craft a complete, publish-ready post based on the topic you provide. Optionally, a second AI pass generates a detailed visual prompt which is sent to the image generation engine to create and attach a professional image to the post.

Full pipeline (when include_image=True): 1. LLM writes the post text (topic + tone + optional CTA). 2. LLM writes a rich, detailed image generation prompt. 3. Image generator (Flux / Gemini) creates the image. 4. Browser uploads image + posts text together on LinkedIn.

Args: topic: What the post should be about (e.g., 'why clean code matters', 'lessons from 6 months of remote work'). tone: Writing style — 'professional' (default), 'storytelling', or 'thought-leader'. include_cta: If True (default), end with a question or call-to-action. include_image: If True, generate and attach an AI image to the post. Requires IMAGE_GEN_API_BASE to be configured. If image generation fails, the post is published text-only.

Returns: JSON string with: - status: 'success' or 'error' - generated_post: The complete text that was published. - character_count: Length of the published post. - topic: Echo of the original topic for traceability. - image_prompt: (if include_image) The prompt used for image gen. - image_url: (if include_image) Local path of the generated image. - image_warning: (if include_image failed) Reason why image was skipped. - message: Human-readable confirmation.

Inputs: topic (required), tone, include_cta, include_image. Returns: result

educationB

Manage education entries on your LinkedIn profile.

Args: action: 'add', 'update', or 'delete', school: School/University name, degree: Degree (e.g. 'Bachelor of Science'), field_of_study: Field of study (optional), grade: Grade/GPA (optional), start_year: Start year string (e.g. '2018'), end_year: End year string (e.g. '2022'), description: Description of your studies (optional), education_id: The ID of the education entry (required for 'update'),

Inputs: action (required), degree (required), school (required), grade, +5 more. Returns: result

experienceA

Manage experience entries on your LinkedIn profile.

Args: action: 'add', 'update', or 'delete', title: Job title (e.g. 'Software Engineer'), company: Company name, position_id: The ID of the position (required for 'update'), employment_type: Type (e.g. 'Full-time', 'Contract'), location: City/Country, description: Role description, start_month: Month name (e.g. 'January'), start_year: Year string (e.g. '2023'), end_month: End Month name (e.g. 'December'), end_year: End Year string (e.g. '2024'), is_current: Whether this is your current role,

allowed_args_for_action = { "add": ["title", "company", "employment_type", "location", "description", "start_month", "start_year", "end_month", "end_year", "is_current"], "update": ["position_id", "title", "company", "employment_type", "location", "description", "start_month", "start_year", "end_month", "end_year", "is_current"], "delete": ["title", "company"] }

Inputs: title (required), action (required), company (required), end_year, +8 more. Returns: result

generate_cover_letterA

Generate a personalized cover letter for a specific job posting.

Args: profile_id: LinkedIn profile ID or 'me' for self job_id: LinkedIn job ID template: Template name (professional, concise) output_format: Output format (html, md, pdf)

Inputs: job_id (required), profile_id (required), template, output_format. Returns: result

generate_resumeA

Generate a professional resume from a LinkedIn profile using AI enhancement.

Args: profile_id: LinkedIn profile ID or 'me' for self template: Template name (modern, professional) output_format: Output format (html, md, pdf)

Inputs: profile_id (required), template, output_format. Returns: result

interact_with_postA

Interact with a specific LinkedIn post (read, like, comment).

Args: post_url: The URL of the LinkedIn post to interact with. action: Strategy to apply: 'read', 'like', or 'comment'. Default is 'read'. comment: The text to post if action is 'comment'.

Inputs: post_url (required), action, comment. Returns: result

jobA

Discover and manage LinkedIn job postings.

Args: action: 'search', 'details', 'recommended', or 'apply', job_id: LinkedIn job ID (required for 'details' and 'apply'), keywords: Search keywords (job title, skills, company), location: Geographic location (city, state, country), job_type: Filter by type: FULL_TIME, PART_TIME, CONTRACT, TEMPORARY, INTERNSHIP, experience_level: Filter: INTERNSHIP, ENTRY_LEVEL, ASSOCIATE, MID_SENIOR, DIRECTOR, EXECUTIVE, remote: Filter for remote jobs only, date_posted: Filter by recency: past-24h, past-week, past-month, page: Page number for pagination (default 1), count: Results per page (1-50, default 20),

allowed_args_for_action = { "search": ["keywords", "location", "job_type", "experience_level", "remote", "date_posted", "page", "count"], "details": ["job_id"], "recommended": ["count"], "apply": ["job_id"] }

Inputs: action (required), page, count, job_id, +6 more. Returns: result

list_templatesA

List all available templates for resumes and cover letters.

Args: template_type: Template type to list: 'resume', 'cover_letter', or 'all'

Inputs: template_type. Returns: result

profileB

Manage LinkedIn profiles.

Args: action: The profile action to perform ('get', 'analyze', 'update', 'update_cover_image'). profile_id: LinkedIn profile ID (username slug) or 'me' for self (for 'get' and 'analyze'). headline: New profile headline (for 'update'). summary: New profile 'About' summary (for 'update'). image_path: Absolute path to the image file (for 'update_cover_image').

allowed_args_for_action = { "get": ["profile_id"], "analyze": ["profile_id"], "update": ["headline", "summary"], "update_cover_image": ["image_path"] }

Inputs: action (required), summary, headline, image_path, +1 more. Returns: result

serverC

Manage the MCP server.

Args: action: The server action to perform ('restart'), reason: Optional reason for the restart,

allowed_args_for_action = { "restart": ["reason"] }

Inputs: action (required), reason. Returns: result

skillsA

Manage skills on your LinkedIn profile.

Args: action: 'add' or 'delete', skill_name: Name of the skill (e.g. 'Python', 'Machine Learning'),

Inputs: action (required), skill_name (required). Returns: result

tailor_resumeA

Generate a resume tailored to a specific job posting.

Args: profile_id: LinkedIn profile ID or 'me' for self job_id: LinkedIn job ID to tailor the resume for template: Template name (modern, professional) output_format: Output format (html, md, pdf)

Inputs: job_id (required), profile_id (required), template, output_format. Returns: result

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections.

Loading tool schema changelog…

    TDQS

    A3.5/5.0

    Scored across 14 tools

    Disambiguation4/5

    Most tools have clearly distinct purposes (e.g., interact_with_post vs create_linkedin_post, job vs application). Some minor overlap exists between generate_resume and tailor_resume, but descriptions clarify the distinction. Profile and its sub-section tools (experience, skills, education) are logically separated but could be slightly ambiguous.

    Naming Consistency2/5

    Naming conventions are mixed: some tools are verb_noun (create_linkedin_post, generate_resume, list_templates), while others are bare nouns (job, profile, company, experience, skills, education, server, application). This inconsistency makes the tool set feel less predictable, even though the noun tools share a pattern of action-based arguments.

    Tool Count5/5

    With 14 tools, the server covers a broad but well-scoped set of LinkedIn features (posts, jobs, profiles, resumes, applications). The count is within the ideal 3-15 range and each tool addresses a meaningful function without redundancy.

    Completeness4/5

    The server covers core LinkedIn workflows: profile management (experience, skills, education), job search/apply, post creation/interaction, and resume/cover letter generation. Minor gaps exist, such as no post deletion or edit, and no direct messages/connections, but these are not critical for the apparent job-seeker focus.

    Maintenance

    ActivityInactive
    ResponsivenessNo recent community issues

    Related MCP Connectors

    Related MCP Servers

    • A
      license
      A
      quality
      D
      maintenance
      Fully featured MCP server that provides automation tools for LinkedIn, supporting browser-based scraping and API-based operations for content management, media uploads, and reactions.
      6
      4
      MIT
    • A
      license
      A
      quality
      C
      maintenance
      Self-hosted, ban-safe MCP server for LinkedIn that provides 22 tools for profiles, search, jobs, posts, connections, and messages. Integrates with any MCP-compatible client like Claude Desktop.
      58
      1
      MIT
    • A
      license
      Not graded
      quality
      D
      maintenance
      MCP server for programmable LinkedIn automation via Playwright, offering 20 tools for profile management, messaging, feed interaction, and job searching through real browser automation.
      18 npm
      MIT