LinkedIn Custom MCP Server

Server Quality Checklist

Profile completionA complete profile improves this server's visibility in search results.

Latest release: v1.0.0
Disambiguation5/5
Every tool has a clearly distinct purpose targeting specific LinkedIn resources and actions. For example, linkedin_create_post, linkedin_create_image_post, and linkedin_create_comment handle different content types, while search tools (companies, jobs, people) and get tools (profile, post details) are well-separated. No tools appear to overlap in functionality.
Naming Consistency5/5
All tools follow a consistent 'linkedin_verb_noun' pattern with snake_case throughout. The verbs are appropriate and predictable (e.g., create, delete, get, search, update), and nouns clearly indicate the resource (e.g., post, comment, profile). There are no deviations in naming conventions.
Tool Count4/5
With 17 tools, the count is slightly high but reasonable for a comprehensive LinkedIn API server covering posts, comments, profiles, companies, jobs, and OAuth. It includes core CRUD operations and search functionalities, though it might benefit from slight consolidation in some areas like OAuth-related tools.
Completeness4/5
The tool set provides strong coverage for LinkedIn's social and professional features, including create, read, update, delete for posts and comments, profile fetching, and searches. Minor gaps include lack of tools for liking/reacting to content or managing connections, but agents can perform core workflows effectively without dead ends.
Average 3.6/5 across 17 of 17 tools scored. Lowest: 2.9/5.
See the Tool Scores section below for per-tool breakdowns.
- No community issues in the last 6 months
- 0 commits in the last 12 weeks
- No stable releases found
- No critical vulnerability alerts
- No high-severity vulnerability alerts
- No code scanning findings
- CI status not available
This repository is licensed under MIT License.
This repository includes a README.md file.
No tool usage detected in the last 30 days. Usage tracking helps demonstrate server value.
Tip: use the "Try in Browser" feature on the server page to seed initial usage.
Add a glama.json file to provide metadata about your server.
If you are the author, simply .
If the server belongs to an organization, first add glama.json to the root of your repository:
```
{
  "$schema": "https://glama.ai/mcp/schemas/server.json",
  "maintainers": [
    "your-github-username"
  ]
}
```
Then . Browse examples.
Add related servers to improve discoverability.

How to sync the server with GitHub?

Servers are automatically synced at least once per day, but you can also sync manually at any time to instantly update the server profile.

To manually sync the server, click the "Sync Server" button in the MCP server admin interface.

How is the quality score calculated?

The overall quality score combines two components: Tool Definition Quality (70%) and Server Coherence (30%).

Tool Definition Quality measures how well each tool describes itself to AI agents. Every tool is scored 1–5 across six dimensions: Purpose Clarity (25%), Usage Guidelines (20%), Behavioral Transparency (20%), Parameter Semantics (15%), Conciseness & Structure (10%), and Contextual Completeness (10%). The server-level definition quality score is calculated as 60% mean TDQS + 40% minimum TDQS, so a single poorly described tool pulls the score down.

Server Coherence evaluates how well the tools work together as a set, scoring four dimensions equally: Disambiguation (can agents tell tools apart?), Naming Consistency, Tool Count Appropriateness, and Completeness (are there gaps in the tool surface?).

Tiers are derived from the overall score: A (≥3.5), B (≥3.0), C (≥2.0), D (≥1.0), F (<1.0). B and above is considered passing.

Tool Scores

Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations only provide a title, so the description carries full burden. It states 'Delete' which implies a destructive mutation, but doesn't disclose behavioral traits like irreversibility, permission requirements, rate limits, or what happens on success/failure. The output schema exists but isn't referenced.
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 front-loaded with the core purpose, followed by parameter details in a structured 'Args:' section. It's appropriately sized with no redundant sentences, though the parameter explanations could be more informative.
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 a destructive tool with 2 parameters, 0% schema coverage, and an output schema (which reduces need to describe returns), the description is minimally adequate. It covers purpose and parameters but lacks behavioral context and usage guidelines, leaving gaps for safe invocation.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, so the description must compensate. It lists both parameters with brief explanations ('URN of the comment to delete', 'URN of the parent post/object'), adding meaning beyond the bare schema. However, it doesn't clarify URN format, examples, or relationships between parameters.
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 the verb ('Delete') and resource ('a specific comment'), making the purpose unambiguous. It distinguishes from siblings like 'linkedin_delete_post' by specifying the comment resource, though it doesn't explicitly contrast them in the description text.
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 no guidance on when to use this tool versus alternatives like 'linkedin_delete_post' or 'linkedin_update_post'. It lacks context about prerequisites (e.g., ownership/permissions), error conditions, or typical scenarios for deletion.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations only provide a title, so the description carries full burden for behavioral disclosure. It mentions searching by keywords but doesn't explain what the search returns (e.g., profiles, contact info), any limitations (e.g., rate limits, authentication needs), or how results are structured. This leaves significant gaps for a search tool.
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?
The description is a single, direct sentence with no wasted words, making it highly concise and front-loaded. It efficiently communicates the core function without unnecessary elaboration, earning full marks for brevity and clarity.
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's low complexity (one parameter) and the presence of an output schema, the description is minimally adequate. However, it lacks details on behavioral aspects like search scope or limitations, and with no annotations to fill gaps, it doesn't fully prepare an agent for effective use, scoring at the baseline for viability.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters2/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
With 0% schema description coverage and one parameter ('keywords'), the description adds minimal value beyond the schema. It specifies that searching is 'by keywords,' which gives a hint about the parameter's purpose, but doesn't detail format, examples, or constraints, failing to compensate for the low schema coverage.
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 the action ('Search for people') and resource ('on LinkedIn'), making the purpose immediately understandable. However, it doesn't differentiate this tool from its sibling 'linkedin_search_companies' or 'linkedin_search_jobs' beyond the resource type, which keeps it from a perfect score.
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 no guidance on when to use this tool versus alternatives like 'linkedin_get_member_profile' for specific profiles or 'linkedin_search_companies' for company searches. It lacks context about use cases, prerequisites, or exclusions, offering only a basic functional statement.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations only provide a title, so the description carries full burden. It states 'Create a comment' implying a write/mutation operation, but lacks behavioral details such as permissions required, rate limits, whether comments are editable/deletable, or what happens on success/failure. This is inadequate for a mutation tool with no annotation coverage.
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 front-loaded with the core purpose in the first sentence, followed by a clear 'Args:' section listing parameters. It's efficient with minimal waste, though the structure could be slightly improved by integrating parameter details more seamlessly.
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 (which handles return values), 2 parameters with description coverage, and no complex annotations, the description is moderately complete. However, as a mutation tool, it lacks crucial behavioral context (e.g., side effects, error handling), making it incomplete for safe agent use.
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 compensates by explaining both parameters: 'object_urn' as 'The URN of the content to comment on' with an example, and 'text' as 'The text of the comment.' This adds meaningful semantics beyond the bare schema, though it could elaborate on URN formats or text constraints.
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 the action ('Create a comment') and specifies the target resources ('on a LinkedIn share, article, or video'), which distinguishes it from sibling tools like linkedin_create_post or linkedin_delete_comment. However, it doesn't explicitly differentiate from all siblings (e.g., it could mention it's for commenting vs. posting original content).
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 no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., authentication), exclusions, or compare it to related tools like linkedin_get_post_comments or linkedin_update_post, 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.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations are minimal (only a title), so the description carries the burden of behavioral disclosure. It implies a read-only operation by using 'Get', but does not specify aspects like authentication needs, rate limits, pagination, or error handling. No contradiction with annotations exists, but it adds limited context beyond the basic action.
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?
The description is a single, direct sentence with no wasted words, making it highly concise and front-loaded. Every part contributes to understanding the tool's basic function efficiently.
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's moderate complexity (a read operation with one parameter) and the presence of an output schema (which handles return values), the description is minimally adequate. However, with no annotations and low parameter coverage, it should provide more context on usage and parameters to be fully complete.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters2/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, so the description must compensate for undocumented parameters. It mentions 'for a specific post/share', which hints at the 'object_urn' parameter's purpose, but does not explain the format, syntax, or how to obtain it. This adds some meaning but is insufficient for full clarity.
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 the action ('Get') and target resource ('comments for a specific post/share'), making the purpose understandable. However, it does not explicitly differentiate from sibling tools like 'linkedin_get_recent_posts' or 'linkedin_search_companies', which might also involve retrieving content, so it lacks sibling distinction for a perfect score.
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 no guidance on when to use this tool versus alternatives. It does not mention prerequisites, such as needing a valid post identifier, or compare it to siblings like 'linkedin_get_recent_posts' for broader queries, leaving usage context implied at best.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations only provide a title, so the description carries full burden. It mentions searching but doesn't disclose behavioral traits like pagination, result limits, authentication requirements, rate limits, or what the output contains. For a search tool with no annotation coverage, this leaves significant gaps in understanding its operation.
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?
The description is a single, efficient sentence that front-loads the core purpose. Every word earns its place, with no redundant information or unnecessary elaboration, making it easy to parse quickly.
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's moderate complexity (search with two parameters), no annotations, and an output schema present, the description is minimally adequate. It covers the basic purpose but lacks context on usage, behavior, and parameter details, relying on the output schema for return values without explaining them.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, so the description must compensate. It adds meaning by explaining that 'keywords' are used for searching and 'location' is optional, which clarifies beyond the bare schema. However, it doesn't detail format (e.g., city names, coordinates) or constraints, leaving parameters partially documented.
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 the action ('Search for jobs') and resource ('on LinkedIn'), with specific filtering criteria ('by keywords and optional location'). It distinguishes from siblings like linkedin_search_companies or linkedin_search_people by focusing on jobs, but doesn't explicitly differentiate from other job-related tools like linkedin_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?
The description provides no guidance on when to use this tool versus alternatives. It doesn't mention when to choose this over linkedin_get_job_details (for specific job details) or linkedin_search_companies/people (for other search types), nor does it specify prerequisites like authentication or rate limits.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations only provide a title, so the description carries full burden. It states this is a creation tool, implying mutation, but doesn't disclose behavioral traits like authentication needs, rate limits, or what happens on success/failure. The description adds minimal context beyond the basic action.
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?
The description is front-loaded with the core purpose ('Create a post with an image'), followed by a concise parameter list. Every sentence earns its place, with no wasted words, making it easy to scan and understand quickly.
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's complexity (mutation with 3 parameters), annotations are minimal (only title), and an output schema exists (so return values needn't be explained), the description is moderately complete. It covers the action and parameters but lacks behavioral context like error handling or side effects, leaving gaps for a mutation 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?
Schema description coverage is 0%, so the description must compensate. It adds meaning by explaining each parameter: 'text' as the post caption, 'image_source' as a local file path or public URL, and 'visibility' with allowed values ('PUBLIC' or 'CONNECTIONS'). This clarifies semantics beyond the bare schema, though it doesn't cover all details like format constraints.
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 the verb ('Create') and resource ('post with an image'), distinguishing it from sibling tools like 'linkedin_create_post' (likely text-only) and 'linkedin_update_post'. However, it doesn't explicitly mention LinkedIn as the platform, though this is implied by the tool name and sibling context.
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 is provided on when to use this tool versus alternatives like 'linkedin_create_post' (presumably for text-only posts) or 'linkedin_update_post'. The description lacks context about prerequisites, such as authentication or image requirements, and doesn't mention when not to use it.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations only provide a title, so the description carries the burden of behavioral disclosure. It indicates this is a mutation operation (exchanging codes for tokens) and implies persistence, but doesn't detail authentication needs, rate limits, error handling, or what 'persistent' entails. With no annotations to contradict, it adds some context but lacks depth for a critical auth tool.
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?
The description is a single, efficient sentence that directly states the tool's function without unnecessary words. It is front-loaded with the core action and resources, making it highly concise and well-structured for quick comprehension.
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's complexity as an OAuth exchange with 1 parameter, 0% schema coverage, and an output schema (which handles return values), the description is minimally adequate. It covers the basic purpose but lacks details on authentication flow, error cases, or integration with siblings like 'linkedin_get_oauth_url', making it incomplete for full contextual understanding.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, so the description must compensate. It mentions 'browser-provided authorization code' for the 'code' parameter, adding semantic meaning beyond the schema's type definition. However, it doesn't explain the code's format, source, or validation rules, leaving gaps in parameter understanding despite the low coverage baseline.
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 the action ('Exchange') and the resources involved ('authorization code' for 'access token'), making the purpose specific and understandable. However, it doesn't explicitly differentiate this from sibling tools like 'linkedin_get_oauth_url', which might be related in the OAuth flow, leaving room for slight ambiguity in sibling context.
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 no guidance on when to use this tool versus alternatives, such as how it fits into the OAuth flow with 'linkedin_get_oauth_url' or other auth-related operations. It lacks explicit instructions on prerequisites, timing, or exclusions, offering only a basic functional statement without contextual usage advice.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations only provide a title, so the description carries the burden of behavioral disclosure. It states the search functionality but doesn't add context about rate limits, authentication needs, result format, or pagination. This is minimal but not contradictory, scoring a baseline 3 for adding some value beyond the sparse annotations.
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?
The description is a single, efficient sentence with zero waste. It's front-loaded and appropriately sized for the tool's complexity, earning a top score for conciseness.
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 (which handles return values) and low complexity, the description is somewhat complete but lacks usage context and behavioral details. It's adequate as a basic search tool description but misses opportunities to guide the agent effectively.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, so the description must compensate. It mentions 'by keywords,' which aligns with the single parameter 'keywords,' adding semantic meaning. However, it doesn't detail syntax, format, or examples, leaving gaps. With one parameter and partial compensation, a score of 3 is appropriate.
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 the action ('Search for companies') and the resource ('on LinkedIn'), providing a specific verb+resource combination. However, it doesn't explicitly differentiate from sibling tools like 'linkedin_search_people' or 'linkedin_search_jobs', which would require a 5.
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 no guidance on when to use this tool versus alternatives like 'linkedin_get_company_profile' or other search tools. It lacks context about use cases, prerequisites, or exclusions, offering only a basic functional statement.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations only provide a title, so the description carries the burden. It implies a read-only operation ('Fetch'), but doesn't disclose behavioral traits like authentication requirements, rate limits, error handling, or what details are returned. No contradiction with annotations exists, but minimal context is added.
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?
The description is a single, efficient sentence that front-loads the core purpose with no wasted words. It directly states what the tool does without unnecessary elaboration, making it easy to parse quickly.
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 tool's low complexity (1 parameter, no nested objects) and the presence of an output schema (which handles return values), the description is reasonably complete. It covers the basic purpose but lacks usage context and detailed parameter guidance, which are minor gaps in this simple case.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, so the description must compensate. It explains that 'job_urn' identifies 'a specific job posting', adding meaning beyond the schema's type definition. However, it doesn't clarify the URN format, examples, or where to obtain it, leaving gaps in parameter understanding.
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 the action ('Fetch details') and resource ('for a specific job posting'), distinguishing it from siblings like 'linkedin_search_jobs' which searches rather than fetches details. However, it doesn't explicitly differentiate from other get tools like 'linkedin_get_company_profile' beyond the resource type.
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 no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., authentication), when not to use it, or how it differs from similar tools like 'linkedin_search_jobs' for broader queries.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations only provide a title, so the description carries the full burden of behavioral disclosure. It mentions deletion but fails to describe critical traits like whether this action is irreversible, requires specific permissions, has rate limits, or what the output schema contains. For a destructive operation with minimal annotations, this leaves significant gaps.
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?
The description is a single, efficient sentence that front-loads the core action and includes a helpful example. There is no wasted verbiage, making it easy to parse quickly while conveying necessary information.
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's destructive nature, lack of annotations, and presence of an output schema, the description is minimally adequate but incomplete. It covers the basic purpose and parameter semantics but misses behavioral context like irreversibility or permission requirements. The output schema existence means return values need not be explained, but safety and operational details are lacking.
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 and one parameter, the description adds essential meaning by explaining that 'post_urn' is the identifier for the LinkedIn post to delete and provides an example format ('urn:li:share:123'). This compensates well for the lack of schema documentation, though it could specify more about URN sourcing or validation.
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 specific action ('Delete') and target resource ('a LinkedIn post'), distinguishing it from sibling tools like 'linkedin_update_post' or 'linkedin_delete_comment' by specifying the exact resource type (post) and mechanism (by its URN). It provides a concrete example ('urn:li:share:123') to illustrate the required format.
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 offers no guidance on when to use this tool versus alternatives, such as 'linkedin_update_post' for modifying posts instead of deleting them, or prerequisites like needing an existing post URN. It simply states what the tool does without contextual usage instructions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations are minimal (only a title), so the description carries the burden of behavioral disclosure. It adds the permission requirement, which is valuable context beyond the annotations. However, it doesn't describe other traits like rate limits, pagination, or what 'recent' means in terms of time range, leaving gaps in behavioral understanding.
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?
The description is a single, efficient sentence that states the action and includes a key prerequisite. It is front-loaded with the main purpose and avoids any unnecessary details, making it highly concise and well-structured.
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's complexity (a read operation with no parameters) and the presence of an output schema (which handles return values), the description is adequate but minimal. It covers the purpose and a permission requirement, but lacks details on behavioral aspects like scope or limitations, making it just sufficient for basic use.
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 input schema has 0 parameters with 100% coverage, meaning no parameters are documented in the schema. The description doesn't mention any parameters, which is appropriate here. It adds no semantic details beyond the schema, but with zero parameters, the baseline is 4 as it doesn't need to compensate for missing information.
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 the verb ('List') and resource ('user's recent posts'), making the purpose specific and understandable. However, it doesn't explicitly differentiate from sibling tools like 'linkedin_get_post_comments' or 'linkedin_search_people', which might also retrieve posts or related content, so it falls short of a perfect score.
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 includes a prerequisite ('Requires 'r_member_social' permission'), which provides some context for when to use it, but it doesn't offer explicit guidance on when to choose this tool over alternatives like 'linkedin_get_post_comments' or 'linkedin_search_people' for post-related queries. Usage is implied rather than fully specified.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations only provide a title, so the description carries the full burden of behavioral disclosure. It indicates this is a creation tool (implying mutation) and specifies visibility options, but does not cover other behavioral traits like authentication needs, rate limits, or what happens on success/failure. The description adds some context (visibility settings) but is incomplete for a mutation tool with no annotations.
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 front-loaded with the core purpose in the first sentence, followed by parameter details. It is appropriately sized with no redundant information, though the parameter explanations could be slightly more integrated into the flow rather than listed separately.
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 tool has an output schema (which handles return values), the description focuses on input semantics and purpose. It covers the basic action and parameters adequately for a creation tool, but lacks details on behavioral aspects like error handling or side effects, which would be beneficial given the mutation nature and sparse annotations.
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%, so the description must compensate. It adds meaningful semantics by explaining 'text' as 'The content of the post' and 'visibility' with enum values 'PUBLIC' or 'CONNECTIONS', which clarifies beyond the schema's basic types. However, it does not detail constraints like text length or default behavior for visibility, leaving some gaps.
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 specific action ('Create a new text-based update') and resource ('on the user LinkedIn feed'), distinguishing it from siblings like linkedin_create_image_post (which handles images) and linkedin_update_post (which modifies existing posts). The verb 'create' and resource 'feed post' are precise and unambiguous.
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 for text-based posts on LinkedIn feeds but does not explicitly state when to use this tool versus alternatives like linkedin_create_image_post or linkedin_update_post. It provides basic context (text-based updates) but lacks explicit guidance on exclusions or prerequisites, such as when image posts are more appropriate.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations only provide a title, so the description carries the full burden. It discloses the read-only nature through 'Fetch,' but lacks details on behavioral traits like rate limits, authentication needs, or error handling. No contradiction with annotations exists, but the description adds minimal value beyond the implied 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.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence that front-loads the key action and resource, with no wasted words. It directly addresses the tool's function and parameter usage, making it easy to parse and understand quickly.
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 tool's low complexity (1 parameter, no nested objects) and the presence of an output schema (which handles return values), the description is reasonably complete. It covers the core purpose and parameter usage, but could improve by adding context on authentication or error cases, though annotations are minimal.
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 and only 1 parameter, the description compensates by explaining the parameter's purpose ('company's profile information by its URN') and providing an example format ('urn:li:organization:123'). This adds meaningful semantics beyond the bare schema, though it could specify URN constraints or validation 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 specific action ('Fetch') and resource ('company's profile information'), and distinguishes it from sibling tools like 'linkedin_search_companies' by focusing on retrieval by URN rather than search. It provides a concrete example of the URN format, making the purpose unambiguous.
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 usage context by specifying retrieval by URN, which helps differentiate it from search-based siblings (e.g., 'linkedin_search_companies'). However, it does not explicitly state when to use alternatives or any exclusions, such as whether it works for all company types or requires specific permissions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations provide only a title, so the description carries full burden. It correctly describes the tool's function but doesn't disclose behavioral traits like whether this requires prior configuration, what permissions/scopes the URL includes, rate limits, or error conditions. The description adds basic context but lacks operational details.
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?
Single sentence with zero waste - every word contributes essential information. Front-loaded with the core action and resource, efficiently structured for immediate understanding.
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 tool's simple purpose (generate URL), no parameters, and existence of an output schema (which presumably documents the URL format), the description is reasonably complete. However, it could benefit from mentioning typical next steps (like redirecting users to the URL) for full context.
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 parameters and 100% schema description coverage, the baseline is 4. The description appropriately doesn't discuss parameters since none exist, and the schema already documents this completely.
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 specific action ('Generate') and resource ('LinkedIn OAuth 2.0 authorization URL') with precise scope ('for browser login'). It distinguishes from sibling tools like 'linkedin_exchange_code' which handles token exchange rather than URL generation.
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 usage context ('for browser login') suggesting this tool is for initiating OAuth flow, but doesn't explicitly state when to use it versus alternatives like direct API calls or other auth methods. No explicit exclusions or prerequisites are mentioned.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations only provide a title, so the description carries the burden of behavioral disclosure. It describes a read-only fetch operation, which aligns with the tool name and purpose, but does not mention rate limits, authentication requirements, error handling, or what data is returned (though an output schema exists). It adds minimal context beyond the basic action, leaving gaps in behavioral understanding.
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?
The description is a single, efficient sentence that front-loads the key information ('Fetch a specific member's profile') and includes a helpful example. There is no wasted text, and it directly supports the tool's purpose without redundancy, making it highly concise and well-structured.
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 simple input schema (one required parameter) and the presence of an output schema, the description is mostly complete. It covers the parameter semantics well but lacks details on authentication, rate limits, or error scenarios. For a read-only fetch tool, this is adequate, though adding a bit more behavioral context would enhance completeness.
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, so the description fully compensates by explaining the 'member_urn' parameter's purpose and providing a concrete example ('urn:li:person:123'). This adds essential meaning beyond the bare schema, clarifying the parameter's format and usage, which is critical for correct tool invocation.
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 specific action ('Fetch') and resource ('a specific member's profile'), distinguishing it from sibling tools like 'linkedin_get_my_profile' (which fetches the user's own profile) or 'linkedin_search_people' (which searches for multiple profiles). It provides a concrete example of the required parameter format ('urn:li:person:123'), making the purpose unambiguous.
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 implicitly indicates when to use this tool—when you have a specific member's URN and need their profile. However, it does not explicitly state when not to use it (e.g., vs. 'linkedin_search_people' for broader searches) or mention prerequisites like authentication, though the context of sibling tools suggests it's part of a LinkedIn API suite. The guidance is clear but lacks explicit alternatives or exclusions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The description adds value beyond annotations by specifying the data fields returned (Name, Email, Picture), which isn't covered in annotations. However, it doesn't disclose additional behavioral traits like authentication requirements, rate limits, or error handling. With annotations limited to title only, the description carries more burden but does not fully compensate.
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?
The description is a single, well-structured sentence that efficiently conveys the tool's purpose, scope, and output fields. It is front-loaded with the key action and resource, with no wasted words.
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 tool's low complexity (0 parameters, read-only operation implied by 'Fetch'), an output schema exists, and annotations are minimal, the description is reasonably complete. It specifies the returned data fields, which complements the output schema. However, it could benefit from mentioning authentication context or usage constraints.
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 0 parameters, and schema description coverage is 100%, so no parameter documentation is needed. The description appropriately focuses on the tool's purpose without redundant parameter info, earning a high score for efficiency.
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 specific action ('Fetch') and resource ('authenticated user's profile information'), explicitly listing the data fields returned (Name, Email, Picture). It distinguishes from siblings like 'linkedin_get_member_profile' by specifying it's for the authenticated user only.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines5/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description explicitly states when to use this tool: to fetch the authenticated user's profile. It implies when not to use it (e.g., for other users' profiles, where 'linkedin_get_member_profile' would be the alternative). This provides clear context for selection among sibling tools.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior5/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations only provide a title, so the description carries full burden. It discloses key behavioral traits: the operation deletes the old post and creates a new one with a new ID, and notes LinkedIn's API limitation. This adds crucial context beyond basic annotations.
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 sentences, front-loaded with the core purpose followed by a critical warning. Every word earns its place, with no redundancy or fluff, making it highly efficient.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's complexity (destructive update), lack of rich annotations, and presence of an output schema, the description is complete. It covers purpose, behavioral nuances, and usage context, compensating well for minimal structured data.
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 adds value by implying parameters (post_urn for the post to update, text for new content). However, it doesn't detail all three parameters (e.g., visibility's default or meaning), leaving some gaps.
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 specific action ('Update a post's text') and resource ('post'), distinguishing it from siblings like linkedin_create_post (creation) and linkedin_delete_post (deletion). It precisely defines the operation's scope.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines5/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
It explicitly states when to use this tool (to update post text) and provides a critical warning about LinkedIn's API limitation, which implicitly guides usage by highlighting its destructive nature and alternative considerations. This addresses the tool's unique context among siblings.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

GitHub Badge

Glama performs regular codebase and documentation scans to:

Confirm that the MCP server is working as expected.
Confirm that there are no obvious security issues.
Evaluate tool definition quality.

Our badge communicates server capabilities, safety, and installation instructions.

Card Badge

Copy to your README.md:

[![Linkedin_mcp_custom_server MCP server](https://glama.ai/mcp/servers/SARAMALI15792/Linkedin_mcp_custom_server/badges/card.svg)](https://glama.ai/mcp/servers/SARAMALI15792/Linkedin_mcp_custom_server)

Score Badge

Copy to your README.md:

[![Linkedin_mcp_custom_server MCP server](https://glama.ai/mcp/servers/SARAMALI15792/Linkedin_mcp_custom_server/badges/score.svg)](https://glama.ai/mcp/servers/SARAMALI15792/Linkedin_mcp_custom_server)

Latest Blog Posts

Who's Calling? MCP Hosts Are an Identity Blind Spot (And the Spec Knows It)
By Om-Shree-0709 on July 25, 2026.
mcp
Agent Identity
OAuth 2.1
Your AI Chatbot Just Exposed Your CEO's Salary to an Intern
By Om-Shree-0709 on July 2, 2026.
Agent Identity
MCP Security
OAuth Delegation
Why MCP Servers Need Execution Sandboxing (And Why Your Current Stack Isn't Enough)
By Om-Shree-0709 on June 30, 2026.
Agentic Ai
Prompt Injection
WebAssembly

MCP directory API

We provide all the information about MCP servers via our MCP API.

curl -X GET 'https://glama.ai/api/mcp/v1/servers/SARAMALI15792/Linkedin_mcp_custom_server'

If you have feedback or need assistance with the MCP directory API, please join our Discord server