fetch_person

Instructions

Implementation Reference

• src/tools/fetch-person.ts:7-145 (handler)

  The FetchPersonTool class defines the 'fetch_person' tool. It extends OperationTool which handles execution via linkedapi operations. The schema defines input params (personUrl required, optional retrieve flags for experience/education/skills/languages/posts/comments/reactions with configs). The getTool() returns the MCP Tool definition with name and inputSchema.

  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'],
        },
      };
    }
  }

• src/tools/fetch-person.ts:10-37 (schema)

  Zod schema defining input validation for fetch_person. personUrl is required; optional boolean flags control retrieval of experience, education, skills, languages, posts, comments, reactions (default false). Posts/comments/reactions have optional config objects with limit (1-20) and since (ISO 8601 string).

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

• src/linked-api-tools.ts:47-78 (registration)

  FetchPersonTool is instantiated and registered in the LinkedApiTools constructor's tools array, making it available alongside all other MCP tools.

  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/utils/linked-api-tool.ts:36-58 (helper)

  OperationTool is the base class that FetchPersonTool extends. It provides the execute() method which finds the matching LinkedApi operation by operationName (OPERATION_NAME.fetchPerson) and runs it with progress tracking via executeWithProgress.

  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/linked-api-server.ts:22-26 (registration)

  LinkedApiMCPServer.getTools() maps all tools (including FetchPersonTool) to MCP Tool definitions by calling getTool(), and returns them for the ListTools request handler.

  public getTools(): Tool[] {
    const linkedApiTools = this.tools.tools.map((tool) => tool.getTool());
    const adminTools = this.tools.adminTools.map((tool) => tool.getTool());
    return [...linkedApiTools, ...adminTools];
  }