@linkedapi/mcp 0.3.11

package/src/tools/check-connection-status.ts

@@ -0,0 +1,39 @@
+import {
+  OPERATION_NAME,
+  TCheckConnectionStatusParams,
+  TCheckConnectionStatusResult,
+} from '@linkedapi/node';
+import { Tool } from '@modelcontextprotocol/sdk/types.js';
+import { z } from 'zod';
+
+import { OperationTool } from '../utils/linked-api-tool.js';
+
+export class CheckConnectionStatusTool extends OperationTool<
+  TCheckConnectionStatusParams,
+  TCheckConnectionStatusResult
+> {
+  public override readonly name = 'check_connection_status';
+  public override readonly operationName = OPERATION_NAME.checkConnectionStatus;
+  protected override readonly schema = z.object({
+    personUrl: z.string(),
+  });
+
+  public override getTool(): Tool {
+    return {
+      name: this.name,
+      description:
+        'Allows you to check the connection status between your account and another person (st.checkConnectionStatus action).',
+      inputSchema: {
+        type: 'object',
+        properties: {
+          personUrl: {
+            type: 'string',
+            description:
+              "Public or hashed LinkedIn URL of the person you want to check the connection status with. (e.g., 'https://www.linkedin.com/in/john-doe')",
+          },
+        },
+        required: ['personUrl'],
+      },
+    };
+  }
+}

package/src/tools/comment-on-post.ts

@@ -0,0 +1,42 @@
+import { OPERATION_NAME, TCommentOnPostParams } from '@linkedapi/node';
+import { Tool } from '@modelcontextprotocol/sdk/types.js';
+import { z } from 'zod';
+
+import { OperationTool } from '../utils/linked-api-tool.js';
+
+export class CommentOnPostTool extends OperationTool<TCommentOnPostParams, unknown> {
+  public override readonly name = 'comment_on_post';
+  public override readonly operationName = OPERATION_NAME.commentOnPost;
+  protected override readonly schema = z.object({
+    postUrl: z.string(),
+    text: z.string().min(1),
+    companyUrl: z.string().optional(),
+  });
+
+  public override getTool(): Tool {
+    return {
+      name: this.name,
+      description: 'Allows you to leave a comment on a post (st.commentOnPost action).',
+      inputSchema: {
+        type: 'object',
+        properties: {
+          postUrl: {
+            type: 'string',
+            description:
+              "The LinkedIn post URL to comment on (e.g., 'https://www.linkedin.com/posts/username_activity-id')",
+          },
+          text: {
+            type: 'string',
+            description: 'Comment text, must be up to 1000 characters.',
+          },
+          companyUrl: {
+            type: 'string',
+            description:
+              "LinkedIn company page URL. If specified, the comment will be added on behalf of the company. (e.g., 'https://www.linkedin.com/company/acme-corp')",
+          },
+        },
+        required: ['postUrl', 'text'],
+      },
+    };
+  }
+}

package/src/tools/create-post.ts

@@ -0,0 +1,71 @@
+import { OPERATION_NAME, TCreatePostParams } from '@linkedapi/node';
+import { Tool } from '@modelcontextprotocol/sdk/types.js';
+import { z } from 'zod';
+
+import { OperationTool } from '../utils/linked-api-tool.js';
+
+export class CreatePostTool extends OperationTool<TCreatePostParams, unknown> {
+  public override readonly name = 'create_post';
+  public override readonly operationName = OPERATION_NAME.createPost;
+  protected override readonly schema = z.object({
+    text: z.string().min(1).max(3000),
+    companyUrl: z.string().optional(),
+    attachments: z
+      .array(
+        z.object({
+          url: z.string(),
+          type: z.enum(['image', 'video', 'document']),
+          name: z.string().optional(),
+        }),
+      )
+      .max(9)
+      .optional(),
+  });
+
+  public override getTool(): Tool {
+    return {
+      name: this.name,
+      description:
+        'Creates a new LinkedIn post with optional media attachments (st.createPost action).',
+      inputSchema: {
+        type: 'object',
+        properties: {
+          text: {
+            type: 'string',
+            description: 'Post content, must be up to 3000 characters.',
+          },
+          companyUrl: {
+            type: 'string',
+            description:
+              'LinkedIn company page URL. If specified, the post will be created on the company page (requires admin access).',
+          },
+          attachments: {
+            type: 'array',
+            description:
+              'Media attachments for the post. You can add up to 9 images, or 1 video, or 1 document. Cannot mix different attachment types.',
+            items: {
+              type: 'object',
+              properties: {
+                url: {
+                  type: 'string',
+                  description: 'Publicly accessible URL of the media file.',
+                },
+                type: {
+                  type: 'string',
+                  enum: ['image', 'video', 'document'],
+                  description: 'Type of media attachment.',
+                },
+                name: {
+                  type: 'string',
+                  description: 'Display name for the document (required for documents).',
+                },
+              },
+              required: ['url', 'type'],
+            },
+          },
+        },
+        required: ['text'],
+      },
+    };
+  }
+}

package/src/tools/execute-custom-workflow.ts

@@ -0,0 +1,28 @@
+import { OPERATION_NAME, TWorkflowCompletion, TWorkflowDefinition } from '@linkedapi/node';
+import { Tool } from '@modelcontextprotocol/sdk/types.js';
+import { z } from 'zod';
+
+import { OperationTool } from '../utils/linked-api-tool.js';
+
+export class ExecuteCustomWorkflowTool extends OperationTool<
+  TWorkflowDefinition,
+  TWorkflowCompletion
+> {
+  public override readonly name = 'execute_custom_workflow';
+  public override readonly operationName = OPERATION_NAME.customWorkflow;
+  protected override readonly schema = z.object({
+    definition: z.any(),
+  });
+
+  public override getTool(): Tool {
+    return {
+      name: this.name,
+      description: 'Execute a custom workflow definition',
+      inputSchema: {
+        type: 'object',
+        properties: { definition: { type: 'object' } },
+        required: ['definition'],
+      },
+    };
+  }
+}

package/src/tools/fetch-company.ts

@@ -0,0 +1,154 @@
+import { OPERATION_NAME, TFetchCompanyParams } from '@linkedapi/node';
+import { Tool } from '@modelcontextprotocol/sdk/types.js';
+import { z } from 'zod';
+
+import { OperationTool } from '../utils/linked-api-tool.js';
+
+export class FetchCompanyTool extends OperationTool<TFetchCompanyParams, unknown> {
+  public override readonly name = 'fetch_company';
+  public override readonly operationName = OPERATION_NAME.fetchCompany;
+  protected override readonly schema = z.object({
+    companyUrl: z.string(),
+    retrieveEmployees: z.boolean().optional().default(false),
+    retrievePosts: z.boolean().optional().default(false),
+    retrieveDMs: z.boolean().optional().default(false),
+    postsRetrievalConfig: z
+      .object({
+        limit: z.number().min(1).max(20).optional(),
+        since: z.string().optional(),
+      })
+      .optional(),
+    dmsRetrievalConfig: z
+      .object({
+        limit: z.number().min(1).max(20).optional(),
+      })
+      .optional(),
+    employeesRetrievalConfig: z
+      .object({
+        limit: z.number().min(1).max(500).optional(),
+        filter: z
+          .object({
+            firstName: z.string().optional(),
+            lastName: z.string().optional(),
+            position: z.string().optional(),
+            locations: z.array(z.string()).optional(),
+            industries: z.array(z.string()).optional(),
+            schools: z.array(z.string()).optional(),
+          })
+          .optional(),
+      })
+      .optional(),
+  });
+
+  public override getTool(): Tool {
+    return {
+      name: this.name,
+      description:
+        'Allows you to open a company page to retrieve its basic information (st.openCompanyPage action). Can optionally retrieve employees, posts and decision makers.',
+      inputSchema: {
+        type: 'object',
+        properties: {
+          companyUrl: {
+            type: 'string',
+            description:
+              "Public or hashed LinkedIn URL of the company. (e.g., 'https://www.linkedin.com/company/microsoft')",
+          },
+          retrieveEmployees: {
+            type: 'boolean',
+            description:
+              "Optional. Whether to retrieve the company's employees information. Default is false.",
+          },
+          retrievePosts: {
+            type: 'boolean',
+            description:
+              "Optional. Whether to retrieve the company's posts information. Default is false.",
+          },
+          retrieveDMs: {
+            type: 'boolean',
+            description:
+              "Optional. Whether to retrieve the company's decision makers information. Default is false.",
+          },
+          postsRetrievalConfig: {
+            type: 'object',
+            description:
+              'Optional. Configuration for retrieving posts. Available only if retrievePosts is true.',
+            properties: {
+              limit: {
+                type: 'number',
+                description:
+                  'Optional. Number of posts to retrieve. Defaults to 20, with a maximum value of 20.',
+              },
+              since: {
+                type: 'string',
+                description:
+                  'Optional. ISO 8601 timestamp to filter posts published after the specified time.',
+              },
+            },
+          },
+          dmsRetrievalConfig: {
+            type: 'object',
+            description:
+              'Optional. Configuration for retrieving decision makers. Available only if retrieveDMs is true.',
+            properties: {
+              limit: {
+                type: 'number',
+                description:
+                  'Optional. Number of decision makers to retrieve. Defaults to 20, with a maximum value of 20. If a company has fewer decision makers than specified, only the available ones will be returned.',
+              },
+            },
+          },
+          employeesRetrievalConfig: {
+            type: 'object',
+            description:
+              'Optional. Configuration for retrieving employees. Available only if retrieveEmployees is true.',
+            properties: {
+              limit: {
+                type: 'number',
+                description:
+                  'Optional. Maximum number of employees to retrieve. Defaults to 500, with a maximum value of 500.',
+              },
+              filter: {
+                type: 'object',
+                description:
+                  'Optional. Object that specifies filtering criteria for employees. When multiple filter fields are specified, they are combined using AND logic.',
+                properties: {
+                  firstName: {
+                    type: 'string',
+                    description: 'Optional. First name of employee.',
+                  },
+                  lastName: {
+                    type: 'string',
+                    description: 'Optional. Last name of employee.',
+                  },
+                  position: {
+                    type: 'string',
+                    description: 'Optional. Job position of employee.',
+                  },
+                  locations: {
+                    type: 'array',
+                    description:
+                      'Optional. Array of free-form strings representing locations. Matches if employee is located in any of the listed locations.',
+                    items: { type: 'string' },
+                  },
+                  industries: {
+                    type: 'array',
+                    description:
+                      'Optional. Array of enums representing industries. Matches if employee works in any of the listed industries. Takes specific values available in the LinkedIn interface.',
+                    items: { type: 'string' },
+                  },
+                  schools: {
+                    type: 'array',
+                    description:
+                      'Optional. Array of institution names. Matches if employee currently attends or previously attended any of the listed institutions.',
+                    items: { type: 'string' },
+                  },
+                },
+              },
+            },
+          },
+        },
+        required: ['companyUrl'],
+      },
+    };
+  }
+}

package/src/tools/fetch-person.ts

@@ -0,0 +1,145 @@
+import { OPERATION_NAME, TFetchPersonParams } from '@linkedapi/node';
+import { Tool } from '@modelcontextprotocol/sdk/types.js';
+import { z } from 'zod';
+
+import { OperationTool } from '../utils/linked-api-tool.js';
+
+export class FetchPersonTool extends OperationTool<TFetchPersonParams, unknown> {
+  public override readonly name = 'fetch_person';
+  public override readonly operationName = OPERATION_NAME.fetchPerson;
+  protected override readonly schema = z.object({
+    personUrl: z.string(),
+    retrieveExperience: z.boolean().optional().default(false),
+    retrieveEducation: z.boolean().optional().default(false),
+    retrieveSkills: z.boolean().optional().default(false),
+    retrieveLanguages: z.boolean().optional().default(false),
+    retrievePosts: z.boolean().optional().default(false),
+    retrieveComments: z.boolean().optional().default(false),
+    retrieveReactions: z.boolean().optional().default(false),
+    postsRetrievalConfig: z
+      .object({
+        limit: z.number().min(1).max(20).optional(),
+        since: z.string().optional(),
+      })
+      .optional(),
+    commentsRetrievalConfig: z
+      .object({
+        limit: z.number().min(1).max(20).optional(),
+        since: z.string().optional(),
+      })
+      .optional(),
+    reactionsRetrievalConfig: z
+      .object({
+        limit: z.number().min(1).max(20).optional(),
+        since: z.string().optional(),
+      })
+      .optional(),
+  });
+
+  public override getTool(): Tool {
+    return {
+      name: this.name,
+      description: `Allows you to open a person page to retrieve their basic information and perform additional person-related actions if needed. (st.openPersonPage action). Allows additional optional retrieval of experience, education, skills, languages, posts, comments and reactions.
+⚠️ **PERFORMANCE WARNING**: Only set additional retrieval flags to true if you specifically need that data. Each additional parameter significantly increases execution time:
+💡 **Recommendation**: Start with basic info only. Only request additional data if the user explicitly asks for it or if it's essential for the current task.
+`,
+      inputSchema: {
+        type: 'object',
+        properties: {
+          personUrl: {
+            type: 'string',
+            description:
+              "The LinkedIn profile URL of the person to fetch (e.g., 'https://www.linkedin.com/in/john-doe')",
+          },
+          retrieveExperience: {
+            type: 'boolean',
+            description:
+              "Optional. Whether to retrieve the person's experience information. Default is false.",
+          },
+          retrieveEducation: {
+            type: 'boolean',
+            description:
+              "Optional. Whether to retrieve the person's education information. Default is false.",
+          },
+          retrieveSkills: {
+            type: 'boolean',
+            description:
+              "Optional. Whether to retrieve the person's skills information. Default is false.",
+          },
+          retrieveLanguages: {
+            type: 'boolean',
+            description:
+              "Optional. Whether to retrieve the person's languages information. Default is false.",
+          },
+          retrievePosts: {
+            type: 'boolean',
+            description:
+              "Optional. Whether to retrieve the person's posts information. Default is false.",
+          },
+          retrieveComments: {
+            type: 'boolean',
+            description:
+              "Optional. Whether to retrieve the person's comments information. Default is false.",
+          },
+          retrieveReactions: {
+            type: 'boolean',
+            description:
+              "Optional. Whether to retrieve the person's reactions information. Default is false.",
+          },
+          postsRetrievalConfig: {
+            type: 'object',
+            description:
+              'Optional. Configuration for retrieving posts. Available only if retrievePosts is true.',
+            properties: {
+              limit: {
+                type: 'number',
+                description:
+                  'Optional. Number of posts to retrieve. Defaults to 20, with a maximum value of 20.',
+              },
+              since: {
+                type: 'string',
+                description:
+                  'Optional. ISO 8601 timestamp to filter posts published after the specified time.',
+              },
+            },
+          },
+          commentsRetrievalConfig: {
+            type: 'object',
+            description:
+              'Optional. Configuration for retrieving comments. Available only if retrieveComments is true.',
+            properties: {
+              limit: {
+                type: 'number',
+                description:
+                  'Optional. Number of comments to retrieve. Defaults to 20, with a maximum value of 20.',
+              },
+              since: {
+                type: 'string',
+                description:
+                  'Optional. ISO 8601 timestamp to filter comments made after the specified time.',
+              },
+            },
+          },
+          reactionsRetrievalConfig: {
+            type: 'object',
+            description:
+              'Optional. Configuration for retrieving reactions. Available only if retrieveReactions is true.',
+            properties: {
+              limit: {
+                type: 'number',
+                description:
+                  'Optional. Number of reactions to retrieve. Defaults to 20, with a maximum value of 20.',
+              },
+              since: {
+                type: 'string',
+                description:
+                  'Optional. ISO 8601 timestamp to filter reactions made after the specified time.',
+              },
+            },
+          },
+        },
+        required: ['personUrl'],
+      },
+    };
+  }
+}

package/src/tools/fetch-post.ts

@@ -0,0 +1,90 @@
+import { OPERATION_NAME, TFetchPostParams } from '@linkedapi/node';
+import { Tool } from '@modelcontextprotocol/sdk/types.js';
+import { z } from 'zod';
+
+import { OperationTool } from '../utils/linked-api-tool.js';
+
+export class FetchPostTool extends OperationTool<TFetchPostParams, unknown> {
+  public override readonly name = 'fetch_post';
+  public override readonly operationName = OPERATION_NAME.fetchPost;
+  protected override readonly schema = z.object({
+    postUrl: z.string(),
+    retrieveComments: z.boolean().optional(),
+    retrieveReactions: z.boolean().optional(),
+    commentsRetrievalConfig: z
+      .object({
+        limit: z.number().min(1).max(500).optional(),
+        replies: z.boolean().optional(),
+        sort: z.enum(['mostRelevant', 'mostRecent']).optional(),
+      })
+      .optional(),
+    reactionsRetrievalConfig: z
+      .object({
+        limit: z.number().min(1).max(1000).optional(),
+      })
+      .optional(),
+  });
+
+  public override getTool(): Tool {
+    return {
+      name: this.name,
+      description:
+        'Open a LinkedIn post and retrieve its data, with optional comments and reactions. (st.openPost action).',
+      inputSchema: {
+        type: 'object',
+        properties: {
+          postUrl: {
+            type: 'string',
+            description:
+              "LinkedIn URL of the post. (e.g., 'https://www.linkedin.com/posts/username_activity-id')",
+          },
+          retrieveComments: {
+            type: 'boolean',
+            description:
+              'Optional. When true, also retrieve comments for the post. Configure via commentsRetrievalConfig.',
+          },
+          retrieveReactions: {
+            type: 'boolean',
+            description:
+              'Optional. When true, also retrieve reactions for the post. Configure via reactionsRetrievalConfig.',
+          },
+          commentsRetrievalConfig: {
+            type: 'object',
+            description:
+              'Optional. Applies only when retrieveComments is true. Controls comments retrieval (limit, replies, sort).',
+            properties: {
+              limit: {
+                type: 'number',
+                description:
+                  'Optional. Max number of comments to retrieve. Defaults to 10, with a maximum value of 500.',
+              },
+              replies: {
+                type: 'boolean',
+                description: 'Optional. When true, include replies to comments (threaded).',
+              },
+              sort: {
+                type: 'string',
+                enum: ['mostRelevant', 'mostRecent'],
+                description:
+                  "Optional. Sort order for comments. One of 'mostRelevant' or 'mostRecent'.",
+              },
+            },
+          },
+          reactionsRetrievalConfig: {
+            type: 'object',
+            description:
+              'Optional. Applies only when retrieveReactions is true. Controls reactions retrieval (limit).',
+            properties: {
+              limit: {
+                type: 'number',
+                description:
+                  'Optional. Max number of reactions to retrieve. Defaults to 10, with a maximum value of 1000.',
+              },
+            },
+          },
+        },
+        required: ['postUrl'],
+      },
+    };
+  }
+}

package/src/tools/get-api-usage-stats.ts

@@ -0,0 +1,48 @@
+import LinkedApi, { TApiUsageAction, TApiUsageParams, TMappedResponse } from '@linkedapi/node';
+import { Tool } from '@modelcontextprotocol/sdk/types.js';
+import z from 'zod';
+
+import { LinkedApiTool } from '../utils/linked-api-tool.js';
+
+export class GetApiUsageTool extends LinkedApiTool<TApiUsageParams, TApiUsageAction[]> {
+  public readonly name = 'get_api_usage';
+  protected readonly schema = z.object({
+    start: z.string(),
+    end: z.string(),
+  });
+
+  public override async execute({
+    linkedapi,
+    args,
+  }: {
+    linkedapi: LinkedApi;
+    args: TApiUsageParams;
+    workflowTimeout: number;
+    progressToken?: string | number;
+  }): Promise<TMappedResponse<TApiUsageAction[]>> {
+    return await linkedapi.getApiUsage(args);
+  }
+
+  public override getTool(): Tool {
+    return {
+      name: this.name,
+      description: 'Retrieve Linked API usage statistics. Date range must not exceed 30 days.',
+      inputSchema: {
+        type: 'object',
+        properties: {
+          start: {
+            type: 'string',
+            description:
+              "Start date for the statistics period in ISO 8601 format (e.g., '2024-01-01T00:00:00Z')",
+          },
+          end: {
+            type: 'string',
+            description:
+              "End date for the statistics period in ISO 8601 format (e.g., '2024-01-30T00:00:00Z')",
+          },
+        },
+        required: ['start', 'end'],
+      },
+    };
+  }
+}