Click on "Install Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type @ followed by the MCP server name and your instructions, e.g., "@was-fb-mcp List all Facebook Pages I manage."
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
was-fb-mcp)Shareable Facebook & Meta Graph API Model Context Protocol (MCP) server. Exposes 10 powerful tools to manage Facebook Pages, Posts, Comments, Ad Accounts, Campaigns, Insights, and execute any raw Graph API request from your favorite AI coding assistant (Claude Desktop, Cursor, Google Antigravity, VS Code, Zed).
Node.js 18+
A Facebook / Meta Account & Meta Developer App
A Facebook User Access Token or Page Access Token (generated via Meta for Developers Graph API Explorer)
Related MCP server: Facebook MCP Server
Select your App and click Generate Access Token.
Grant permissions such as pages_show_list, pages_read_engagement, pages_manage_posts, ads_read, read_insights.
Run the interactive setup command in your terminal:
npx -y github:was-member-keramat/was-fb-mcp authPaste your Access Token when prompted. Credentials will be securely saved locally to ~/.was-fb-mcp/config.json with restricted file permissions (0600).
Add the following 4 lines to your AI tool's MCP configuration (claude_desktop_config.json, mcp_config.json, etc.):
{
"mcpServers": {
"Facebook MCP": {
"command": "npx",
"args": ["-y", "github:was-member-keramat/was-fb-mcp"]
}
}
}Here are example prompts you can use with your AI assistant:
Discovery: "List all Facebook Pages I manage."
Content Creation: "Publish a new post to my Page with ID 100123456 saying 'Hello World!'."
Feed & Comments: "Show the latest 10 posts on my Page feed and list the comments on the top post."
Interaction: "Reply to comment ID 987654321 with 'Thank you for your feedback!'."
Ads Management: "List my Meta Ad Accounts and show active campaigns in act_123456789."
Analytics: "Get post engagement insights for Page 100123456."
Universal Access: "Use fb_api to GET v19.0/me/photos."
Category | Tool | Description |
Account |
| Get details of authenticated user / token owner |
Pages |
| List Facebook Pages managed by user |
Feed & Posts |
| Publish a post on a Facebook Page feed |
Feed & Posts |
| Fetch recent posts from a Page feed |
Comments |
| Get comments on a Facebook post |
Comments |
| Post a comment or reply to a post/comment |
Meta Ads |
| List accessible Meta Ad accounts |
Meta Ads |
| List ad campaigns in an Ad Account |
Analytics |
| Fetch metrics/insights for Page or Ad Account |
Universal |
| Execute raw GET/POST/DELETE Graph API calls |
# Connect / re-connect credentials
npx -y github:was-member-keramat/was-fb-mcp auth
# Check saved configuration status
npx -y github:was-member-keramat/was-fb-mcp status
# Delete saved credentials
npx -y github:was-member-keramat/was-fb-mcp logout
# View CLI usage help
npx -y github:was-member-keramat/was-fb-mcp helpYou can bypass the local config file by passing environment variables in your AI client config:
{
"mcpServers": {
"Facebook Account A": {
"command": "npx",
"args": ["-y", "github:was-member-keramat/was-fb-mcp"],
"env": {
"FB_ACCESS_TOKEN": "EAAX..."
}
},
"Facebook Account B": {
"command": "npx",
"args": ["-y", "github:was-member-keramat/was-fb-mcp"],
"env": {
"FB_ACCESS_TOKEN": "EAAY..."
}
}
}
}If you see:
File C:\...\npx.ps1 cannot be loaded because running scripts is disabled
Run in PowerShell:
Set-ExecutionPolicy -Scope CurrentUser -ExecutionPolicy RemoteSignedIf npx is serving cached old versions:
Remove-Item -Recurse -Force "$env:LOCALAPPDATA\npm-cache" -ErrorAction SilentlyContinue
npm cache clean --forceIf a tool call returns an error, the MCP decodes Meta Graph API's exact error structure (code, error_subcode, fbtrace_id) so the AI assistant can fix permissions or parameters immediately.
MIT © 2026 WAS.
Universal Graph API tool. Execute any GET, POST, or DELETE request on Facebook Graph API endpoints directly.
| Name | Required | Description | Default |
|---|---|---|---|
| body | No | JSON body payload for POST requests | |
| path | Yes | API endpoint path (e.g. "me/friends", "v19.0/123456/photos") | |
| token | No | Optional override Access Token (e.g., Page Access Token) | |
| method | No | HTTP Method: GET, POST, or DELETE | GET |
| params | No | Query parameters object |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations exist, so description bears full burden. It fails to disclose critical behaviors like rate limits, authentication requirements, or that DELETE requests are destructive. Minimal transparency for a powerful tool.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Very concise at two sentences, front-loaded with 'Universal Graph API tool'. However, it could be slightly more structured with bullet points for clarity.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given no output schema and the tool's generic nature, the description should explain response format or common patterns. It also lacks warnings about destructive operations. Incomplete for safe agent usage.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100% with descriptive names, so the description adds no extra meaning. Baseline of 3 is appropriate as schema already documents all parameters adequately.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states it is a universal tool for executing GET, POST, DELETE requests on Facebook Graph API endpoints. It distinguishes from specific sibling tools like fb_create_post or fb_reply_comment by being a generic interface.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Usage is implied as a generic fallback for any Graph API operation not covered by specialized tools, but no explicit when-to-use or when-to-avoid guidance is provided.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Create a new post on a Facebook Page feed.
| Name | Required | Description | Default |
|---|---|---|---|
| link | No | Optional URL link to attach | |
| pageId | Yes | Facebook Page ID | |
| message | Yes | Post message text content | |
| pageToken | No | Optional Page Access Token (if posting on behalf of a Page) |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided, so description carries full burden. Only states 'create a new post' without disclosing authentication requirements (pageToken), rate limits, or post behavior (e.g., visibility, scheduling).
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Single sentence is concise but too terse; it under-specifies and could benefit from additional critical details without being verbose.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Very incomplete: no output schema, no annotations, and minimal description. Fails to provide authentication context (pageToken), error handling, or relationship to sibling tools.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so description adds no extra meaning. It does not clarify edge cases or relationships between parameters (e.g., link vs. message). Baseline of 3 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action (create) and resource (new post on Facebook Page feed), but does not differentiate from siblings like fb_get_page_feed or fb_reply_comment, which could cause confusion.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance on when to use this tool versus alternatives (e.g., creating a post vs. replying or listing). No mention of prerequisites or limitations.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Get metrics and insights for a Facebook Page, Post, or Ad Account.
| Name | Required | Description | Default |
|---|---|---|---|
| metric | Yes | Comma-separated list of metrics (e.g. "page_impressions,page_engagements") | |
| period | No | Period (day, week, days_28, month, lifetime) | |
| objectId | Yes | Page ID, Post ID, or Ad Account ID |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided, and the description does not disclose behavioral traits such as read-only nature, rate limits, or permission requirements. The description only states the function without depth.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Single sentence, 13 words, efficiently conveys the core action. However, it is too brief and could benefit from structure like bullet points or additional clarification.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
No output schema, no annotations, and minimal description. The tool has 3 parameters and returns data, but the description does not explain the response format, error handling, or any advanced details.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the baseline is 3. The description does not add substantial meaning beyond the schema; it merely restates the parameter purposes without new context.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
Description clearly states the tool retrieves metrics and insights for a Facebook Page, Post, or Ad Account. It specifies the resource types, making its purpose identifiable, though it could be more specific about the types of metrics.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance on when to use this tool versus sibling tools like fb_list_campaigns or fb_get_page_feed. The description does not mention prerequisites or alternatives.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Get details of the currently authenticated Facebook User, Page, or Token owner.
| Name | Required | Description | Default |
|---|---|---|---|
| fields | No | Comma-separated fields to request (e.g. "id,name,email,picture") |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided, so the description carries full burden. It fails to disclose behavioral traits such as whether the operation is read-only, rate limits, or required permissions. The description is too minimal to inform the agent about side effects or constraints.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single concise sentence that front-loads the main action. It efficiently communicates the purpose without extraneous words, though it could include more detail without becoming bloated.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool complexity (single optional parameter, no output schema), the description is adequate but not complete. It does not describe return structure or example fields, leaving the agent to guess what 'details' means. A minimal addition would improve completeness.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100% for the single parameter 'fields', and the schema already describes it well. The description adds no additional meaning beyond the schema, which is acceptable given high coverage. Baseline score of 3 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
Description clearly states it retrieves details of the authenticated entity (user, page, or token owner). The verb 'Get' and resource are explicit. While it doesn't differentiate from siblings, the sibling tools have distinct purposes (e.g., fb_reply_comment, fb_list_campaigns), making the distinction clear.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance on when to use this tool versus alternatives. No mention of prerequisites, or situations where other tools (like fb_api) might be preferred. The description lacks context for decision-making.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Fetch recent posts published on a Facebook Page.
| Name | Required | Description | Default |
|---|---|---|---|
| limit | No | Number of posts to fetch (1-100) | |
| pageId | Yes | Facebook Page ID | |
| pageToken | No | Optional Page Access Token |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description must fully convey behavioral traits. It only says 'Fetch', implying read-only, but doesn't state pagination behavior, rate limits, authentication requirements (pageToken is optional per schema but not explained), or whether posts are ordered by time. The lack of detail leaves ambiguity.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single sentence with no extraneous words. It is appropriately concise but could benefit from a note on typical usage or return format without becoming verbose.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
No output schema is provided, and the description does not hint at what the response contains (e.g., an array of post objects with fields like message, created_time). Given the tool's complexity (3 parameters, 10 siblings), more context is needed to make it fully usable.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100%, so the description does not need to explain parameters. However, it adds no extra meaning beyond the schema (e.g., that pageId is a numeric string). The description is too brief to complement the schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool fetches recent posts from a Facebook Page. It uses a specific verb ('Fetch') and identifies the resource ('recent posts published on a Facebook Page'). While it distinguishes from siblings like fb_create_post (create vs fetch), it could be more precise about the scope (only posts, not other feed items).
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance on when to use this tool versus alternatives. Sibling tools like fb_get_post_comments or fb_get_insights exist but are not mentioned. There is no indication of prerequisites, excluded scenarios, or typical use cases.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Get comments on a Facebook post or photo.
| Name | Required | Description | Default |
|---|---|---|---|
| limit | No | Max comments to fetch | |
| postId | Yes | Post ID (e.g. "PAGE_ID_POST_ID") |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description must fully disclose behavioral traits. It only says 'Get comments', omitting important details like pagination, rate limits, auth requirements, or whether it retrieves nested replies. This is insufficient for safe invocation.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence with no redundant information. It could be improved by including a hint about return format, but it is not verbose.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Without an output schema, the description should at least hint at the return structure (e.g., list of comment objects, order). It does not, and combined with no annotations, the overall context is incomplete for a tool that likely returns paginated data.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Both parameters have descriptions in the schema (100% coverage), so the description adds no extra meaning beyond what the schema already provides. Baseline 3 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb 'Get' and resource 'comments on a Facebook post or photo', providing a specific purpose that distinguishes it from sibling tools like fb_reply_comment (reply) and fb_create_post (create).
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description offers no guidance on when to use this tool vs alternatives such as fb_get_page_feed or fb_get_insights, nor does it specify any exclusions or prerequisites.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
List Meta Ad Accounts accessible by the token.
| Name | Required | Description | Default |
|---|---|---|---|
| fields | No | Comma-separated fields (default: "id,name,account_status,currency,balance") |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description bears full responsibility for behavioral disclosure. It only states the core function, omitting details like token requirements, potential empty responses, or any operational constraints.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, clear sentence with no redundant information. It is concise and front-loaded.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given there is no output schema, the description should explain the return format or pagination. It does not, leaving a gap. However, the tool is simple with one parameter, so minimalism is somewhat acceptable.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The single parameter 'fields' has complete schema coverage (100%). The description adds no extra meaning beyond the schema, so a baseline score of 3 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description 'List Meta Ad Accounts accessible by the token.' uses a specific verb ('List') and resource ('Meta Ad Accounts'), clearly stating the tool's function. It distinguishes effectively from sibling tools like fb_list_campaigns and fb_list_pages.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is provided on when to use this tool versus alternatives. There is no mention of scenarios or exclusions, leaving the agent without context for selection.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
List ad campaigns inside a Meta Ad Account.
| Name | Required | Description | Default |
|---|---|---|---|
| limit | No | Max campaigns | |
| adAccountId | Yes | Ad Account ID (e.g. "act_123456789") |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries full burden but only states 'List ad campaigns inside a Meta Ad Account.' It does not disclose whether pagination is handled, rate limits, error behavior, or read-only nature. The implicit read operation is not explicitly marked, and no behavioral traits are mentioned.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, front-loaded sentence that uses no unnecessary words. It efficiently communicates the core function, earning its place with zero waste.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Despite having only 2 parameters and no output schema, the description omits crucial context like whether results are paginated or the format of the returned list. It does not mention the use of the 'limit' parameter for controlling output size, leaving the agent with incomplete information.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100%, so baseline is 3. The description does not add any extra meaning beyond the schema's parameter descriptions. While the schema clearly describes 'adAccountId' and 'limit', the description merely restates the action without enriching parameter understanding.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool lists ad campaigns within a Meta Ad Account. It uses a specific verb ('List') and resource ('ad campaigns'), and the scope is implied by the required parameter. This sufficiently distinguishes it from sibling tools like fb_create_post or fb_get_insights.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives such as fb_get_insights for analytics or fb_api for custom queries. It lacks context about prerequisites or when not to use it, leaving the agent without decision support.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
List Facebook Pages managed by the authenticated user.
| Name | Required | Description | Default |
|---|---|---|---|
| fields | No | Comma-separated fields (default: "id,name,access_token,category,tasks") |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided, so the description carries full burden. It only mentions 'managed by the authenticated user' implying authentication, but lacks details on authentication requirements, rate limits, or any side effects.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Single sentence, front-loaded with the action and resource. No unnecessary words or repetition.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple list tool with 0 required params and no output schema, the description is minimal but sufficient. However, it lacks context about possible return values or pagination, which could help agents adapt.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100%, so baseline is 3. The description does not add any information beyond the schema's parameter description. No additional context for the optional 'fields' parameter.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action ('List') and resource ('Facebook Pages') with a specific scope ('managed by the authenticated user'). It distinguishes itself from sibling tools like fb_list_ad_accounts or fb_list_campaigns.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance on when to use this tool vs alternatives, or any prerequisites. The description simply states what it does without contextual usage advice.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Publish a reply or comment to a Facebook post or parent comment.
| Name | Required | Description | Default |
|---|---|---|---|
| message | Yes | Comment text message | |
| targetId | Yes | Post ID or Comment ID to comment on | |
| accessToken | No | Optional Access Token (e.g. Page token) |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries full burden for behavioral disclosure. It fails to mention side effects, permission requirements, rate limits, or what happens on failure (e.g., invalid targetId).
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single concise sentence that is front-loaded and efficient. However, it is overly minimal; a bit more detail would improve without sacrificing conciseness.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the low complexity (3 parameters, no output schema), the description adequately states the basic purpose but lacks completeness. It would benefit from mentioning return format or confirming the action is irreversible.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100%, so the schema already documents all parameters. The description does not add extra meaning beyond the schema, e.g., not explaining that targetId can be a post or comment ID or how accessToken is used.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description 'Publish a reply or comment to a Facebook post or parent comment' uses a specific verb (publish) and resource (reply/comment), clearly distinguishing it from siblings like fb_create_post (creates posts) and fb_get_post_comments (retrieves comments).
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool vs alternatives (e.g., fb_create_post for new posts). It lacks context about appropriate scenarios or prerequisites.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Recent tool additions, removals, and schema changes observed during successful MCP inspections. Dates show when Glama detected each change.
v1.0.5fb_apifb_create_postfb_get_insightsfb_get_mefb_get_page_feedfb_get_post_commentsfb_list_ad_accountsfb_list_campaignsfb_list_pagesfb_reply_commentEach tool targets a distinct operation or resource: commenting, campaign listing, insights, raw API, user info, page listing, post creation, feed fetching, comment retrieval, and ad account listing. No overlap or ambiguity.
All tools follow a consistent 'fb_' prefix followed by verb_noun in snake_case (e.g., fb_reply_comment, fb_list_campaigns). The pattern is uniform and predictable.
10 tools cover core Facebook/Meta operations: pages, posts, comments, ads, insights, and a universal API fallback. Well-scoped for a Facebook MCP server without being bloated or sparse.
Covers common CRUD for posts and comments, ad management, and insights. Missing update/delete for posts and comments, but the raw API tool (fb_api) can fill gaps. Minor but acceptable shortfall.
Unclaimed servers have limited discoverability.
If you are the server author, to access and configure the admin panel.
60+ Meta Ads tools for AI agents: audits, campaign management, audiences and CAPI tracking.
Instagram for AI agents: publish, read comments and DMs, insights, and engage from your account.
Boost posts and launch community growth campaigns from your AI assistant. OAuth, credit-billed.
Read and manage Meta Ads campaigns, ad sets, ads, audiences, pages and Business Manager. You provide
We provide all the information about MCP servers via our MCP API.
curl -X GET 'https://glama.ai/api/mcp/v1/servers/was-member-keramat/was-fb-mcp'
If you have feedback or need assistance with the MCP directory API, please join our Discord server
