Linked API MCP

Instructions

Implementation Reference

• src/tools/retrieve-connections.ts:11-99 (handler)

  The RetrieveConnectionsTool class defines the tool implementation, including the name 'retrieve_connections', operationName, Zod input schema for validation, detailed inputSchema for the Tool interface, and description.

  export class RetrieveConnectionsTool extends OperationTool<
    TRetrieveConnectionsParams,
    TRetrieveConnectionsResult[]
  > {
    public override readonly name = 'retrieve_connections';
    public override readonly operationName = OPERATION_NAME.retrieveConnections;
    protected override readonly schema = z.object({
      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 retrieve your connections and perform additional person-related actions if needed (st.retrieveConnections action).',
        inputSchema: {
          type: 'object',
          properties: {
            limit: {
              type: 'number',
              description:
                'Optional. Number of connections 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/linked-api-tools.ts:34-67 (registration)

  The LinkedApiTools class constructor instantiates RetrieveConnectionsTool (line 40) and registers it in the readonly tools array.

  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/retrieve-connections.ts:17-31 (schema)

  Zod schema for validating the input parameters of the retrieve_connections tool: optional limit and detailed filter object.

  protected override readonly schema = z.object({
    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(),
  });

• src/utils/linked-api-tool.ts:39-58 (helper)

  The execute method from the base OperationTool class, inherited by RetrieveConnectionsTool, which locates the specific retrieveConnections operation and executes it with progress reporting.

    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,
      });
    }
  }