Linked API MCP

Instructions

Implementation Reference

• src/linked-api-tools.ts:31-67 (registration)

  Registration of SearchPeopleTool in the LinkedApiTools class constructor, where it is instantiated and added to the array of available tools.

  export class LinkedApiTools {
    public readonly tools: ReadonlyArray<LinkedApiTool<unknown, unknown>>;
  
    constructor(progressCallback: (progress: LinkedApiProgressNotification) => void) {
      this.tools = [
        // Standard tools
        new SendMessageTool(progressCallback),
        new GetConversationTool(progressCallback),
        new CheckConnectionStatusTool(progressCallback),
        new RetrieveConnectionsTool(progressCallback),
        new SendConnectionRequestTool(progressCallback),
        new WithdrawConnectionRequestTool(progressCallback),
        new RetrievePendingRequestsTool(progressCallback),
        new RemoveConnectionTool(progressCallback),
        new SearchCompaniesTool(progressCallback),
        new SearchPeopleTool(progressCallback),
        new FetchCompanyTool(progressCallback),
        new FetchPersonTool(progressCallback),
        new FetchPostTool(progressCallback),
        new ReactToPostTool(progressCallback),
        new CommentOnPostTool(progressCallback),
        new CreatePostTool(progressCallback),
        new RetrieveSSITool(progressCallback),
        new RetrievePerformanceTool(progressCallback),
        // Sales Navigator tools
        new NvSendMessageTool(progressCallback),
        new NvGetConversationTool(progressCallback),
        new NvSearchCompaniesTool(progressCallback),
        new NvSearchPeopleTool(progressCallback),
        new NvFetchCompanyTool(progressCallback),
        new NvFetchPersonTool(progressCallback),
        // Other tools
        new ExecuteCustomWorkflowTool(progressCallback),
        new GetWorkflowResultTool(progressCallback),
        new GetApiUsageTool(progressCallback),
      ];
    }

• src/tools/search-people.ts:7-97 (handler)

  The SearchPeopleTool class defines the tool name 'search_people', schema for validation, MCP tool definition via getTool(), and delegates execution to the base OperationTool using operationName 'searchPeople' from linkedapi-node.

  export class SearchPeopleTool extends OperationTool<TSearchPeopleParams, unknown> {
    public override readonly name = 'search_people';
    public override readonly operationName = OPERATION_NAME.searchPeople;
    protected override readonly schema = z.object({
      term: z.string().optional(),
      limit: z.number().min(1).max(1000).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(),
          currentCompanies: z.array(z.string()).optional(),
          previousCompanies: z.array(z.string()).optional(),
          schools: z.array(z.string()).optional(),
        })
        .optional(),
    });
  
    public override getTool(): Tool {
      return {
        name: this.name,
        description:
          'Allows you to search people applying various filtering criteria (st.searchPeople action).',
        inputSchema: {
          type: 'object',
          properties: {
            term: {
              type: 'string',
              description: 'Optional. Keyword or phrase to search.',
            },
            limit: {
              type: 'number',
              description:
                'Optional. Number of search results to return. Defaults to 10, with a maximum value of 1000.',
            },
            filter: {
              type: 'object',
              description:
                'Optional. Object that specifies filtering criteria for people. When multiple filter fields are specified, they are combined using AND logic.',
              properties: {
                firstName: {
                  type: 'string',
                  description: 'Optional. First name of person.',
                },
                lastName: {
                  type: 'string',
                  description: 'Optional. Last name of person.',
                },
                position: {
                  type: 'string',
                  description: 'Optional. Job position of person.',
                },
                locations: {
                  type: 'array',
                  description:
                    'Optional. Array of free-form strings representing locations. Matches if person is located in any of the listed locations.',
                  items: { type: 'string' },
                },
                industries: {
                  type: 'array',
                  description:
                    'Optional. Array of enums representing industries. Matches if person works in any of the listed industries. Takes specific values available in the LinkedIn interface.',
                  items: { type: 'string' },
                },
                currentCompanies: {
                  type: 'array',
                  description:
                    'Optional. Array of company names. Matches if person currently works at any of the listed companies.',
                  items: { type: 'string' },
                },
                previousCompanies: {
                  type: 'array',
                  description:
                    'Optional. Array of company names. Matches if person previously worked at any of the listed companies.',
                  items: { type: 'string' },
                },
                schools: {
                  type: 'array',
                  description:
                    'Optional. Array of institution names. Matches if person currently attends or previously attended any of the listed institutions.',
                  items: { type: 'string' },
                },
              },
            },
          },
        },
      };
    }
  }

• src/utils/linked-api-tool.ts:36-58 (handler)

  Base OperationTool class providing the core execute method for all operation-based tools, including search_people. It locates the specific operation by name and executes it with progress tracking.

  export abstract class OperationTool<TParams, TResult> extends LinkedApiTool<TParams, TResult> {
    public abstract readonly operationName: TOperationName;
  
    public override execute({
      linkedapi,
      args,
      workflowTimeout,
      progressToken,
    }: {
      linkedapi: LinkedApi;
      args: TParams;
      workflowTimeout: number;
      progressToken?: string | number;
    }): Promise<TMappedResponse<TResult>> {
      const operation = linkedapi.operations.find(
        (operation) => operation.operationName === this.operationName,
      )! as Operation<TParams, TResult>;
      return executeWithProgress(this.progressCallback, operation, workflowTimeout, {
        params: args,
        progressToken,
      });
    }
  }

• src/tools/search-people.ts:10-25 (schema)

  Zod schema defining the input parameters for the search_people tool, matching TSearchPeopleParams from linkedapi-node.

  protected override readonly schema = z.object({
    term: z.string().optional(),
    limit: z.number().min(1).max(1000).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(),
        currentCompanies: z.array(z.string()).optional(),
        previousCompanies: z.array(z.string()).optional(),
        schools: z.array(z.string()).optional(),
      })
      .optional(),
  });