Skip to main content
Glama

LinkedIn MCP Server

A Model Context Protocol (MCP) server for LinkedIn. Search people, companies, and jobs, scrape profiles, and retrieve structured JSON data from any MCP-compatible AI client.

https://github.com/user-attachments/assets/50cd8629-41ee-4261-9538-40dc7d30294e

Built with FastMCP, Patchright, and a clean hexagonal architecture.


Features

Category

Tools

People

get_person_profile · search_people

Companies

get_company_profile · get_company_posts

Jobs

get_job_details · search_jobs

Browser

close_browser

Person Profile Sections

The get_person_profile tool supports granular section scraping. Request only the sections you need:

  • Main profile (always included) — name, headline, location, followers, connections, about, profile image

  • Experience — title, company, dates, duration, description, company logo

  • Education — school, degree, dates, description, school logo

  • Contact info — email, phone, websites, birthday, LinkedIn URL

  • Interests — people, companies, and groups followed

  • Honors and awards — title, issuer, description

  • Languages — language name and proficiency level

  • Posts — recent activity with reactions and timestamps

  • Recommendations — received and given, with author details

Company Profile Sections

  • About (always included) — overview, website, industry, size, headquarters, specialties, logo

  • Posts — recent feed posts with engagement metrics

  • Jobs — current open positions

Job Search Filters

The search_jobs tool supports the following filters:

Filter

Values

date_posted

past_hour, past_24_hours, past_week, past_month

job_type

full_time, part_time, contract, temporary, internship, other

experience_level

entry, associate, mid_senior, director, executive

work_type

on_site, remote, hybrid

easy_apply

true / false

sort_by

date, relevance


Related MCP server: linkedin-mcp-server

Prerequisites

  • Python 3.12 or later

  • uv package manager

  • A LinkedIn account for authentication


Quick Start

1. Clone and install

git clone https://github.com/eliasbiondo/linkedin-mcp-server.git
cd linkedin-mcp-server
uv sync

2. Install browser

This project uses Patchright (a patched fork of Playwright) for browser automation. You need to install the browser binaries before first use:

uv run patchright install

Windows users: If the command above fails with program not found, run instead:

uv run python -m patchright install

3. Authenticate with LinkedIn

uv run linkedin-mcp-server --login

A browser window will open. Log in to LinkedIn and the session will be persisted locally at ~/.linkedin-mcp-server/browser-data.

4. Run the server

stdio transport (default — for Claude Desktop, Cursor, and similar clients):

uv run linkedin-mcp-server

HTTP transport (for remote clients, the MCP Inspector, etc.):

uv run linkedin-mcp-server --transport streamable-http --host 0.0.0.0 --port 8000

Client Integration

Claude Desktop / Cursor

Add to your MCP configuration file:

{
  "mcpServers": {
    "linkedin": {
      "command": "uv",
      "args": [
        "--directory", "/path/to/linkedin-mcp-server",
        "run", "linkedin-mcp-server"
      ]
    }
  }
}

MCP Inspector

npx @modelcontextprotocol/inspector

Then connect to http://localhost:8000/mcp if using HTTP transport.


Configuration

Configuration follows a strict precedence chain: CLI args > environment variables > .env file > defaults.

CLI Arguments

Argument

Description

Default

--transport

stdio or streamable-http

stdio

--host

Host for HTTP transport

127.0.0.1

--port

Port for HTTP transport

8000

--log-level

DEBUG, INFO, WARNING, ERROR

WARNING

--headless

Run browser in headless mode

true

--no-headless

Show browser window (visible mode)

--login

Open browser for LinkedIn login

--logout

Clear stored credentials

--status

Check session status

Environment Variables

Create a .env file in the project root:

# Server
LINKEDIN_TRANSPORT=stdio
LINKEDIN_HOST=127.0.0.1
LINKEDIN_PORT=8000
LINKEDIN_LOG_LEVEL=WARNING

# Browser
LINKEDIN_HEADLESS=true
LINKEDIN_SLOW_MO=0
LINKEDIN_TIMEOUT=10000
LINKEDIN_VIEWPORT_WIDTH=1280
LINKEDIN_VIEWPORT_HEIGHT=720
LINKEDIN_CHROME_PATH=
LINKEDIN_USER_AGENT=
LINKEDIN_USER_DATA_DIR=~/.linkedin-mcp-server/browser-data

Architecture

The project follows a hexagonal (ports and adapters) architecture with strict layer separation:

src/linkedin_mcp_server/
├── domain/              # Core business logic — zero external dependencies
│   ├── models/          # Data models (Person, Company, Job, Search)
│   ├── parsers/         # HTML to structured data parsers
│   ├── exceptions.py    # Domain exceptions
│   └── value_objects.py # Immutable configuration and content objects
├── ports/               # Abstract interfaces
│   ├── auth.py          # Authentication port
│   ├── browser.py       # Browser automation port
│   └── config.py        # Configuration port
├── application/         # Use cases — orchestration layer
│   ├── scrape_person.py
│   ├── scrape_company.py
│   ├── scrape_job.py
│   ├── search_people.py
│   ├── search_jobs.py
│   └── manage_session.py
├── adapters/            # Concrete implementations
│   ├── driven/          # Infrastructure adapters (browser, auth, config)
│   └── driving/         # Interface adapters (CLI, MCP tools, serialization)
└── container.py         # Dependency injection composition root

Design Decisions

  • Ports and adapters — Domain logic is fully decoupled from infrastructure. The browser engine, MCP framework, and configuration source can all be swapped independently.

  • Dependency injection — A single Container class acts as the composition root and is the only place that imports concrete adapter classes.

  • Structured JSON output — LinkedIn HTML is parsed into typed Python dataclasses, then serialized to JSON for reliable LLM consumption.

  • Session persistence — Browser state is saved to disk, so authentication is required only once.


Development

Setup

uv sync --group dev
uv run pre-commit install

Running tests

uv run pytest

With coverage:

uv run pytest --cov=linkedin_mcp_server

Linting and formatting

This project uses Ruff for both linting and formatting. Pre-commit hooks will run these automatically on each commit.

# Lint
uv run ruff check .

# Lint and auto-fix
uv run ruff check . --fix

# Format
uv run ruff format .

License

This project is licensed under the MIT License. See the LICENSE file for details.


Contributing

Contributions are welcome. Please read the contributing guide for details on the development workflow and submission process.


Disclaimer

This tool is intended for personal and educational use. Scraping LinkedIn may violate their Terms of Service. Use responsibly and at your own risk. The authors are not responsible for any misuse or consequences arising from the use of this software.

Available Tools

7 tools
close_browserA

Close the browser instance and release resources. Credentials are preserved.

ParametersJSON Schema
NameRequiredDescriptionDefault

No parameters

Output Schema

ParametersJSON Schema
NameRequiredDescription

No output parameters

TDQS

A3.6/5.0
Behavior2/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description must disclose behavioral traits. It notes that credentials are preserved, but omits other side effects like session invalidation or resource cleanup scope. This is insufficient for safety-critical browser management.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

Two concise sentences with no redundancy. The first sentence states the primary action, the second adds a key behavioral detail (credential preservation). Every word earns its place.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness4/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given zero parameters and an existing output schema, the description covers the essential purpose and a behavioral note. It does not explain return values, but the output schema covers that. Slightly limited for a cleanup tool, but adequate.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters4/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The tool has no parameters (schema coverage 100% trivially). Description adds no parameter information, but none is needed. Baseline 4 for zero-parameter tools applies.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description explicitly states 'Close the browser instance and release resources,' with a clear verb and resource. It distinguishes from sibling tools like check_session_status and logout_and_cleanup by focusing on the browser instance itself.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines2/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

No guidance on when to use this tool versus alternatives like logout_and_cleanup. The description does not indicate prerequisites, context, or exclusions, leaving the agent to infer usage.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

get_company_postsB

Get recent posts from a company's LinkedIn feed.

Args: company_name: LinkedIn company name (e.g., 'google', 'stripe', 'openai')

ParametersJSON Schema
NameRequiredDescriptionDefault
company_nameYes

Output Schema

ParametersJSON Schema
NameRequiredDescription

No output parameters

TDQS

B3.4/5.0
Behavior2/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so the description bears full responsibility. It fails to disclose behavioral traits such as authentication requirements, result limits, pagination, or rate limits. The description is too minimal for a read operation.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness4/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is concise and front-loaded with the purpose. However, it could include more detail without becoming verbose, given the simplicity of the tool.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness3/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

With an output schema present, the description does not need to explain return values. However, it lacks context about prerequisites (e.g., logged-in session) and usage scope, which are relevant given sibling tools like start_login.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters4/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The description adds meaning beyond the schema by providing example values (e.g., 'google', 'stripe', 'openai') for the company_name parameter, which has 0% schema description coverage. However, it does not explain the exact format or validity rules.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the verb 'get' and the resource 'recent posts from a company's LinkedIn feed'. It provides examples of company names, distinguishing it from sibling tools like get_company_profile or get_job_details.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines2/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

No guidance on when to use this tool vs alternatives, no prerequisites or exclusions. Sibling tools are listed but not compared, leaving the agent to infer usage context.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

get_company_profileA

Get a specific company's LinkedIn profile.

Args: company_name: LinkedIn company name (e.g., 'google', 'stripe', 'openai') sections: Comma-separated list of extra sections to scrape. The about page is always included. Available sections: posts, jobs Default (None) scrapes only the about page.

ParametersJSON Schema
NameRequiredDescriptionDefault
company_nameYes
sectionsNo

Output Schema

ParametersJSON Schema
NameRequiredDescription

No output parameters

TDQS

A3.5/5.0
Behavior2/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so the description must disclose behavioral traits. It mentions that the about page is always included and sections are extra, but does not discuss side effects, authorization needs, rate limits, or data mutability. The behavioral disclosure is minimal.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness4/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is concise and front-loaded with the purpose. The Args section is structured but could be slightly more compact. Overall, it efficiently conveys the key information without unnecessary words.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness3/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the tool has an output schema (not shown but present), the description need not explain return values. However, it lacks usage guidelines and behavioral transparency. For a two-parameter tool, it covers input adequately but leaves gaps in completeness regarding when to use and behavioral context.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters5/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 0%, yet the description adds clear meaning: company_name is illustrated with examples ('google', 'stripe'), and sections are explained with its possible values ('posts, jobs') and default behavior. This adds significant value beyond the raw schema.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the tool's purpose: 'Get a specific company's LinkedIn profile.' It uses a specific verb ('Get') and resource ('company's LinkedIn profile'), which distinguishes it from siblings like get_job_details or get_person_profile.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines2/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description provides parameter details but lacks explicit guidance on when to use this tool versus alternatives like get_company_posts. No context on prerequisites, limitations, or when-not-to-use is given.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

get_job_detailsB

Get job details for a specific job posting on LinkedIn.

Args: job_id: LinkedIn job ID (e.g., '3912045678', '4108763210')

ParametersJSON Schema
NameRequiredDescriptionDefault
job_idYes

Output Schema

ParametersJSON Schema
NameRequiredDescription

No output parameters

TDQS

B3.4/5.0
Behavior2/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Annotations are absent, so description bears full burden. It only states 'get job details' without disclosing behavioral traits like auth needs, rate limits, or whether it's a read-only operation.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness4/5

Is the description appropriately sized, front-loaded, and free of redundancy?

Very concise with the main purpose front-loaded. Only two sentences plus parameter description. No wasted words, though some users may prefer slightly more structure.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness3/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a simple one-parameter tool with an output schema, the description is adequate but lacks detail about what fields are returned in the job details. Context signals show an output schema exists, reducing the need for return value explanation, but completeness is still middling.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters4/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 0%, but the description adds meaningful information for the job_id parameter with examples of valid IDs (e.g., '3912045678'), which adds value beyond the schema's type string.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

Clearly states verb 'get' and resource 'job details for a specific job posting on LinkedIn'. It is specific and distinguishes from sibling tools like search_jobs and apply_for_job.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines2/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

No guidance on when to use this tool versus alternatives (e.g., search_jobs or get_person_profile). No mention of prerequisites or context.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

get_person_profileA

Get a specific person's LinkedIn profile.

Args: linkedin_username: LinkedIn username (e.g., 'satyanadella', 'jeffweiner08') sections: Comma-separated list of extra sections to scrape. The main profile page is always included. Available sections: experience, education, interests, honors, languages, contact_info, posts Default (None) scrapes only the main profile page.

ParametersJSON Schema
NameRequiredDescriptionDefault
linkedin_usernameYes
sectionsNo

Output Schema

ParametersJSON Schema
NameRequiredDescription

No output parameters

TDQS

A4.2/5.0
Behavior3/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so the description carries the full burden. It describes that the main profile is always included and sections are optional, but does not disclose potential behaviors like error handling, rate limits, or data volatility. This is adequate but not comprehensive.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness4/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is clear and front-loaded with the purpose, but the Args section is slightly verbose. Each sentence adds value, but could be slightly more concise without losing information.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness4/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

The description covers parameters well and the tool has an output schema, so return values are not needed. It lacks behavioral or error context, but for a simple data retrieval tool, it is reasonably complete. Minor gaps remain.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters5/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema coverage is 0%, meaning the schema itself provides no descriptions. The description adds significant meaning: examples for linkedin_username, a list of available sections with their behavior, and default behavior. This fully compensates for the schema gap.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description explicitly states the tool retrieves a specific person's LinkedIn profile, using a clear verb+resource structure. It distinguishes itself from siblings like 'search_people' and 'get_company_profile' by focusing on an individual profile.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines4/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description provides parameter usage details (linkedin_username format, sections options) but does not explicitly state when to use or avoid this tool relative to alternatives. It implies use for a specific person, which is clear, but lacks direct guidance.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

search_jobsA

Search for jobs on LinkedIn.

Returns job_ids that can be passed to get_job_details for full info.

Args: keywords: Search keywords (e.g., 'backend developer', 'devops engineer') location: Optional location filter (e.g., 'Austin', 'Singapore') max_pages: Maximum number of result pages to load (1-10, default 3) date_posted: Filter by posting date (past_hour, past_24_hours, past_week, past_month) job_type: Filter by job type, comma-separated (full_time, part_time, contract, temporary, volunteer, internship, other) experience_level: Filter by experience level, comma-separated (internship, entry, associate, mid_senior, director, executive) work_type: Filter by work type, comma-separated (on_site, remote, hybrid) easy_apply: Only show Easy Apply jobs (default false) sort_by: Sort results (date, relevance)

ParametersJSON Schema
NameRequiredDescriptionDefault
keywordsYes
locationNo
max_pagesNo
date_postedNo
job_typeNo
experience_levelNo
work_typeNo
easy_applyNo
sort_byNo

Output Schema

ParametersJSON Schema
NameRequiredDescription

No output parameters

TDQS

A4.2/5.0
Behavior3/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations provided, the description must cover behavioral aspects. It explains that the tool returns job IDs but does not disclose rate limits, authentication needs, or whether it reads existing data without modification. This is a basic but acceptable level.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness4/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is well-structured with a brief summary, return value note, and then a param list. It is slightly lengthy but each line adds value. Could be tightened slightly.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness4/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the high parameter count (9) and many filter options, the description covers purpose, return value, and all parameters thoroughly. It lacks information about pagination or search scope but is otherwise complete for an agent.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters5/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The input schema has 0% description coverage, but the description provides detailed guidance for each parameter, including example values for keywords and enumerated options for filters like job_type, experience_level, etc. This adds significant meaning beyond the raw schema.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the tool's purpose: 'Search for jobs on LinkedIn.' It also mentions that the return value (job_ids) can be passed to get_job_details, which differentiates it from other search tools like search_people.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines4/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description implies when to use this tool (for job searching) and how to follow up with get_job_details. However, it does not explicitly state when not to use it or compare with alternatives like search_people.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

search_peopleB

Search for people on LinkedIn.

Args: keywords: Search keywords (e.g., 'product manager', 'ML engineer at Meta') location: Optional location filter (e.g., 'London', 'Berlin')

ParametersJSON Schema
NameRequiredDescriptionDefault
keywordsYes
locationNo

Output Schema

ParametersJSON Schema
NameRequiredDescription

No output parameters

TDQS

B3.3/5.0
Behavior2/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so the description bears full responsibility for behavioral disclosure. It fails to mention authentication needs, rate limits, or any behavioral traits beyond the search action.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness4/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is very short and front-loaded, with no wasted words. It follows a docstring format, making it easy to parse, though slightly more structure could improve readability.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness3/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the existence of an output schema, the description doesn't need to explain return values. However, it omits details like pagination, sorting, or result limits, leaving gaps for a search tool.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters4/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

With 0% schema description coverage, the description compensates by providing concrete examples for both keywords and location, adding meaningful usage context beyond the bare schema definitions.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose4/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states 'Search for people on LinkedIn' with a specific verb and resource. It provides example keywords, distinguishing it from sibling tools like get_person_profile which targets a specific person.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines3/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description implies usage through examples but does not explicitly state when to use or avoid this tool, nor does it mention alternatives among siblings. Basic context is present but no exclusions.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Tool Schema Changelog

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

  1. 7 tool updatesv0.1.0
    • First observedclose_browser
    • First observedget_company_posts
    • First observedget_company_profile
    • First observedget_job_details
    • First observedget_person_profile
    • First observedsearch_jobs
    • First observedsearch_people

TDQS

A3.9/5.0

Scored across 7 tools

Disambiguation5/5

Each tool has a clearly distinct purpose targeting specific LinkedIn resources: company profiles/posts, person profiles, job details/searches, and browser management. There is no overlap in functionality, with clear boundaries between company, person, and job operations.

Naming Consistency5/5

All tools follow a consistent verb_noun pattern with snake_case (e.g., get_company_profile, search_jobs, close_browser). The naming is predictable and readable throughout the set, using appropriate verbs like 'get', 'search', and 'close'.

Tool Count5/5

With 7 tools, this server is well-scoped for LinkedIn data access, covering key entities (companies, people, jobs) and essential operations (profiles, posts, searches, details). Each tool earns its place without being overwhelming or insufficient.

Completeness4/5

The toolset provides strong coverage for reading LinkedIn data, including profiles, posts, and jobs with search capabilities. Minor gaps exist, such as no tools for creating or interacting with content (e.g., posting updates or sending messages), but core data retrieval workflows are well-supported.

Maintenance

ActivityInactive
ResponsivenessUnresponsive

Related MCP Connectors

Related MCP Servers

  • A
    license
    Not graded
    quality
    F
    maintenance
    Enables LLMs to search for LinkedIn profiles and retrieve detailed profile information via the LinkedIn API, supporting secure OAuth2 authentication.
    82 npm
    52
    MIT
  • A
    license
    Not graded
    quality
    D
    maintenance
    Enables AI assistants to search, filter, and extract job listings from LinkedIn using an automated headless browser with semantic AI filtering and deduplication.
    9 npm
    MIT
  • A
    license
    A
    quality
    D
    maintenance
    Enables searching and scraping of LinkedIn profiles, companies, jobs, and posts using natural language through MCP-compatible AI clients.
    13
    MIT