flin-linkedin-posts-mcp
Click on "Install Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@flin-linkedin-posts-mcplist my recent LinkedIn posts"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
flin-linkedin-posts-mcp
flin-linkedin-posts-mcp is a local MCP server for reading and analyzing the authenticated member's own LinkedIn post/share data.
It uses LinkedIn member OAuth login and the Member Data Portability API. Each user runs the MCP locally, signs into their own LinkedIn account in the system browser, and stores their token on their own machine.
The MCP supports two login flows:
Regular 3-legged OAuth with a client secret. This is the recommended local setup for most LinkedIn Developer apps.
Native OAuth PKCE. This does not require a client secret, but LinkedIn must explicitly enable the Native PKCE protocol for your app.
Important Access Requirement
This MCP does not bypass LinkedIn API approval. Each user should create their own LinkedIn Developer app with access to Member Data Portability API (Member) and the r_dma_portability_self_serve permission. Without that product/scope, LinkedIn returns 403 ACCESS_DENIED for memberSnapshotData.
Native PKCE is a separate LinkedIn app capability. If LinkedIn shows Not enough permissions to access Native PKCE protocol, use the regular 3-legged OAuth setup below or ask LinkedIn to enable Native PKCE for the app.
Relevant LinkedIn docs:
3-legged OAuth: https://learn.microsoft.com/en-us/linkedin/shared/authentication/authorization-code-flow
Native OAuth PKCE: https://learn.microsoft.com/en-us/linkedin/shared/authentication/authorization-code-flow-native
Member Snapshot API: https://learn.microsoft.com/en-us/linkedin/dma/member-data-portability/shared/member-snapshot-api
Snapshot domains: https://learn.microsoft.com/en-us/linkedin/dma/member-data-portability/shared/snapshot-domain
API access overview: https://learn.microsoft.com/en-us/linkedin/shared/authentication/getting-access
Related MCP server: LinkedIn MCP Server
Features
Browser-based LinkedIn login with regular OAuth or native PKCE
Local token storage outside the repository
Auth status and logout tools
Snapshot domain count/debug tool
Authenticated member post/share listing from
MEMBER_SHARE_INFOPost analysis for counts, text length, hashtags, mentions, and top terms
Best-effort extraction of engagement counters when they are present in snapshot rows
Draft-to-published matching based on provided draft texts
Optional engagement enrichment via LinkedIn
socialMetadataandmemberCreatorPostAnalytics
MCP Tools
auth_statusloginlogoutlist_snapshot_domainslist_member_postsanalyze_member_postsmatch_drafts_to_member_postsget_post_social_metadataget_member_post_analyticsenrich_member_posts_with_engagement
Configuration
Required for login:
LINKEDIN_CLIENT_ID: LinkedIn Developer app client ID
Recommended for regular 3-legged OAuth:
LINKEDIN_CLIENT_SECRET: LinkedIn Developer app client secret. If set,LINKEDIN_OAUTH_FLOWdefaults toauthorization_code.LINKEDIN_REDIRECT_URI: exact local callback URI registered in the LinkedIn app, for examplehttp://127.0.0.1:63141/callback.
Optional:
LINKEDIN_OAUTH_FLOW:authorization_codeornative_pkce. Defaults toauthorization_codewhenLINKEDIN_CLIENT_SECRETis set, otherwisenative_pkce.LINKEDIN_SCOPES: defaults tor_dma_portability_self_serveLINKEDIN_API_VERSION: defaults to202312LINKEDIN_RESTLI_PROTOCOL_VERSION: defaults to2.0.0LINKEDIN_TIMEOUT_SECONDS: defaults to30LINKEDIN_MAX_RETRIES: defaults to3LINKEDIN_OAUTH_TIMEOUT_SECONDS: defaults to300LINKEDIN_TOKEN_FILE: defaults to~/.flin-linkedin-posts-mcp/tokens.json
Additional LinkedIn access may be required for engagement enrichment:
socialMetadataaccess for comment and reaction summariesr_member_postAnalyticsfor member post impressions, reach, reactions, comments, and reshares
The MCP intentionally does not require LINKEDIN_ACCESS_TOKEN anymore. Tokens are created through the login tool.
LinkedIn Developer App Setup
Create or open a LinkedIn Developer app.
Add/obtain access to
Member Data Portability API (Member).Make sure the app can request
r_dma_portability_self_serve.For regular 3-legged OAuth, add an exact loopback redirect URL in the app's Auth tab, for example
http://127.0.0.1:63141/callback.Set
LINKEDIN_CLIENT_ID,LINKEDIN_CLIENT_SECRET, andLINKEDIN_REDIRECT_URIto the same redirect URL.For native PKCE only, ask LinkedIn to enable Native PKCE OAuth for the app, omit
LINKEDIN_CLIENT_SECRET, and configure loopback redirect URIs as LinkedIn requires.
Claude Desktop Configuration
For a published package:
{
"mcpServers": {
"flin-linkedin-posts-mcp": {
"command": "uvx",
"args": ["--refresh", "flin-linkedin-posts-mcp@latest"],
"env": {
"LINKEDIN_CLIENT_ID": "<YOUR_LINKEDIN_CLIENT_ID>",
"LINKEDIN_CLIENT_SECRET": "<YOUR_LINKEDIN_CLIENT_SECRET>",
"LINKEDIN_REDIRECT_URI": "http://127.0.0.1:63141/callback",
"LINKEDIN_SCOPES": "r_dma_portability_self_serve",
"LINKEDIN_API_VERSION": "202312"
}
}
}
}For local development from this repository:
{
"mcpServers": {
"flin-linkedin-posts-mcp": {
"command": "uv",
"args": ["run", "flin-linkedin-posts-mcp"],
"cwd": "/path/to/flin-linkedin-posts-mcp",
"env": {
"LINKEDIN_CLIENT_ID": "<YOUR_LINKEDIN_CLIENT_ID>",
"LINKEDIN_CLIENT_SECRET": "<YOUR_LINKEDIN_CLIENT_SECRET>",
"LINKEDIN_REDIRECT_URI": "http://127.0.0.1:63141/callback",
"LINKEDIN_SCOPES": "r_dma_portability_self_serve",
"LINKEDIN_API_VERSION": "202312"
}
}
}
}After adding the config, restart the MCP host and call:
auth_statusloginlist_snapshot_domainslist_member_postsoranalyze_member_postsmatch_drafts_to_member_postsif you want to compare draft text to published postsget_post_social_metadata,get_member_post_analytics, orenrich_member_posts_with_engagementif your LinkedIn app has the required engagement scopes
Local Development
python3 -m pip install -e '.[dev]'
pytest -q
ruff check .Packaging
python3 -m buildThe package entry point is:
flin-linkedin-posts-mcpTroubleshooting
LINKEDIN_CLIENT_ID is required before running login: setLINKEDIN_CLIENT_IDin the MCP config.Not enough permissions to access Native PKCE protocol: the LinkedIn app does not have Native PKCE enabled. SetLINKEDIN_CLIENT_SECRETandLINKEDIN_REDIRECT_URIto use regular 3-legged OAuth, or ask LinkedIn to enable Native PKCE for the app.LINKEDIN_REDIRECT_URI is required when LINKEDIN_OAUTH_FLOW=authorization_code: add the same exact local callback URL to the LinkedIn app's Auth tab and to the MCP config.403 ACCESS_DENIEDforpartnerApiMemberSnapshotData: the LinkedIn Developer app/token likely does not have Member Data Portability API access orr_dma_portability_self_serve.LinkedIn token has expired: runloginagain. If LinkedIn issued a refresh token, the MCP attempts a refresh automatically before requiring login.Timed out waiting for LinkedIn OAuth callback: rerunloginand complete the browser flow withinLINKEDIN_OAUTH_TIMEOUT_SECONDS.403 ACCESS_DENIEDonsocialMetadataormemberCreatorPostAnalytics: the LinkedIn app/token does not have the extra engagement permissions needed for those tools.
Notes
The MCP reads only the authenticated member's own snapshot data.
It does not support arbitrary-author LinkedIn post lookup.
MEMBER_SHARE_INFOis snapshot/export-style data, so field names can vary. The normalizer is intentionally tolerant and keepsinclude_raw=trueavailable for debugging.LinkedIn's portability data for
Sharesis documented around fields like date, link, commentary, media URL, and visibility. Likes, comments, and impressions are exposed only if they appear in the snapshot payload returned for that member.Saved LinkedIn drafts are not exposed as a documented portability snapshot domain here.
match_drafts_to_member_postscompares draft texts you already have against published posts; it does not fetch drafts from LinkedIn.analyze_member_postscan return very large payloads wheninclude_posts=true. Usepost_limitto cap the embeddedpostslist, or setinclude_posts=falsewhen you only need aggregate metrics.enrich_member_posts_with_engagementkeeps export discovery and engagement lookup separate. It fetches exported posts first, derives post URNs, then merges insocialMetadataand analytics where available.Bulk enrichment is intentionally bounded. Use
limitto keep the number of analytics calls under control and expect per-postengagement_errorswhen a URN cannot be derived or LinkedIn denies a lookup.
Available Tools
10 toolsanalyze_member_postsD
Analyze the authenticated member's LinkedIn posts/share records
| Name | Required | Description | Default |
|---|---|---|---|
| top_n | No | ||
| page_size | No | ||
| post_limit | No | ||
| include_posts | No | ||
| published_after | No |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are present, and the description only says 'analyze', which is ambiguous regarding side effects, required permissions, or whether it is read-only. The behavioral traits are not disclosed.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is extremely short but fails to convey essential information. It is under-specified rather than concise, offering no structure or key details beyond a vague verb.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
With 5 parameters, no output schema, and 10 sibling tools, the description is grossly incomplete. It does not address what analysis is done, what results look like, or how to configure the tool effectively.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, and the description does not explain the purpose or effect of any of the 5 parameters. The agent cannot infer how to use parameters like 'page_size', 'top_n', or 'published_after' from the description alone.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses the vague verb 'analyze' without specifying what analysis is performed. It does not distinguish itself from sibling tools like get_member_post_analytics or enrich_member_posts_with_engagement, which have more explicit purposes.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
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. The sibling tools list includes several analytics-related tools, but the description offers no context for differentiation.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
auth_statusA
Check whether the local MCP has a usable LinkedIn OAuth token
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
TDQS
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 indicates a read-only check without side effects, but does not define what 'usable' means (e.g., token validity, expiration).
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
A single, front-loaded sentence with no extraneous information. Every word earns its place.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple zero-parameter tool with no output schema, the description is complete enough. It could mention the return type (e.g., boolean), but the tool's simplicity makes this acceptable.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
With no parameters, the description adds meaning beyond the empty schema by clarifying the tool's purpose. Baseline score for 0-param tools is 4.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses a specific verb 'Check' and clearly identifies the resource as 'whether the local MCP has a usable LinkedIn OAuth token'. It distinguishes itself from sibling tools like login and logout.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description does not explicitly state when to use this tool versus alternatives, but since it is the only tool for checking auth status, usage is implied. Lacks explicit guidance on prerequisites or context.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
enrich_member_posts_with_engagementC
Enrich exported member posts with LinkedIn social metadata and analytics when scopes are available
| Name | Required | Description | Default |
|---|---|---|---|
| limit | No | ||
| page_size | No | ||
| published_after | No | ||
| analytics_metric_types | No | ||
| include_post_analytics | No | ||
| include_social_metadata | No |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries full burden for behavioral details. It mentions 'when scopes are available' implying authorization, but does not disclose side effects, error conditions, or whether the operation is read-only or modifies state.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single sentence of 13 words, which is concise. However, it sacrifices necessary detail; it is not appropriately sized for a tool with 6 parameters and no other structured metadata.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool has 6 undocumented parameters, no output schema, and no annotations, the description is severely incomplete. It does not cover expected output, error conditions, or relationship to sibling tools like list_member_posts.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0% and the description does not explain any of the 6 parameters. An AI agent would have no context on how page_size, limit, published_after, social metadata flags, or analytics metric types affect the enrichment.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action ('Enrich exported member posts') and the type of data added ('LinkedIn social metadata and analytics'). It distinguishes from sibling tools like get_member_post_analytics and get_post_social_metadata by implying a combination of enrichment, but does not explicitly differentiate.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
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, nor any prerequisites such as requiring exported posts or specific scopes. The phrase 'when scopes are available' hints at authorization but is vague.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_member_post_analyticsC
Fetch LinkedIn analytics metrics for a single member-owned post
| Name | Required | Description | Default |
|---|---|---|---|
| post_url | No | ||
| post_urn | No | ||
| metric_types | No |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description must carry the full burden for behavioral traits. It only states 'Fetch', implying read-only, but lacks details on required permissions, error handling, rate limits, or what happens with invalid inputs.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single short sentence, which is concise but lacks necessary detail. It could be slightly longer to include parameter guidance without being verbose.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool has 3 parameters, no output schema, and no annotations, the description is highly incomplete. It fails to provide essential context for correct invocation, such as parameter constraints or return format.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, and the description does not explain any parameter's purpose, format, or relationships (e.g., whether post_urn and post_url are alternatives or both needed). The agent cannot infer how to correctly set metric_types.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly specifies the verb 'Fetch' and the resource 'LinkedIn analytics metrics for a single member-owned post', distinguishing it from siblings like 'list_member_posts' and 'get_post_social_metadata'.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
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. There is no mention of prerequisites or context for selection.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_post_social_metadataC
Fetch comment and reaction summary data for a single LinkedIn post
| Name | Required | Description | Default |
|---|---|---|---|
| post_url | No | ||
| post_urn | No |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries full burden for behavioral traits. It only states 'Fetch' which implies a read operation, but provides no details about authentication, rate limits, error conditions, or side effects.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence with no redundancy. However, its brevity sacrifices necessary detail, making it less helpful than a slightly longer but more informative description.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the lack of annotations, output schema, and parameter descriptions, the description is insufficient. An agent cannot determine required inputs or expected output beyond the vague notion of 'comment and reaction summary data'.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 0% and the description does not explain the two parameters (post_urn, post_url). The agent has no information on what these parameters represent or how to use them.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description explicitly states the action (Fetch), the resource (comment and reaction summary data), and the scope (single LinkedIn post). It clearly distinguishes from siblings like get_member_post_analytics and enrich_member_posts_with_engagement.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
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. The description does not mention any prerequisites, context, or scenarios where this tool is preferred over similar tools like get_member_post_analytics.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
list_member_postsC
List posts/share records for the authenticated LinkedIn member
| Name | Required | Description | Default |
|---|---|---|---|
| limit | No | ||
| page_size | No | ||
| include_raw | No | ||
| published_after | No |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are present, so the description carries full burden for behavioral traits. It does not disclose pagination behavior, filtering by date (published_after), or the scope of posts (only authored by member?). The description is too sparse to convey important behavioral details.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single sentence, making it concise, but it lacks critical information. Conciseness should not come at the expense of completeness. It is structured as a simple statement, which is adequate but not exemplary.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given that the tool has 4 parameters, no annotations, and no output schema, the description is severely incomplete. It fails to explain return values, filtering capabilities, or any side effects. The description provides only the bare minimum for understanding the tool's function.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has 4 parameters with 0% description coverage, and the tool description adds no explanation for any parameter. The agent cannot infer the meaning or usage of 'page_size', 'include_raw', 'published_after', or 'limit' from the description.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action 'list' and the resource 'posts/share records' for the 'authenticated LinkedIn member', which gives a good sense of what the tool does. However, it does not differentiate from sibling tools like 'analyze_member_posts' or 'enrich_member_posts_with_engagement', so it loses some points for lack of distinction.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
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, no prerequisites, and no context about appropriate invocation. It simply states the action without any usage boundaries.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
list_snapshot_domainsB
List available LinkedIn Member Data Portability snapshot domains and item counts
| Name | Required | Description | Default |
|---|---|---|---|
| page_size | No |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The description indicates a read operation but does not disclose behavioral traits such as authentication requirements, rate limits, pagination, or the format of the response. With no annotations provided, the description should carry the burden of transparency but falls short.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single sentence, highly concise with no extraneous information. Every word contributes to the purpose.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple listing tool with one optional parameter and no output schema, the description provides the basic purpose. However, it lacks details on the return structure (e.g., whether it's a list of strings with counts or a mapping), which would aid completeness.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool has one parameter (page_size) with 0% schema description coverage. The description does not mention page_size at all, failing to add any meaning beyond the schema's type and constraints.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool lists LinkedIn Member Data Portability snapshot domains and item counts. It uses a specific verb ('list') and resource ('snapshot domains'), and it is distinct from sibling tools which focus on member posts, authentication, and other unrelated tasks.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
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 vs alternatives, prerequisites, or scenarios for use. There is no mention of when not to use it or which tool to use instead for related tasks.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
loginA
Start browser-based LinkedIn OAuth login and store the token locally
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description must convey behavior. It states the action (start login) and side effect (store token), but lacks details on potential user interaction requirements, conditional behavior if already logged in, or token management.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
A single sentence that is front-loaded with the primary action and includes key information. No unnecessary words.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a zero-parameter tool, the description is minimal but misses details about return values, prerequisites, and interaction with sibling tools like auth_status. It is adequate but not fully complete for an agent navigating authentication flow.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has no parameters, so schema description coverage is 100%. The description correctly adds no parameter information, but does not need to; baseline of 3 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses a specific verb 'Start' and clearly identifies the resource as 'browser-based LinkedIn OAuth login'. It also implies storing the token, distinguishing it from sibling tools like 'auth_status' and 'logout'.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implicitly indicates when to use the tool (to initiate login) but provides no explicit guidance on when not to use it or mention of alternatives like checking auth_status first.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
logoutA
Delete the locally stored LinkedIn OAuth token
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description bears full burden. It discloses deletion of a local token but omits details like server-side invalidation or side effects. For a simple tool, this is adequate but not thorough.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Single sentence with no wasted words; front-loads action and resource.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple logout with no parameters or output schema, the description is mostly complete. A minor gap: it does not clarify that this only affects local storage, not server-side session.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
There are no parameters, so baseline is 4. The description does not add parameter info, which is acceptable here.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action (delete) and the resource (locally stored LinkedIn OAuth token), which distinguishes it from sibling tools like login (creates token) and auth_status (checks token).
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies use when logging out and clearing local credentials, but does not explicitly state when not to use or mention alternatives like auth_status or login.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
match_drafts_to_member_postsC
Match draft post texts against the authenticated member's published LinkedIn posts
| Name | Required | Description | Default |
|---|---|---|---|
| drafts | Yes | ||
| page_size | No | ||
| post_limit | No | ||
| published_after | No | ||
| max_matches_per_draft | No |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided, so the description carries full burden. It only states it operates on 'authenticated member's published posts', but does not disclose side effects, rate limits, or what happens with no matches. Minimal behavioral 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.
Is the description appropriately sized, front-loaded, and free of redundancy?
Extremely concise (one sentence) but at the cost of omitting essential details. For a tool with 5 parameters, the description is too sparse and does not effectively front-load critical information.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
With no output schema, no annotations, and a high parameter count (5), the description fails to explain return values, matching logic, or constraints. It is grossly incomplete for an AI agent to correctly invoke and interpret results.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Description does not explain any of the 5 parameters beyond the implicit mention of 'drafts'. Parameters like page_size, published_after, post_limit, and max_matches_per_draft are left entirely undefined, providing no value over the raw schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb 'match' and the resources 'draft post texts' and 'published LinkedIn posts', which distinguishes it from sibling tools like list_member_posts or analyze_member_posts. However, it could be more specific about what 'match' entails (e.g., similarity threshold or algorithm).
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No explicit guidance on when to use this tool vs alternatives. It is implied that the user has drafts and wants to compare them to published posts, but there is no mention of prerequisites (e.g., authentication), when not to use, or references to sibling tools.
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. Dates show when Glama detected each change.
10 tool updates
v0.2.5- First observed
analyze_member_posts - First observed
auth_status - First observed
enrich_member_posts_with_engagement - First observed
get_member_post_analytics - First observed
get_post_social_metadata - First observed
list_member_posts - First observed
list_snapshot_domains - First observed
login - First observed
logout - First observed
match_drafts_to_member_posts
TDQS
Scored across 10 tools
Each tool has a clearly distinct purpose: authentication (login, logout, auth_status), post listing and analysis (list_member_posts, analyze_member_posts), enrichment and analytics (enrich_member_posts_with_engagement, get_member_post_analytics, get_post_social_metadata), snapshot domains (list_snapshot_domains), and draft matching (match_drafts_to_member_posts). No two tools overlap functionally.
Most tools use a consistent snake_case verb_noun pattern (e.g., list_member_posts, get_member_post_analytics). The exceptions are 'login' and 'logout', which are single verbs but still clear and follow conventional auth naming. The overall pattern is predictable and readable.
With 10 tools, the server is well-scoped for its purpose of analyzing LinkedIn posts and managing authentication. Each tool serves a distinct function without redundancy, and the count is neither too sparse nor overwhelming for the domain.
The tool set covers core workflows: authentication, listing, analysis, enrichment, and analytics. Missing is a direct 'get post by ID' tool, but that functionality is partially covered by analytic and metadata tools that require a post identifier. The snapshot domain tool adds breadth. Overall, the surface is nearly complete for analyzing member posts.
Maintenance
Resources
Unclaimed servers have limited discoverability.
Looking for Admin?
If you are the server author, to access and configure the admin panel.
Related MCP Connectors
Search, label and export your LinkedIn saved posts, then draft, schedule and publish from them.
Read-only access to your what2post LinkedIn data: posts, profile stats, follower growth and goals.
Scrape and analyze public LinkedIn posts as structured JSON via the Apify LinkedIn Posts API.
PerfectPost is a LinkedIn content management platform. This MCP server gives AI assistants read and write access to a user's PerfectPost account: published posts with their engagement analytics, drafts lifecycle (create / edit / schedule), and LinkedIn profile data.
Related MCP Servers
- AlicenseNot gradedqualityDmaintenanceEnables users to fetch, analyze, and manage LinkedIn posts data through tools that retrieve profiles, search posts by keywords, filter by date, and identify top-performing content based on engagement metrics.MIT
- FlicenseNot gradedqualityDmaintenanceEnables users to search for jobs, retrieve profiles, and fetch feed posts through the LinkedIn API. It also provides tools for analyzing and extracting data from PDF resumes.-
- AlicenseBqualityAmaintenanceEnables AI agents with read/write access to LinkedIn API, including profile, posts, media, organizations, comments, reactions, and analytics.2011MIT
- AlicenseAqualityDmaintenanceEnables posting content, sharing articles, and managing LinkedIn profile through natural language using the official LinkedIn REST API with OAuth 2.0.718MIT
Latest Blog Posts
- Who's Calling? MCP Hosts Are an Identity Blind Spot (And the Spec Knows It)By Om-Shree-0709 on .mcpAgent IdentityOAuth 2.1
- Your AI Chatbot Just Exposed Your CEO's Salary to an InternBy Om-Shree-0709 on .Agent IdentityMCP SecurityOAuth Delegation
- Why MCP Servers Need Execution Sandboxing (And Why Your Current Stack Isn't Enough)By Om-Shree-0709 on .Agentic AiPrompt InjectionWebAssembly
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/flin-agency/flin-linkedin-posts-mcp'
If you have feedback or need assistance with the MCP directory API, please join our Discord server