Skip to main content
Glama
ertiqah
by ertiqah

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
NameRequiredDescriptionDefault

No arguments

Implementation Reference

  • 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 
            });
        }
  • 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';
Behavior2/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so the description carries full burden. It mentions 'Force a refresh' suggesting a write/mutation operation, but doesn't disclose behavioral traits like permissions required, rate limits, whether it's idempotent, or what the refresh entails (e.g., overwriting cached data). Minimal context beyond the basic action.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

Single sentence, front-loaded with the core action, zero waste. Every word contributes to understanding the tool's purpose efficiently.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness2/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given no annotations, no output schema, and a mutation-like operation ('Force a refresh'), the description is incomplete. It lacks details on what the refresh does (e.g., updates cache, triggers sync), expected outcomes, error conditions, or dependencies, leaving significant gaps for agent usage.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters4/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The tool has 0 parameters with 100% schema description coverage, so no parameter documentation is needed. The description doesn't add parameter details, but this is appropriate given the absence of parameters, meeting the baseline for zero-param tools.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose4/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the action ('Force a refresh') and target resource ('LinkedIn posts data'), with a specific goal ('to capture recently published content'). It distinguishes from siblings like 'get_linkedin_posts' by emphasizing forced refresh rather than retrieval, but doesn't explicitly contrast with 'refresh_linkedin_profile'.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines2/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

No explicit guidance on when to use this tool versus alternatives like 'get_linkedin_posts' or 'refresh_linkedin_profile'. The phrase 'to capture recently published content' implies usage when fresh data is needed, but lacks context on frequency, prerequisites, or exclusions.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Install Server

Other Tools

Latest Blog Posts

MCP directory API

We provide all the information about MCP servers via our MCP API.

curl -X GET 'https://glama.ai/api/mcp/v1/servers/ertiqah/linkedin-mcp-runner'

If you have feedback or need assistance with the MCP directory API, please join our Discord server