refresh_linkedin_posts

Refresh LinkedIn posts data to capture recently published content for up-to-date analysis.

Instructions

Force a refresh of LinkedIn posts data to capture recently published content.

Input Schema

TableJSON Schema

Name	Required	Description	Default
No arguments

Implementation Reference

cli.js:1088-1172 (handler)

The main handler function for the 'refresh_linkedin_posts' tool within the 'tools/call' method. It authenticates with the API key, makes a POST request to the backend refresh-posts endpoint, and handles success/error responses by sending appropriate MCP responses.

} else if (name === 'refresh_linkedin_posts') {
    console.error(`${packageName}: Received call for refresh_linkedin_posts tool.`);
    const apiKey = process.env.LINKEDIN_MCP_API_KEY;

    if (!apiKey) {
        sendResponse({ jsonrpc: "2.0", error: { code: -32001, message: "Server Configuration Error: API Key not set." }, id });
        return;
    }

    try {
        const headers = { "Authorization": `Bearer ${apiKey}`, "Content-Type": "application/json", "Accept": "application/json" };
        console.error(`${packageName}: Calling refresh LinkedIn posts API: ${backendLinkedinRefreshPostsApiUrl}`);
        const apiResponse = await axios.post(backendLinkedinRefreshPostsApiUrl, {}, { headers, timeout: 60000 });
        console.error(`${packageName}: Refresh LinkedIn posts API response status: ${apiResponse.status}`);
        console.error(`${packageName}: Refresh LinkedIn posts API response data:`, JSON.stringify(apiResponse.data, null, 2));

        if (apiResponse.data && apiResponse.data.success) {
            sendResponse({ 
              jsonrpc: "2.0", 
              result: { 
                content: [
                  {
                    type: "text",
                    text: apiResponse.data.message || "Successfully refreshed LinkedIn posts data."
                  }
                ],
                isError: false
              }, 
              id 
            });
        } else {
            const errorMessage = apiResponse.data?.error || "Backend API Error (no detail)";
            console.error(`${packageName}: Refresh LinkedIn posts API Error: ${errorMessage}`);
            sendResponse({ 
              jsonrpc: "2.0", 
              result: {
                content: [
                  {
                    type: "text",
                    text: `Failed to refresh LinkedIn posts: ${errorMessage}`
                  }
                ],
                isError: true
              }, 
              id 
            });
        }

    } catch (error) {
        let errorMessage = `Failed to call refresh LinkedIn posts API: ${error.message}`;
        if (error.response) {
            // Extract complete error details from the response
            const responseData = error.response.data || {};
            const extractedError = responseData.error || 
                                  responseData.message ||
                                  (typeof responseData === 'string' ? responseData : null);
            
            // Use the backend's full error message
            if (extractedError) {
                errorMessage = extractedError;
            } else {
                // Fallback with a generic message but including the status
                errorMessage = `Backend API Error (Status ${error.response.status}): Unknown error`;
            }
            
            console.error(`${packageName}: Refresh LinkedIn posts API Error Response:`, error.response.data); 
        } else if (error.request) {
            errorMessage = "No response received from refresh LinkedIn posts API.";
        }
        console.error(`${packageName}: ${errorMessage}`);
        
        sendResponse({ 
          jsonrpc: "2.0", 
          result: { 
            content: [
              {
                type: "text",
                text: `Failed to refresh LinkedIn posts: ${errorMessage}`
              }
            ],
            isError: true
          }, 
          id 
        });
    }

cli.js:1364-1370 (schema)

The input schema and description for the 'refresh_linkedin_posts' tool, defined in the 'tools/list' response. No input parameters required.

    name: "refresh_linkedin_posts",
    description: "Force a refresh of LinkedIn posts data to capture recently published content.",
    inputSchema: {
        type: "object",
        properties: {}
    }
}

cli.js:1187-1372 (registration)

The tool is registered in the 'tools/list' method response, where the full list of available tools is returned including 'refresh_linkedin_posts'.

    tools: [
        {
            name: "publish_linkedin_post",
            description: "Publish a text post to LinkedIn, optionally including media (images/videos) specified by URL.",
            inputSchema: {
                type: "object",
                properties: {
                    post_text: {
                        type: "string",
                        description: "The text content of the LinkedIn post."
                    },
                    media: {
                        type: "array",
                        description: "Optional. A list of media items to attach to the post. Each item must have a 'file_url' pointing to a direct image or video URL and a 'filename'.",
                        items: {
                            type: "object",
                            properties: {
                                file_url: {
                                    type: "string",
                                    description: "A direct URL to the image or video file (e.g., ending in .jpg, .png, .mp4)."
                                },
                                filename: {
                                    type: "string",
                                    description: "A filename for the media item (e.g., 'promo_video.mp4')."
                                }
                            },
                            required: ["file_url", "filename"]
                        }
                    }
                },
                required: ["post_text"]
            }
        },
        {
            name: "schedule_linkedin_post",
            description: "Schedule a text post for LinkedIn at a specific future date and time, optionally including media (images/videos) specified by URL.",
            inputSchema: {
                type: "object",
                properties: {
                    post_text: {
                        type: "string",
                        description: "The text content of the LinkedIn post to be scheduled."
                    },
                    scheduled_date: {
                        type: "string",
                        description: "The date and time to publish the post, in ISO 8601 format (e.g., '2025-12-31T10:00:00Z' or '2025-12-31T15:30:00+05:30'). Must be in the future."
                    },
                    media: {
                        type: "array",
                        description: "Optional. A list of media items to attach to the post. Each item must have a 'file_url' pointing to a direct image or video URL and a 'filename'.",
                        items: {
                            type: "object",
                            properties: {
                                file_url: {
                                    type: "string",
                                    description: "A direct URL to the image or video file (e.g., ending in .jpg, .png, .mp4)."
                                },
                                filename: {
                                    type: "string",
                                    description: "A filename for the media item (e.g., 'meeting_notes.mp4')."
                                }
                            },
                            required: ["file_url", "filename"]
                        }
                    }
                },
                required: ["post_text", "scheduled_date"]
            }
        },
        {
            name: "publish_twitter_post",
            description: "Publish a text post (tweet) to Twitter.",
            inputSchema: {
                type: "object",
                properties: {
                    post_text: {
                        type: "string",
                        description: "The text content of the tweet (maximum 280 characters)."
                    }
                },
                required: ["post_text"]
            }
        },
        {
            name: "analyze_linkedin_chat",
            description: "Ask questions about the user's LinkedIn profile, content, or network, with support for multi-turn conversations.",
            inputSchema: {
                type: "object",
                properties: {
                    query: {
                        type: "string",
                        description: "The question or request about LinkedIn data to be analyzed."
                    },
                    conversation_history: {
                        type: "array",
                        description: "Optional. Previous messages in the conversation for context. Each message must have 'role' (user/assistant) and 'content' (text).",
                        items: {
                            type: "object",
                            properties: {
                                role: {
                                    type: "string",
                                    description: "The sender of the message: 'user' or 'assistant'."
                                },
                                content: {
                                    type: "string",
                                    description: "The text content of the message."
                                }
                            },
                            required: ["role", "content"]
                        }
                    }
                },
                required: ["query"]
            }
        },
        {
            name: "generate_linkedin_post",
            description: "Generate three LinkedIn post variants from any content (article, newsletter, notes, etc.) to optimize engagement.",
            inputSchema: {
                type: "object",
                properties: {
                    content: {
                        type: "string",
                        description: "The source content to transform into LinkedIn posts. Can be articles, emails, newsletters, notes, etc."
                    },
                    content_type: {
                        type: "string",
                        description: "Optional. A short description of the content type (e.g., 'article', 'newsletter', 'notes'). Defaults to 'article'."
                    }
                },
                required: ["content"]
            }
        },
        {
            name: "get_linkedin_posts",
            description: "Retrieve the user's recent LinkedIn posts with engagement metrics.",
            inputSchema: {
                type: "object",
                properties: {
                    limit: {
                        type: "number",
                        description: "Optional. Number of posts to retrieve (1-20). Defaults to 5."
                    }
                }
            }
        },
        {
            name: "get_linkedin_profile",
            description: "Retrieve the user's LinkedIn profile information including headline, summary, experience, and education.",
            inputSchema: {
                type: "object",
                properties: {}
            }
        },
        {
            name: "set_linkedin_url",
            description: "Set or update the LinkedIn profile URL to analyze. Required before using profile/posts retrieval tools if not set previously.",
            inputSchema: {
                type: "object",
                properties: {
                    linkedin_url: {
                        type: "string",
                        description: "The full LinkedIn profile URL (e.g., https://www.linkedin.com/in/username/)"
                    }
                },
                required: ["linkedin_url"]
            }
        },
        {
            name: "refresh_linkedin_profile",
            description: "Force a refresh of the LinkedIn profile data to update any recent changes.",
            inputSchema: {
                type: "object",
                properties: {}
            }
        },
        {
            name: "refresh_linkedin_posts",
            description: "Force a refresh of LinkedIn posts data to capture recently published content.",
            inputSchema: {
                type: "object",
                properties: {}
            }
        }
    ]
}

cli.js:20-20 (helper)
Backend API URL constant used by the refresh_linkedin_posts handler to call the refresh-posts endpoint.
```
const backendLinkedinRefreshPostsApiUrl = 'https://ligo.ertiqah.com/api/mcp/linkedin/refresh-posts';
```

LinkedIn MCP Assistant