unipile-linkedin-mcp

Server Quality Checklist

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

Latest release: v0.1.0
Disambiguation4/5
Most tools have distinct purposes, but there is some overlap between start_chat, send_inmail, and send_message which could cause confusion. The descriptions help differentiate them, but the boundaries between initiating a chat vs sending an InMail vs sending a message in an existing chat are not immediately clear. Similarly, search_people and search_people_sales_nav are similar but separate. Overall, good disambiguation with minor issues.
Naming Consistency5/5
All tool names follow a consistent verb_noun pattern in snake_case. Names clearly indicate the action and target resource (e.g., get_profile, send_invitation, search_companies). There are no mixed conventions or ambiguous naming styles.
Tool Count4/5
With 22 tools, the set is comprehensive but slightly high. However, each tool serves a distinct function covering multiple areas (profiles, search, messaging, invitations, accounts). The count is appropriate for the broad scope of LinkedIn automation, though it could be trimmed slightly.
Completeness4/5
The tool set covers core LinkedIn workflows: profile retrieval, searching (people, companies, posts), messaging (chats, InMail, invitations), and account management. Missing features like profile updates, message deletion, or advanced filtering are minor gaps. Overall, it's sufficiently complete for common use cases.
Average 4.1/5 across 22 of 22 tools scored.
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?
No annotations are provided, and the description only states 'Accept' without disclosing side effects, required permissions, rate limits, or whether the action is reversible. The mutation behavior is implied but not elaborated.
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 extremely concise, using only necessary sentences. No wasted words, and the structure (description, args, returns) is logical.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple tool with one parameter and no complex output, the description is adequate but could be improved by specifying the confirmation format and potential errors. The returns section is vague ('Confirmation of acceptance').
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?
The description adds meaning by referencing 'from list_invitations_received' for the invitation_id, but does not explain the parameter format or constraints. Schema coverage is 0%, so the description partially compensates but falls short of full clarity.
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 uses a specific verb ('Accept') and resource ('received connection request'), clearly distinguishing it from sibling tools like 'decline_invitation' or 'send_invitation'.
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 states the action and references 'list_invitations_received' as a prerequisite, providing clear context. However, it does not explicitly state when not to use this tool or mention alternatives.
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?
No annotations are provided, so the description carries the full burden. It discloses that the tool returns a 'list of chat conversations with latest message preview' and implies pagination via limit and cursor, but lacks details on ordering, rate limits, 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.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is short and includes Args and Returns sections, making it easy to scan. It could be slightly more concise but is 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 3 parameters, no output schema, and no annotations, the description covers the basics but is incomplete. It does not specify the default sorting order or the structure of the returned conversations beyond a preview.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters5/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, but the description adds significant meaning: limit is 'Max results per page', cursor is 'Pagination cursor from previous response', and unread_only is 'If True, only return chats with unread messages'. This fully compensates for the lack of schema descriptions.
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 'List LinkedIn message conversations,' which is a specific verb+resource. It distinguishes from sibling tools like get_chat_messages (which gets messages within a chat) and start_chat (creates a new chat).
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 explicit guidance on when to use this tool versus alternatives. It does not mention when not to use it or provide context for switching to other chat-related tools.
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?
No annotations are provided, so the description must disclose behavioral traits. It states the tool 'checks' and 'returns' data, but does not explicitly state that it is read-only, safe, or mention any authentication or rate limit considerations. It lacks behavioral context beyond the basic operation.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is five sentences and includes necessary background information. It is fairly concise and every sentence adds value, though it could be slightly more streamlined by integrating the background into the main statement.
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 has no parameters and no output schema, the description is complete. It explains the purpose, provides context about InMail credits, and describes the return value. There are no gaps in information.
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 zero parameters and schema coverage is 100%. The description does not need to add parameter meaning because there are none. According to the rubric, baseline for 0 parameters is 4.
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 uses a specific verb ('Check') and clearly identifies the resource ('InMail credits for the connected LinkedIn account'). It distinguishes itself from sibling tools like 'send_inmail' and 'send_invitation' by focusing solely on credit checking.
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 provides background on when InMail credits are used and that premium users have variations, but it does not explicitly state when to use this tool versus alternatives or provide any usage exclusions. The guidance is implicit rather than direct.
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?
No annotations are provided, so the description must carry the full burden. It mentions pagination via cursor and returns 'List of connections with profile summaries,' which gives a basic behavioral picture. However, it does not disclose authentication requirements, rate limits, or whether the tool returns all connections or just one page. More detail would improve transparency.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is concise, with a clear one-line purpose followed by parameter list and return description. It avoids fluff and is front-loaded. The structure could be improved with formatting, but it efficiently conveys essential 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?
The tool has two parameters, no output schema, and no annotations. The description explains the return value as 'List of connections with profile summaries,' which gives a general idea but lacks detail on the structure of each connection. For a simple list tool, it is adequate but not fully complete, especially without schema descriptions.
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 no descriptions for its two parameters (0% coverage), so the description must compensate. It adds meaning: 'limit: Max results per page (default 50)' and 'cursor: Pagination cursor from previous response,' which clarifies usage. However, it could add constraints like acceptable range for limit. Overall, it adds significant value beyond the bare schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states 'List your 1st degree connections on LinkedIn,' specifying the verb (list), resource (1st degree connections), and context (LinkedIn). This distinguishes it from sibling tools like 'get_profile' or 'list_invitations_received' which have different purposes.
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 listing connections but does not explicitly state when to use this tool versus alternatives. It does not provide conditions for use or exclusion criteria (e.g., when to use search_people instead). While it is clear, it lacks proactive guidance on tool selection.
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?
No annotations provided. Description reveals key behavioral traits: requires Premium, uses InMail credits, targets non-connections. However, it omits details like credit consumption confirmation, rate limits, or asynchronous delivery.
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?
Concise and efficient: 3 sentences plus argument list. Front-loaded with purpose and prerequisite. No redundant content, but could improve structure with bullet points for args.
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?
Covers purpose, prerequisite, and basic param descriptions. Missing: output format, error handling (e.g., insufficient credits), rate limits, or message tracking details. Adequate but not comprehensive.
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?
With 0% schema coverage, description adds meaning by naming required parameters and brief explanations. However, attendees_ids format is ambiguous ('LinkedIn provider IDs') and does not clarify expected structure 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?
Clear verb (send), resource (InMail message), and target audience (non-connections). Distinguishes from sibling tools like send_message and send_invitation by specifying the use case and requirement for LinkedIn Premium.
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?
Explicitly states when to use (messaging 2nd/3rd degree connections without connecting) and advises checking credits via get_inmail_credits() first. Provides clear prerequisite guidance.
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?
No annotations are provided, so the description must disclose behavioral traits. It only states the return data composition (description, industry, etc.) but does not mention that it is a read-only operation, any authentication prerequisites, rate limits, or error behaviors. The description does not add value beyond the obvious 'get' semantics.
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 extremely concise: a single line for purpose, then a clear Args block and Returns block. It is front-loaded with the main action and has no redundant information. Every sentence serves a purpose.
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?
For a simple tool with one parameter and no output schema, the description is mostly complete. It explains the input and gives examples of output fields. However, it could be improved by noting that the output is a JSON object with a defined structure (though no schema exists). Overall, it adequately covers the essential information for an agent to use the tool.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters5/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 0%, but the description explicitly explains the only parameter: 'company_id: The LinkedIn company ID or vanity URL name.' This adds critical context about acceptable input types, which is not present in the schema (which only states type: string).
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's function: 'Get a company's LinkedIn profile/page details.' This specifies a verb ('Get') and a resource ('company profile'), distinguishing it from sibling tools like 'get_my_profile' (personal profile) and 'search_companies' (search functionality).
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?
Usage is implied (use when you need a company's profile by ID), but no explicit guidance on when to use this tool over siblings, such as 'search_companies' for finding companies by name, or 'get_profile' for people. No when-not-to-use information.
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?
No annotations exist, so description is key. It indicates listing returns a list with recipient details but does not disclose read-only nature or other behavioral traits like idempotency. Adequate but minimal.
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?
Extremely concise with no wasted words. Front-loaded purpose, then parameter explanations, and return description. Every sentence adds value.
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?
Adequate for a simple list tool with pagination. However, no output schema and no mention of sorting or filtering. With no annotations, additional context like rate limits or result structure would improve completeness.
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 has 0% description coverage, but the description explains limit as 'Max results per page (default 50)' and cursor as 'Pagination cursor from previous response,' adding meaning beyond types and defaults.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
Clearly states 'List pending outbound connection requests,' identifying the verb and resource. Distinguishes from sibling tool list_invitations_received by specifying 'outbound'.
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?
Implies usage for viewing sent invitations but lacks explicit when-not or alternative comparisons. With siblings like accept_invitation and list_invitations_received, more guidance would help.
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?
As no annotations are provided, the description carries full burden. It describes return format with sender info and timestamps, and mentions pagination. However, it does not explicitly state that the operation is read-only or disclose any side effects, which would help an agent understand safety.
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 brief and well-structured with Args and Returns sections. Every sentence is necessary and front-loaded with the purpose. No redundant information.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the simplicity of the tool (3 parameters, no output schema, no annotations), the description covers essential aspects: required chat_id, pagination with limit and cursor, return format. It lacks details on error handling or rate limits, but is reasonably complete for a read operation.
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 significant meaning: explains chat_id as from list_chats, limit as max per page with default 50, and cursor as pagination from previous response. This compensates for the lack of schema param descriptions.
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 'Get messages from a specific chat conversation,' specifying the verb and resource. It distinguishes from sibling tools like list_chats, send_message, start_chat by focusing on retrieval of messages.
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 that chat_id comes from list_chats and explains pagination parameters, but does not explicitly state when to use this tool versus alternatives like list_chats (which lists chats themselves) or send_message (which sends messages). No exclusion criteria or context for 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?
No annotations are provided, so the description bears full responsibility. It states the tool lists accounts and returns information, but does not explicitly confirm it is a read-only operation or disclose any side effects, auth requirements, or rate limits. For a list tool, the lack of explicit behavioral disclosure is a minor gap.
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 exceptionally concise: two sentences, front-loaded with the action, and every word adds value. No redundancy or fluff.
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?
For a parameterless list tool with no output schema, the description provides sufficient context: it states what the tool does and what information it returns. It could optionally mention that it returns all accounts (no filtering), but that is implied.
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?
There are no parameters, so schema coverage is 100% by default. The description adds meaningful context about the output (account IDs, status, provider), which is valuable since there is no output schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states 'List all connected LinkedIn accounts' and specifies the returned information (account IDs, status, provider). It is a specific verb+resource and is well-distinguished from sibling tools that handle invitations, messages, profiles, etc.
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?
No explicit guidance on when to use this tool versus alternatives. The description implies its use for listing accounts, but does not mention when not to use it or suggest other tools for different contexts.
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?
No annotations are provided, and the description does not disclose behavioral traits such as read-only nature, rate limits, or authentication requirements. It only lists parameters and returns.
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 structured as a clear docstring with Args and Returns sections. Every sentence is informative and necessary, with no redundancy.
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 complexity (6 parameters, 1 required) and no output schema, the description covers all input parameters and mentions the return type (posts with pagination cursor). It is adequate but could include more detail on return fields.
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 significant meaning: it explains each parameter's purpose, provides allowed values for sort_by, date_posted, content_type, and notes the default and range for limit and cursor usage.
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 'Search for LinkedIn posts/content,' which is a specific verb+resource. It distinguishes from sibling tools like search_people and search_companies.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides parameter options (sort_by, date_posted, content_type) that imply usage contexts, but it does not explicitly state when to use this tool versus alternatives. It is clear that it is for posts.
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?
With no annotations, the description carries the burden. It states the tool 'gets' data, implying a read-only operation, but does not explicitly declare safety, authentication requirements, or potential side effects. For a read tool, this is minimally adequate but lacks full transparency.
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 two sentences, front-loading the purpose and listing return contents. No extraneous information, every sentence earns its place.
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?
For a zero-parameter tool with no output schema, the description fully covers what the tool does and what it returns. No gaps remain given the simplicity.
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 zero parameters, so the description does not need to add parameter meaning. Baseline 4 applies as no additional parameter documentation is required.
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 specifies the tool retrieves the authenticated user's LinkedIn profile, with a verb 'Get' and a specific resource. It distinguishes from sibling tool 'get_profile' by emphasizing 'authenticated user's' and 'currently connected account', implying that the sibling retrieves other profiles.
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 when needing the current user's full profile, but provides no explicit guidance on when to use this tool versus alternatives like 'get_profile' or 'search_people'. No when-not-to-use 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?
No annotations provided, so description carries full burden. It describes pagination via cursor and basic search behavior, but does not disclose rate limits, authentication needs, or potential side effects. Adequate for a read-only tool.
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?
Description is well-structured with Args and Returns sections, front-loaded with purpose. Slightly verbose but every sentence adds value.
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 no output schema, description explains returns ('Search results with profiles and pagination cursor'). All parameters described. Sibling tools provide context. Missing details like result count limits or error handling.
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 coverage is 0%, so description compensates well. It provides meaningful descriptions for all 9 parameters (e.g., 'Keywords: Free text search', 'network_distance: Connection degree [1,2,3]'), adding context beyond schema types and defaults.
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 'Search for people on LinkedIn using Classic LinkedIn filters', specifying the verb and resource. It distinguishes from siblings like 'search_companies' and 'search_people_sales_nav' by mentioning 'Classic LinkedIn filters', implying standard search.
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?
Description guides use of 'get_search_params()' to find valid IDs for filters, provides parameter details, and states 'This is the standard LinkedIn search available to all users.' It gives context but lacks explicit when-not-to-use vs. siblings.
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?
With no annotations provided, the description carries the full burden. It states it declines an invitation and returns confirmation, but omits details like side effects (e.g., removal from list), authentication needs, or rate limits. For a simple tool, this is adequate but not comprehensive.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is extremely concise—one sentence for purpose, then an Args section. Every word earns its place, and the structure is front-loaded with the action.
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 simplicity (one parameter, no output schema), the description is sufficiently complete. It covers the action, parameter meaning, and expected outcome. Minimal gaps exist, such as not specifying the exact return format, but not critical.
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?
Although schema description coverage is 0%, the description adds meaningful context for the only parameter: 'invitation_id: The ID of the invitation to decline (from list_invitations_received).' This explains where to obtain the value, going beyond the bare schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose: 'Decline a received connection request.' It uses a specific verb (decline) and resource (invitation), distinguishing it from sibling tools like accept_invitation and cancel_invitation.
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 noting the invitation_id should come from list_invitations_received. However, it doesn't explicitly contrast with accept_invitation or cancel_invitation, nor does it state when not to use it. Still, the intent is clear given sibling names.
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?
No annotations are provided, so the description bears full burden. It describes the return as 'Full profile data including requested sections' and notes that omitting sections returns all. However, it does not explicitly state that the operation is read-only or mention any authentication or error conditions.
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 well-structured with Args and Returns sections, concise, and includes all necessary details without redundancy. Every sentence adds value.
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 simplicity (2 params, no output schema), the description is fairly complete. It explains the return type and parameter details. Minor gap: it could differentiate from get_my_profile more explicitly, but overall sufficient.
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 description adds significant meaning beyond the schema: it explains that provider_id comes from search results or profile URL, and it lists all available section options. Since schema description coverage is 0%, the description fully compensates.
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 purpose: 'Get a LinkedIn user's full profile by their provider ID.' It uses a specific verb ('Get') and resource ('full profile'), and distinguishes from sibling tools like get_my_profile (for own profile) and get_company_profile.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description specifies when to use: 'by their provider ID (from search results or profile URL).' It provides context but does not explicitly exclude alternative tools like get_my_profile or search_people.
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?
No annotations provided, so description carries full burden. It describes parameters and return values, including pagination, but does not disclose potential side effects, rate limits, or authentication requirements. Lacks depth for a complete behavioral picture.
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?
Description is concise with a brief purpose, a practical usage hint, and a clean Args/Returns format. Every sentence adds value, and the structure is front-loaded for quick comprehension.
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?
Covers all 8 parameters and explains return value (search results and pagination cursor). Lacks explicit mention of search scope (e.g., worldwide vs. regional) or edge cases, but is sufficient for an agent to use the tool effectively.
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?
Input schema has 0% parameter descriptions, but the description's Args section compensates fully by explaining each parameter's purpose (keywords, industry, location, headcount filters, has_job_offers, limit, cursor). This adds significant meaning beyond the schema's types and defaults.
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?
Description clearly states 'Search for companies on LinkedIn', specifying the action and target. It distinguishes from sibling tools like search_people and search_posts which have different targets.
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?
Provides explicit instruction to use get_search_params() for valid industry/location IDs, guiding the agent on prerequisites. Could add more alternatives (e.g., 'for detailed profile, use get_company_profile'), but the context from siblings is adequate.
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?
No annotations are provided, so the description carries full burden. It accurately describes the action as 'withdraw a sent connection request', but does not disclose potential consequences (e.g., if already accepted) or permissions needed.
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?
Three sentences are used efficiently: action, parameter description, and return value. No unnecessary words, and the key information is front-loaded.
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?
With only one required parameter and no output schema, the description fully covers input and output expectations for the simple operation.
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 description explains that invitation_id comes from list_invitations_sent, adding crucial context beyond the schema's type string, guiding the agent to a valid source.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb 'Withdraw' and the resource 'sent connection request', distinguishing it from sibling tools like accept_invitation and decline_invitation which operate on received invitations.
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 specifies that the invitation must be 'sent' and 'not accepted yet', providing clear context. The sibling tool names list accept_invitation and decline_invitation, which imply when not to use this tool.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden. It clearly indicates this is a read-only lookup operation that returns a list of IDs and names. It does not mention potential side effects, rate limits, or authentication requirements, but for a simple lookup tool, the transparency is adequate.
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 well-structured with a brief intro, a clear explanation, a bulleted list of parameter values, and a return description. It is concise yet comprehensive, with no redundant information. Every sentence adds value.
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 simplicity and the absence of complex inputs/outputs, the description is complete. It explains the purpose, parameters, and return value adequately. No output schema is needed as the return description suffices.
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?
Despite the input schema having no descriptions (0% coverage), the tool description provides exhaustive documentation for both parameters: it lists all possible values for param_type (categorized) and explains the optional query parameter with an example. This greatly exceeds the schema and adds crucial meaning.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose: 'Get valid parameter IDs for search filters.' It explains that LinkedIn search filters require IDs, and this tool looks up those IDs. This distinguishes it from sibling tools like search_people or search_companies, which perform actual searches rather than providing lookup IDs.
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 explains the tool's use case: to look up IDs for locations, industries, companies, etc., for search filters. However, it does not explicitly state when not to use the tool or mention alternative tools. The usage context is implied but not fully spelled out.
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?
No annotations are provided, so the description carries the full burden. It explains the tool is read-only and lists results with sender details, but does not cover auth needs, rate limits, or potential empty results. Adequate but not rich.
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 concise with a clear purpose statement, followed by parameter explanations and return type. Every sentence adds value with no unnecessary text.
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?
For a simple list tool with two parameters and no output schema, the description fully covers the purpose, parameters, and return value. It is complete and self-contained.
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 description adds meaning to both parameters: limit is 'Max results per page (default 50)' and cursor is 'Pagination cursor from previous response'. This compensates for the 0% schema description coverage.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool lists 'inbound connection requests awaiting response', specifying the resource and state. This distinguishes it from sibling tools like 'list_invitations_sent' and action tools like 'accept_invitation'.
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 for viewing pending invitations, but does not explicitly provide when-not-to-use or contrast with alternative tools beyond the name. Clear context, no 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?
No annotations provided, so description carries burden. Describes basic behavior (send message) and return value but lacks details on idempotency, rate limits, or constraints like character limits.
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?
Concise, well-structured: main sentence, usage guidance, then arg descriptions. Front-loaded with purpose.
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?
Adequate for a simple two-param tool. Distinguishes from key sibling (start_chat). Return value noted but vague. Could mention prerequisite of existing chat.
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 coverage 0%, but description explains chat_id as ID from list_chats and text as message content, adding meaning beyond schema types. Source for chat_id is helpful.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
Clearly states verb 'send' and resource 'message in existing chat conversation'. Distinguishes from sibling 'start_chat' for new conversations.
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?
Explicitly advises using this for ongoing conversations and alternatives new conversations with 'start_chat'. Provides clear context and when-not-to-use.
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?
No annotations provided, so description must disclose behavior. It mentions return of chat_id, but lacks details on authentication, rate limits, or side effects (e.g., immediate message delivery). Adequate but could be more thorough.
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?
Very concise: purpose, usage, args, returns in few sentences. No redundant information, easy to scan.
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?
Covers all essential aspects for a 2-param tool: purpose, usage guidelines, parameter explanations, return value. Lacks error conditions or validation but sufficient for typical 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 coverage is 0%, so description adds meaning: attendees_ids as 'LinkedIn provider IDs' and text as 'initial message content'. Clear but could specify ID format or constraints.
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?
Description explicitly states the tool starts a new conversation with LinkedIn users, specifically 1st degree connections. It clearly distinguishes from sibling tool send_inmail for non-connections.
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?
Provides explicit guidance: use for 1st degree connections, for 2nd/3rd degree use send_inmail instead. This directly helps agent decide when to invoke.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden. It describes the tool's behavior: requires subscription, accepts various filters, supports pagination via 'limit' and 'cursor', and returns search results with profiles. However, it does not mention error handling (e.g., missing subscription) or rate limits. It adds context beyond the schema but could be more explicit about behavioral traits.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is well-structured with an introductory sentence, a list of arguments with brief explanations, and a return note. It is front-loaded with the tool's purpose and requirement. Though it is somewhat lengthy due to many parameters, each sentence serves a purpose. Minor tightening could be done, but overall it is efficiently organized.
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 15 parameters, no output schema, and no annotations, the description covers purpose, usage, and parameter semantics. It mentions the return (profiles with pagination cursor) but does not detail the profile fields. For a complex tool, it is mostly complete, but missing output schema details is a gap. Still, it adequately informs the agent.
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% description coverage, so the description must compensate. It provides brief explanations for all 15 parameters, including examples for complex ones like 'tenure' and 'company_headcount'. While most parameters are clarified, some (e.g., 'network_distance') lack detailed meaning of numeric values. Overall, it adds significant value over the schema titles.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool searches for people using LinkedIn Sales Navigator with advanced filters, distinguishing it from sibling tool 'search_people' which uses standard LinkedIn search. The verb 'search' and resource 'people' are explicit, and the unique scope (Sales Nav) is highlighted.
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 specifies prerequisites (Sales Nav subscription), explains when to use this over alternatives (advanced filters not in Classic LinkedIn), and directs users to 'get_search_params()' to obtain valid filter IDs. This provides explicit guidance on when and how to use the tool, as well as when not to (if lacking subscription).
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Discloses limitations (character and daily limits) and return type (confirmation or error). No annotations, so description carries the burden well.
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?
Highly concise, with action first, then notes, then parameter descriptions. 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?
Adequate for a simple 2-param tool. Covers purpose, limitations, params, and return type. Could mention how to obtain provider_id, but not necessary.
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?
With 0% schema coverage, description fully explains both parameters: provider_id as LinkedIn ID and message as optional with max 300 chars.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
Clearly states the action: 'Send a connection request to a LinkedIn user.' Differentiates from siblings like accept_invitation and cancel_invitation.
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?
Provides practical constraints: character limit and daily limits. Does not explicitly mention when not to use, but context of sibling tools helps.
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:

[![unipile-linkedin-mcp MCP server](https://glama.ai/mcp/servers/bhaktatejas922/unipile-linkedin-mcp/badges/card.svg)](https://glama.ai/mcp/servers/bhaktatejas922/unipile-linkedin-mcp)

Score Badge

Copy to your README.md:

[![unipile-linkedin-mcp MCP server](https://glama.ai/mcp/servers/bhaktatejas922/unipile-linkedin-mcp/badges/score.svg)](https://glama.ai/mcp/servers/bhaktatejas922/unipile-linkedin-mcp)

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/bhaktatejas922/unipile-linkedin-mcp'

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