MCP TabNews Integration
The MCP TabNews Integration server connects to the TabNews API, enabling comprehensive content management and analytics operations:
Check Status: Verify TabNews API availability
Get Contents: Retrieve content lists with pagination and sorting options (relevant, new, old)
Get Contents by User: Fetch all contents posted by a specific user with pagination and sorting
Get Content: Retrieve detailed content including body text using username and slug
Get Comments: Fetch comments associated with specific content
Get Analytics: Access daily analytics for user creation, root content (posts), and child content (comments) published
Get RSS Feed: Retrieve the TabNews RSS feed
Enables fetching the RSS feed from TabNews via the getRssFeedTool
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., "@MCP TabNews Integrationshow me the latest posts from TabNews"
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.
MCP TabNews Integration
A Model Context Protocol (MCP) integration for TabNews.
This MCP server is also available on Smithery for direct integration.
Available Tools
checkStatusTool: Check the status of the TabNews API.getContentsTool: Get contents from TabNews.getContentsByUserTool: Get contents from TabNews by user.getContentTool: Get a content with body from TabNews by user and slug.getContentChildrenTool: Get comments from TabNews by content.getAnalyticsUserCreatedTool: Get the analytics of a user created contents from TabNews.getAnalyticsRootContentPublishedTool: Get the analytics of a root content published from TabNews.getAnalyticsChildContentPublishedTool: Get the analytics of a child content published from TabNews.getRssFeedTool: Get the RSS feed from TabNews.
Integration with AI Tools
Related MCP server: MCP Boilerplate
Inspect MCP Server Capabilities
You can inspect this MCP server's capabilities using Smithery:
npx -y @smithery/cli@latest inspect @renant/mcp-tabnewsThis will show you all available tools, their parameters, and how to use them.
Setup
Manual Installation
Make sure you're using Node.js v23+
node -v
#v23.11.0Clone this repository:
git clone https://github.com/renant/mcp-tabnews.git
cd mcp-tabnewsRestore dependencies:
npm ciIntegration with AI Tools
Cursor Setup
Open Cursor Settings
Navigate to MCP section
Click "Add new MCP server"
Configure the server:
Name = mcp-tabnews Type = command Command = node ABSOLUTE_PATH_TO_PROJECT/src/index.tsor if you prefer executing it from Smithery
Name = mcp-tabnews Type = command Command = npm exec -- @smithery/cli@latest run @renant/mcp-tabnews
or configure directly from the Cursor's global MCP file located in ~/.cursor/mcp.json and add the following:
{
"mcpServers": {
"mcp-tabnews": {
"command": "node",
"args": ["ABSOLUTE_PATH_TO_PROJECT/src/index.ts"]
}
}
}or if you prefer executing it from Smithery
{
"mcpServers": {
"mcp-tabnews": {
"command": "npm",
"args": [
"exec",
"--",
"@smithery/cli@latest",
"run",
"@renant/mcp-tabnews"
]
}
}
}Make sure Cursor chat is in Agent mode by selecting "Agent" in the lower left side dropdown
Go to the chat an ask any question about TabNews
Claude Desktop Setup
Installing via Smithery
To install TabNews for Claude Desktop automatically via Smithery:
npx -y @smithery/cli install @renant/mcp-tabnews --client claudeDevelopment
Features
Built with Model Context Protocol (MCP)
Type-safe with TypeScript and Zod schema validation
Native TypeScript support in Node.js without transpilation
Standard I/O transport for easy integration
Structured error handling
Contributing
Contributions are welcome! Please feel free to submit a Pull Request.
Author
License
This project is licensed under the MIT License - see the LICENSE file for details.
Available Tools
9 toolsget analytics child content publishedB
To get how many comments were made (per day) in tabnews
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden of behavioral disclosure. It states the tool retrieves comment counts per day but doesn't cover aspects like authentication needs, rate limits, data freshness, or response format. For a tool with zero annotation coverage, this leaves significant behavioral gaps.
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 that directly states the tool's purpose without unnecessary words. It's front-loaded with the core functionality and avoids redundancy, making it highly concise and well-structured.
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's complexity (0 parameters, no output schema, no annotations), the description is minimally adequate. It explains what the tool does but lacks details on behavior, output format, or usage context. For a simple retrieval tool, it meets basic needs but could be more informative.
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 input schema has 0 parameters with 100% coverage, so no parameters need documentation. The description adds context by specifying the tool returns comment counts aggregated per day, which is useful semantic information beyond the empty schema. This compensates adequately for the lack of parameters.
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's purpose: 'To get how many comments were made (per day) in tabnews'. It specifies the verb ('get'), resource ('comments'), and temporal scope ('per day'), though it doesn't explicitly differentiate from sibling tools like 'get comments' or 'get analytics root content published'. The purpose is specific but lacks sibling comparison.
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. It doesn't mention prerequisites, exclusions, or comparisons to sibling tools such as 'get comments' or 'get analytics user created'. Usage is implied by the purpose statement alone, with no explicit context for selection.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get analytics root content publishedB
To get how many posts were made (per day) in tabnews
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden of behavioral disclosure. While it indicates this is a read operation ('get'), it doesn't describe the return format (e.g., structured data, time-series), potential rate limits, authentication needs, or error conditions. The description is minimal and lacks behavioral context.
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 that directly states the tool's purpose without unnecessary words. It's front-loaded with the core functionality and appropriately sized for a no-parameter tool.
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 has 0 parameters, no annotations, and no output schema, the description is minimally complete but lacks depth. It explains what the tool does but doesn't cover behavioral aspects like output format or usage constraints, which are important for an analytics tool even without parameters.
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 tool has 0 parameters with 100% schema description coverage, so no parameter documentation is needed. The description doesn't add parameter details, which is appropriate here, but it does imply the tool aggregates data 'per day', which is useful semantic context beyond the empty 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's purpose: 'To get how many posts were made (per day) in tabnews'. It specifies the verb ('get'), resource ('posts'), and scope ('per day in tabnews'), though it doesn't explicitly differentiate from sibling tools like 'get analytics child content published' or 'get content'.
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. It doesn't mention sibling tools like 'get content' or 'get contents' that might retrieve similar data, nor does it specify prerequisites or exclusions for usage.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get analytics user createdB
To get how many users were created (per day) in tabnews
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden of behavioral disclosure. It states the tool retrieves analytics data, implying a read-only operation, but doesn't specify authentication needs, rate limits, error conditions, or output format. For a tool with zero annotation coverage, this leaves significant behavioral gaps.
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 that directly states the tool's purpose without unnecessary words. It is appropriately sized and front-loaded, though it could be slightly more structured by explicitly separating purpose from context.
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's simplicity (0 parameters, no output schema), the description is minimally adequate. It explains what the tool does but lacks details on behavioral traits like authentication or output format. Without annotations or output schema, the description should ideally provide more context about the return data (e.g., date range, aggregation method).
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 tool has 0 parameters, and schema description coverage is 100%, so there are no parameters to document. The description doesn't need to add parameter semantics, and it correctly doesn't mention any. A baseline of 4 is appropriate for a zero-parameter tool with complete schema coverage.
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's purpose: 'To get how many users were created (per day) in tabnews'. It specifies the verb ('get'), resource ('users created'), and temporal scope ('per day'), making the function unambiguous. However, it doesn't explicitly differentiate from sibling tools like 'get contents' or 'get status', which prevents a perfect score.
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. It doesn't mention prerequisites, context for usage, or comparisons to sibling tools like 'get analytics child content published' or 'get contents by user'. The agent must infer usage solely from the purpose statement.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get commentsC
get comments from a content on tabnews api
| Name | Required | Description | Default |
|---|---|---|---|
| username | Yes | The username to get the content | |
| slug | Yes | The slug to get the content |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden of behavioral disclosure. It states the tool 'gets comments' but doesn't explain what that entails—for example, whether it returns all comments, paginated results, or specific metadata. Without annotations, this leaves significant gaps in understanding the tool's behavior.
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, straightforward sentence that efficiently conveys the core purpose without unnecessary words. It's appropriately sized for a simple tool, though it could be slightly more structured by explicitly mentioning the parameters or context.
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 lack of annotations and output schema, the description is incomplete. It doesn't explain what the tool returns (e.g., comment data format, error handling) or any behavioral nuances. For a tool with two required parameters and no structured output information, this leaves too much undefined for effective use.
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 input schema has 100% description coverage, clearly documenting both parameters ('username' and 'slug') and their purposes. The description adds no additional parameter information beyond what the schema provides, so it meets the baseline score of 3 for adequate but not enhanced parameter semantics.
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 ('get comments') and resource ('from a content on tabnews api'), making the purpose understandable. However, it doesn't distinguish this tool from its siblings (like 'get content' or 'get contents'), which could also potentially retrieve comments or related data, so it doesn't reach the highest score.
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. With siblings like 'get content' and 'get contents' available, it's unclear if this is the primary method for retrieving comments or if there are specific scenarios where it should be preferred over other tools.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get contentC
get content from tabnews api
| Name | Required | Description | Default |
|---|---|---|---|
| username | Yes | The username to get the content | |
| slug | Yes | The slug to get the content |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries full burden. It states 'get content' which implies a read-only operation, but doesn't disclose behavioral traits like authentication needs, rate limits, error handling, or what 'content' entails (e.g., format, size, metadata). This is inadequate for a tool with no annotation coverage.
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 zero waste. However, it's under-specified rather than concise—it lacks necessary detail to be truly helpful, but within its limited scope, it's structured appropriately.
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 annotations, no output schema, and a vague description, this is incomplete for a tool with 2 required parameters. The description doesn't compensate for missing context about what 'content' includes, how it's returned, or usage distinctions from siblings, leaving significant gaps.
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%, with clear parameter descriptions in the schema. The description adds no meaning beyond this, as it doesn't explain how username and slug combine to identify content or provide examples. Baseline 3 is appropriate since the schema does the heavy lifting.
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 'get content from tabnews api' states the action (get) and resource (content) but is vague about scope and specificity. It doesn't distinguish this tool from sibling tools like 'get contents' or 'get contents by user', leaving ambiguity about what exactly this tool retrieves versus those alternatives.
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 like 'get contents' or 'get contents by user'. The description implies it retrieves content but doesn't specify context, prerequisites, or exclusions, leaving the agent to guess based on parameter names alone.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get contentsC
get contents from tabnews api
| Name | Required | Description | Default |
|---|---|---|---|
| page | No | The page number to get | |
| per_page | No | The number of contents per page | |
| strategy | No | The strategy to get the contents |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden of behavioral disclosure. It only states the action ('get contents') without detailing traits like pagination behavior, rate limits, authentication needs, or what happens on errors. For a retrieval tool with no annotation coverage, this is a significant gap in transparency.
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 wasted words, making it appropriately concise. It could be improved by front-loading more specific information, but it avoids redundancy and is structurally sound.
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's complexity (3 parameters, no output schema, and no annotations), the description is incomplete. It lacks details on what 'contents' are, how results are returned, or any behavioral context. Without an output schema, the description should ideally hint at the return format, but it doesn't, leaving gaps for the agent.
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%, with clear descriptions for all three parameters (page, per_page, strategy). The description adds no additional meaning beyond what the schema provides, such as explaining the purpose of the strategy options or default behaviors. However, since the schema does the heavy lifting, 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 'get contents from tabnews api' is a tautology that essentially restates the tool name 'get contents' with minimal additional context. While it specifies the source (tabnews api), it doesn't clarify what 'contents' refers to (e.g., articles, posts, data entries) or distinguish this tool from siblings like 'get content' (singular) or 'get contents by user.' The purpose remains vague beyond the basic retrieval action.
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. It doesn't mention any context, prerequisites, or exclusions, nor does it differentiate from sibling tools such as 'get content' or 'get contents by user.' This leaves the agent with no information to make an informed choice among similar tools.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get contents by userC
get contents by user from tabnews api
| Name | Required | Description | Default |
|---|---|---|---|
| username | Yes | The username to get the contents | |
| page | No | The page number to get | |
| per_page | No | The number of contents per page | |
| strategy | No | The strategy to get the contents |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden of behavioral disclosure. It states this is a 'get' operation but doesn't clarify whether it's read-only, whether it requires authentication, what rate limits apply, what format the contents are returned in, or whether pagination is handled. For a content retrieval tool with zero annotation coverage, this leaves significant behavioral questions unanswered.
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 that directly states the tool's function. There's no wasted verbiage or unnecessary elaboration. However, it could be slightly more structured by front-loading key differentiators, but it's appropriately concise for its purpose.
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 tool with 4 parameters, no annotations, and no output schema, the description is inadequate. It doesn't explain what 'contents' means in this context, what the return format looks like, whether authentication is required, or how pagination works. The description should provide more context to compensate for the lack of structured metadata.
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%, meaning all parameters are documented in the schema itself. The description adds no additional parameter semantics beyond what's already in the schema (username, page, per_page, strategy). With complete schema coverage, the baseline score of 3 is appropriate since the description doesn't need to compensate for gaps.
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 states the tool retrieves contents by user from the TabNews API, which is a clear verb+resource combination. However, it doesn't distinguish this tool from sibling tools like 'get content' or 'get contents', which appear to be similar content retrieval tools. The purpose is understandable but lacks differentiation from alternatives.
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 like 'get content' or 'get contents'. There's no mention of prerequisites, constraints, or comparative use cases. The agent must infer usage from the tool name alone, which is insufficient for optimal selection.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get rss feedB
To get the rss feed from tabnews
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure. It only states what the tool does ('get the rss feed'), but doesn't mention any behavioral traits like whether it's read-only, requires authentication, has rate limits, or what the output format might be. This leaves significant gaps in understanding how the tool behaves.
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, straightforward sentence that directly states the tool's purpose without any unnecessary words. It's front-loaded and efficiently communicates the core function, making it highly concise and well-structured for its simplicity.
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 lack of annotations and output schema, the description is incomplete for a tool that retrieves data. It doesn't explain what the RSS feed contains, how it's structured, or any limitations (e.g., update frequency, data scope). For a data retrieval tool with no structured context, more detail is needed to be fully helpful.
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 tool has 0 parameters, and the schema description coverage is 100%, so there's no need for parameter details in the description. The baseline for this scenario is 4, as the description doesn't need to compensate for any parameter documentation gaps, and it appropriately avoids redundant information.
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 ('get') and resource ('rss feed from tabnews'), making the purpose understandable. However, it doesn't differentiate from sibling tools like 'get content' or 'get contents', which might retrieve similar data but in different formats or scopes, so it's not fully specific about what makes this tool unique.
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 sibling tools like 'get content' or 'get contents'. It lacks context about scenarios where an RSS feed is preferred over other data retrieval methods, leaving the agent without usage direction.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get statusC
get status from tabnews api
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden. It only states the basic action without disclosing behavioral traits such as rate limits, authentication needs, response format, or error handling. This is inadequate for a tool with zero annotation coverage.
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 extremely concise ('get status from tabnews api') with no wasted words, front-loading the core purpose. It is appropriately sized for a simple, parameterless tool.
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 lack of annotations and output schema, the description is incomplete. It does not explain what 'status' entails, the return values, or any behavioral context, leaving significant gaps for an AI agent to understand and use the tool effectively.
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 input schema has 0 parameters with 100% coverage, so no parameter documentation is needed. The description does not add parameter details, which is appropriate, earning a baseline score of 4 for tools with no parameters.
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 'get status from tabnews api' states the action ('get') and resource ('status from tabnews api'), but is vague about what 'status' specifically refers to (e.g., API health, system status, user status). It does not differentiate from sibling tools like 'get content' or 'get comments', which also retrieve data from the same API.
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. The description does not mention context, prerequisites, or exclusions, and with sibling tools like 'get content' or 'get comments' available, there is no indication of when 'get status' is appropriate.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections. Dates show when Glama detected each change.
5 tool updates
v1.0.0- Changed
get analytics child content published1 field changed- removed
Input schema / additionalPropertiesRemoved value: -false
- Changed
get analytics root content published1 field changed- removed
Input schema / additionalPropertiesRemoved value: -false
- Changed
get analytics user created1 field changed- removed
Input schema / additionalPropertiesRemoved value: -false
- Changed
get rss feed1 field changed- removed
Input schema / additionalPropertiesRemoved value: -false
- Changed
get status1 field changed- removed
Input schema / additionalPropertiesRemoved value: -false
9 tool updates
- First observed
get analytics child content published - First observed
get analytics root content published - First observed
get analytics user created - First observed
get comments - First observed
get content - First observed
get contents - First observed
get contents by user - First observed
get rss feed - First observed
get status
TDQS
The tools have some overlap that could cause confusion, particularly between 'get content', 'get contents', and 'get contents by user', as their purposes are similar but not clearly distinct. However, the analytics tools and others like 'get rss feed' and 'get status' are well-separated, reducing overall ambiguity.
The naming is inconsistent, mixing descriptive phrases like 'get analytics child content published' with simpler forms like 'get content' and 'get status'. There is no uniform pattern, with variations in verb usage and structure, making it harder to predict tool names.
With 9 tools, the count is well-scoped for a TabNews integration, covering analytics, content retrieval, and system status without being overwhelming. Each tool appears to serve a specific purpose, making the set manageable and appropriate.
The toolset focuses heavily on read operations (get analytics, get content, get status) but lacks obvious write or update capabilities like creating or modifying content or comments. This creates notable gaps for a full integration, though core retrieval functions are covered.
Maintenance
Resources
Unclaimed servers have limited discoverability.
Looking for Admin?
If you are the server author, to access and configure the admin panel.
Related MCP Connectors
A comprehensive Model Context Protocol (MCP) server that enables AI assistants to interact with yo…
A Model Context Protocol server for Wix AI tools
The Mercado Pago MCP Server implements the Model Context Protocol to provide AI agents and LLMs with access to Mercado Pago's APIs and tools within compatible development environments. It acts as an intermediary that translates Mercado Pago resources into executable functions (tools) that AI applications can invoke to perform actions and automate flows. The server simplifies integration, enables using documentation to implement or improve code, and optimizes operations through natural language interactions without manual implementations.
The Telnyx MCP server is an official implementation of the Model Context Protocol that enables AI clients (like Claude Desktop, Cursor, and OpenAI Agents) to interact with Telnyx's telephony, messaging, and AI assistant APIs. It provides comprehensive capabilities including making and managing phone calls, sending SMS/MMS messages, purchasing and configuring phone numbers, creating AI assistants with custom instructions, managing cloud storage buckets, scraping and embedding website content, and handling integration secrets. The server exists as both a local implementation and a remotely hosted version, allowing developers to integrate real-world communication infrastructure directly into AI applications.
Related MCP Servers
- AlicenseBqualityDmaintenanceA Model Context Protocol server that enables AI agents to query Erick Wendel's talks, blog posts, and videos across different platforms using natural language.427338MIT
- AlicenseNot gradedqualityDmaintenanceA server that implements the Model Context Protocol, providing a standardized way to connect AI models to different data sources and tools.1511MIT
- AlicenseAqualityDmaintenanceA server that enables AI assistants to access, analyze, and understand HackerNews content through standardized Model Context Protocol interfaces, providing tools for searching posts, analyzing users, and tracking trending topics.58MIT
- AlicenseBqualityDmaintenanceA Model Context Protocol server that enables AI assistants to securely fetch and extract readable text content from web pages through a standardized interface.1MIT
Latest Blog Posts
- Who's Calling? MCP Hosts Are an Identity Blind Spot (And the Spec Knows It)By Om-Shree-0709 on .mcpAgent IdentityOAuth 2.1
- Your AI Chatbot Just Exposed Your CEO's Salary to an InternBy Om-Shree-0709 on .Agent IdentityMCP SecurityOAuth Delegation
- Why MCP Servers Need Execution Sandboxing (And Why Your Current Stack Isn't Enough)By Om-Shree-0709 on .Agentic AiPrompt InjectionWebAssembly
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/renant/mcp-tabnews'
If you have feedback or need assistance with the MCP directory API, please join our Discord server