scout-mcp is a multi-source search MCP server that searches 21 platforms in parallel, returning structured JSON results from code registries, academic platforms, social networks, and tech blogs.
Code & Packages
GitHub repositories (stars, forks, language, license) and detailed repo info (contributors, releases, topics)
npm packages (quality/popularity/maintenance scores), PyPI, GitLab projects, and x402 Bazaar for AI-agent APIs
Developer News & Blogs
Hacker News stories/comments/polls, Lobste.rs curated tech news
Dev.to, Hashnode, Zenn (Japanese), Qiita (Japanese, optional QIITA_TOKEN)
Social & Community
X/Twitter via xAI Grok (requires XAI_API_KEY), Reddit, Lemmy (Fediverse)
Product Hunt product launches (requires PH_CLIENT_ID / PH_CLIENT_SECRET)
Academic Research
ArXiv preprints (CS, ML, physics, math)
Semantic Scholar across 200M+ papers with citation data (optional S2_API_KEY)
Q&A & Video
StackExchange/Stack Overflow (optional SE_API_KEY)
YouTube videos and tutorials (requires YOUTUBE_API_KEY)
Multi-Source Reports
scout_report tool runs parallel searches across up to 18 sources simultaneously with configurable focus presets (balanced, trending, comprehensive) or custom source selection.
Searches ArXiv for academic papers.
Searches Dev.to for articles.
Searches GitHub for repositories and retrieves repository details.
Searches GitLab for projects.
Used by Hashnode search integration to query articles via GraphQL.
Searches Hashnode for articles.
Searches Lemmy for Fediverse posts.
Searches Lobste.rs for stories.
Searches npm Registry for packages.
Searches Product Hunt for products by topic.
Searches PyPI for Python packages.
Searches Qiita for Japanese tech articles.
Searches Reddit for posts and comments.
Searches Semantic Scholar for academic papers.
Searches YouTube for videos.
Searches Zenn for Japanese tech articles.
An MCP server that searches 21 platforms in parallel and returns structured JSON. Built with the Model Context Protocol SDK.
Connect it to Claude Desktop, VS Code, Cursor, or any MCP client and search code registries, academic papers, social platforms, and tech blogs from a single tool call.
Tool | Source | Notes |
| Hacker News (Algolia) | Stories, comments, polls |
| GitHub | Repositories by keyword |
| GitHub | Single repo details |
| npm Registry | Packages |
| PyPI | Python packages |
| Product Hunt | Products by topic |
| X / Twitter | AI-powered via xAI Grok (requires |
| Dev.to | Articles |
| Hashnode | Articles (GraphQL) |
| Lobste.rs | Stories |
| StackExchange | Q&A across all sites |
| ArXiv | Academic papers |
| Posts and comments | |
| YouTube | Videos (requires |
| Zenn | Japanese tech articles |
| Qiita | Japanese tech articles |
| Semantic Scholar | Academic papers |
| Lemmy | Fediverse posts |
| GitLab | Projects |
| x402 Bazaar | x402 API directory |
| Multi-source | Parallel search across selected sources |
Related MCP server: research-dispatcher-mcp
git clone https://github.com/bartonguestier1725-collab/scout-mcp.git
cd scout-mcp && npm install && npm run buildAdd to your MCP client config:
{
"mcpServers": {
"scout": {
"command": "node",
"args": ["/absolute/path/to/scout-mcp/build/index.js"]
}
}
}docker build -t scout-mcp .
docker run -i scout-mcpThe Dockerfile builds a minimal node:24-alpine image that runs the MCP server over stdio.
All configuration is via environment variables. Most tools work without any keys. Optional keys unlock additional sources or raise rate limits.
Variable | Required | Description |
| For | xAI API key for X/Twitter search |
| Recommended | Raises GitHub rate limit |
| For | YouTube Data API v3 key |
| For | Product Hunt API credentials |
| For | Reddit API credentials |
| Optional | Raises Qiita rate limit |
| Optional | Semantic Scholar dedicated rate limit |
| Optional | StackExchange dedicated rate limit |
Each tool makes a direct API call to its source, parses the response, and returns normalized JSON with consistent fields (title, url, source, created_at, etc.). The scout_report tool runs multiple searches in parallel using Promise.allSettled, so one source failing doesn't block the others.
Transport: stdio (standard MCP transport). The server reads JSON-RPC messages from stdin and writes responses to stdout.
scout-mcp also runs as a paid HTTP API at https://scout.hugen.tokyo via the x402 protocol (USDC micropayments on Base). This mode uses the same tool implementations but exposes them as REST endpoints with payment middleware.
MIT
Search ArXiv for academic papers and preprints. Returns title, authors, abstract summary, PDF link, and categories. Great for cutting-edge research in CS, ML, physics, and mathematics.
| Name | Required | Description | Default |
|---|---|---|---|
| query | Yes | Search query | |
| per_page | No | Results per page | |
| sort | No | Sort by relevance or submission date | relevance |
| category | No | ArXiv category filter (e.g. cs.AI, cs.CL, stat.ML) |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided, so the description carries full burden. It does not disclose behavior like rate limits, API key requirements, or that results may be outdated due to ArXiv's update schedule. The term 'Great for' is vague and does not clarify 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 two concise sentences that front-load the purpose and return format. Every sentence adds value without redundancy.
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 that annotations are absent and output schema is missing, the description provides adequate overview but lacks details on result count limits or pagination. For a simple search tool with 4 parameters, it is minimally complete but could benefit from mentioning max results or behavior when no results found.
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%, and the description adds context by summarizing return fields and intended use for specific domains. However, it does not elaborate on parameter interdependencies or query formatting tips beyond what the schema provides. Baseline 3 is raised to 4 due to additional context about return values.
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 starts with a clear action verb 'Search' and specifies the resource 'ArXiv for academic papers and preprints'. It lists return fields (title, authors, abstract summary, PDF link, categories) and mentions target domains (CS, ML, physics, mathematics), which helps differentiate from sibling search tools like bazaar_search or devto_search.
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 implies use for cutting-edge research in specific fields, but provides no explicit guidance on when to use this tool versus alternatives like semantic_scholar_search. No mention of when not to use it or prerequisites.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Search x402 Bazaar for AI-agent APIs with micropayment access. Queries the CDP Discovery directory of x402-enabled HTTP resources. Returns matching APIs with price, network, and relevance score.
| Name | Required | Description | Default |
|---|---|---|---|
| query | Yes | Search query (matched against API URL and description) | |
| per_page | No | Max results to return |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided, so description bears full burden. It mentions return fields and data source but does not discuss rate limits, authentication, pagination behavior, or potential empty results. Adequate but not rich.
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?
Three sentences, zero waste. Each sentence adds new info: what it does, where it searches, what it returns. Front-loaded with action verb.
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, description explains return fields adequately. Tool has 2 simple params, no nested objects, and no enums. Description covers core functionality, though could mention pagination or error cases.
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. Description does not add extra semantics beyond schema: query matched against URL and description, per_page defaults to 10 and has min/max. No enrichment needed.
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 searches x402 Bazaar for AI-agent APIs with micropayment access, specifies it queries CDP Discovery directory, and lists return fields (price, network, relevance score). Distinguished from siblings by unique domain.
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 explicit guidance on when to use this vs alternatives, but sibling names suggest distinct search domains (e.g., arxiv_search, reddit_search). Implied usage: use for x402-enabled APIs. No exclusions or prerequisites mentioned.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Search Dev.to (Forem) for technical articles and blog posts. Returns title, description, reactions, comments, reading time, and tags. Great for tutorials, how-tos, and developer insights.
| Name | Required | Description | Default |
|---|---|---|---|
| query | Yes | Search query (used as tag filter + keyword match) | |
| per_page | No | Results per page | |
| sort | No | Sort order | relevance |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided, so description carries full burden. The description lists returned fields (title, description, reactions, etc.), which implies a get/search operation. However, it doesn't disclose mutation, rate limits, authentication needs, or pagination behavior beyond the per_page parameter. It mentions 'Returns title, description...' which is helpful but not comprehensive.
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?
Description is two sentences: first sentence states purpose and source, second lists returned fields and usage context. Efficient and front-loaded with key info. Could be slightly more concise by removing 'technical articles and blog posts' since Dev.to is primarily that, but no redundancy.
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, the description partially compensates by listing return fields. Parameter coverage is complete. However, for a search tool among many similar siblings, more guidance on when to use this specific tool (e.g., 'for developer-focused content') 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 description coverage is 100%, so baseline is 3. The description adds value by explaining that query is used as both a tag filter and keyword match, which goes beyond the schema's generic 'Search query' description. per_page and sort are adequately described in schema, so no extra credit needed.
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 searches Dev.to for technical articles and blog posts, listing specific returned fields. It distinguishes from siblings by being specific to Dev.to, but many sibling tools are also search tools for different platforms, so the platform is the key differentiator, which is 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?
The description gives usage context ('Great for tutorials, how-tos, and developer insights') but does not explicitly state when to use this vs alternatives (e.g., for non-technical content, use other platforms). No exclusions or alternatives mentioned.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Get detailed information about a specific GitHub repository: stars, forks, contributors, releases, license, topics, and more.
| Name | Required | Description | Default |
|---|---|---|---|
| owner | Yes | Repository owner (user or org) | |
| repo | Yes | Repository name | |
| include_contributors | No | Include top 10 contributors | |
| include_releases | No | Include 5 most recent releases |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description must disclose behavioral traits. It correctly implies a read-only operation by listing fetched data and uses conditional boolean parameters. However, it does not mention rate limiting, authentication, or any potential side effects, which is acceptable for a typical read-only data retrieval 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?
The description is a single concise sentence that lists key functionalities. It is front-loaded and contains no redundancy.
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?
The tool is relatively simple with four parameters, all documented. The description lists the key data fields returned. Since there is no output schema, the description compensates by summarizing the output. It is fully adequate for the tool's complexity.
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 schema has 100% description coverage, so all parameters are documented in the schema. The description adds high-level context by listing data fields but does not add syntax or format details beyond 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 explicitly uses 'Get detailed information' as the verb and clearly identifies the resource ('specific GitHub repository'). It lists specific data fields (stars, forks, contributors, releases, license, topics) and distinguishes itself from sibling tools like 'github_search', which presumably searches for repositories.
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 implies usage for retrieving repo details, but it does not explicitly state when to use this tool versus alternatives. Given sibling tools like 'github_search', 'scout_report', and others, there is no guidance on choosing this tool over them.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Search GitHub repositories by keyword, topic, or description. Returns stars, forks, language, topics, and license info.
| Name | Required | Description | Default |
|---|---|---|---|
| query | Yes | Search query (supports GitHub search qualifiers like 'topic:mcp') | |
| sort | No | Sort order | best-match |
| per_page | No | Results per page | |
| language | No | Filter by programming language (e.g. 'typescript') |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description must carry full burden. It explains what the tool returns (stars, forks, language, topics, license) and hints at typical search behavior. It does not mention rate limits, authentication needs, or destructive actions, but for a read-only search tool, the description is reasonably transparent.
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 purpose and key outputs. No wasted words.
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 (4 parameters, no output schema, no nested objects), the description covers the main functionality and outputs. It does not detail the return format or pagination behavior, but the schema covers parameters. For a search tool, this is mostly complete.
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 schema already documents each parameter. The description adds no additional semantics beyond what the schema provides, such as clarifying the 'query' supports GitHub qualifiers (which is already in the schema description). 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 tool searches GitHub repositories by keyword, topic, or description, and lists the returned information (stars, forks, language, topics, license). This distinguishes it from sibling tools like github_repo_info that focus on a single repo, and from other search tools targeting different platforms.
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 implies when to use this tool (to search GitHub repos) vs. siblings like github_repo_info (for detailed info on a single repo) or other search tools (for different platforms). However, it does not explicitly mention when not to use it or provide alternative tools.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Search GitLab.com for public projects (the second largest code hosting platform). Returns name, description, stars, forks, topics, and activity. Covers enterprise OSS and projects not on GitHub.
| Name | Required | Description | Default |
|---|---|---|---|
| query | Yes | Search query for GitLab projects | |
| per_page | No | Results per page | |
| sort | No | Sort order | stars |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided, so description must carry burden. Description states it returns specific fields and covers public repos, but does not disclose privacy policy, API rate limits, auth requirements, or any behaviors like rate limiting, pagination (though per_page is in schema), or whether results are filtered by user or permissions. Incomplete for a search 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?
Two sentences, front-loaded with purpose and key differentiator. Could be slightly more concise without losing value, but efficient overall.
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, description partially compensates by listing returned fields. However, lacks information about result structure, error handling, or usage limits. With constant sibling count (18 tools) and context signals indicating simple schema, description is minimally complete but has 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 coverage is 100%, so baseline is 3. Description does not add parameter-level details beyond schema, but schema itself is clear with descriptions for query, per_page (default, min, max), and sort (default, enum). Parameter semantics are adequate.
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?
Clearly states it searches GitLab.com for public projects, specifies it's the second largest code hosting platform, distinguishes from GitHub search. Mentions returned fields (name, description, stars, forks, topics, activity) and coverage (enterprise OSS, not on GitHub).
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?
Implied usage: use when looking for GitLab-hosted projects not on GitHub. But no explicit when-not-to-use or alternatives among siblings (e.g., github_search for GitHub). Context signals show sibling tools cover other platforms, but no direct exclusion guidance.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Search Hacker News (stories, comments, polls) via Algolia. Good for developer sentiment, trending tech topics, and community discussions.
| Name | Required | Description | Default |
|---|---|---|---|
| query | Yes | Search query | |
| sort | No | Sort order | relevance |
| per_page | No | Results per page | |
| tag | No | Filter by tag: story, comment, poll, show_hn, ask_hn |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries full burden. It fails to disclose behaviors like rate limiting, pagination limits (max 50 per_page), or that results are via Algolia (a third-party). The mention of 'via Algolia' hints at external dependency but is insufficient.
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 that efficiently states the resource, method, and use cases 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?
Given no output schema and no annotations, the description is adequate for a search tool but lacks depth on result format, error handling, and authentication. It covers the core purpose but leaves gaps in behavioral context.
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 adds no param-specific details. Baseline 3 is appropriate; the description cannot add value beyond schema for 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 searches Hacker News stories, comments, and polls via Algolia, and distinguishes it from siblings by specifying unique use cases like developer sentiment and trending tech topics.
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 implies when to use the tool (for developer sentiment, trending tech topics, community discussions) but does not explicitly state when not to use it or provide alternatives among the many sibling search tools.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Search Hashnode for technical blog posts. Uses tag-based lookup with keyword filtering. Returns title, brief, reactions, reading time, and author info. Good for in-depth technical articles.
| Name | Required | Description | Default |
|---|---|---|---|
| query | Yes | Search query (used as tag slug + keyword filter) | |
| per_page | No | Results per page |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided, but the description explains behavior: uses 'tag-based lookup with keyword filtering', and returns specific fields. It does not mention rate limits, authentication requirements, or whether results are sorted by relevance, but given the absence of annotations, it provides adequate 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 concise (three sentences) and front-loaded with the main action. Each sentence provides distinct information: action, mechanism, output, and use case. No redundant or unnecessary words.
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 2 parameters, no output schema, and no annotations, the description covers purpose, input, output fields, and use case. It is mostly complete, though it could mention pagination behavior or any sorting details. However, it meets requirements for a straightforward search tool.
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% (both parameters have descriptions). The description adds context that 'query' is used as a tag slug combined with keyword filtering, which is not in the schema. 'per_page' is adequately described in the schema. The description adds moderate value beyond 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's purpose: 'Search Hashnode for technical blog posts.' It specifies the input mechanism ('tag-based lookup with keyword filtering') and the output fields ('title, brief, reactions, reading time, and author info'). It also distinguishes itself from siblings by focusing on technical articles and Hashnode specifically.
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 clear context on when to use this tool ('for in-depth technical articles') and implies it is specific to Hashnode. However, it does not explicitly state when not to use it or mention alternatives among the sibling tools for other types of content.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Search Lemmy (Fediverse Reddit alternative) for posts and discussions. Searches lemmy.world by default (largest instance, 30K+ daily active users). Returns title, score, comments, community, and content. Good for tech community discussions, especially post-Reddit-API communities.
| Name | Required | Description | Default |
|---|---|---|---|
| query | Yes | Search query | |
| per_page | No | Results per page | |
| sort | No | Sort order | TopAll |
| instance | No | Lemmy instance to search (default: lemmy.world) | lemmy.world |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description must cover behavioral traits. It discloses default instance, community focus, and return fields, but does not discuss potential rate limits, auth needs, or whether results are real-time. A score of 3 is appropriate as it adds some context but lacks 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?
The description is concise (3 sentences) and front-loaded with key info. Each sentence adds value: purpose, default instance, return fields, use case. Minor improvement could tighten the 'Good for...' sentence.
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?
With 4 parameters, no output schema, and no annotations, the description is fairly complete but lacks details on pagination (per_page) and sort options, which are part of the schema. The use case guidance is 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?
Schema coverage is 100%, so the schema documents all parameters. The description adds value by explaining the default instance and return fields, but does not elaborate on parameter usage beyond what's in the schema. Baseline 3 is correct.
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 searches 'Lemmy (Fediverse Reddit alternative) for posts and discussions' with specific details on default instance and return fields (title, score, comments, community, content). This verb+resource combination distinguishes it from sibling tools that search other platforms.
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 context on when to use (tech community discussions, post-Reddit-API communities) and default behavior (searches lemmy.world). However, it does not explicitly state when not to use or compare with alternatives.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Search Lobste.rs for curated tech news and discussions. A community-driven link aggregator focused on computing, similar to Hacker News but more tightly curated. Returns title, score, comments, tags, and URLs.
| Name | Required | Description | Default |
|---|---|---|---|
| query | Yes | Search query (used as tag + keyword filter) | |
| per_page | No | Results per page | |
| sort | No | Sort order: hottest or newest | hot |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided, so the description must disclose behavior. It describes what the tool returns (title, score, comments, tags, URLs) and notes it's similar to Hacker News but more curated. It does not mention pagination behavior, rate limits, auth requirements, or how the search works beyond being a tag + keyword filter. For a simple search tool, this is adequate but minimal.
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?
Two sentences covering purpose, context, and return data. Every phrase is informative with no redundancy. Highly efficient 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 zero annotations, no output schema, and 3 parameters with 100% schema coverage, the description provides enough context about the tool's domain and return structure. It could be more complete by mentioning pagination or result limits, but for a simple search tool it is largely sufficient.
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 baseline is 3. The description adds value by explaining that the query is used as a 'tag + keyword filter', providing insight into how the search operates beyond the schema. It also lists the return fields (title, score, etc.) which enriches understanding of what to expect. This justifies a higher score.
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?
Clearly states it searches Lobste.rs for curated tech news and discussions. The verb 'Search' + resource 'Lobste.rs' is specific. The description also contrasts it with Hacker News as more tightly curated, which helps distinguish it from sibling hackernews_search.
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 explains what Lobste.rs is and that it returns title, score, comments, tags, and URLs. It implicitly suggests usage for curated tech content. However, there is no explicit when-to-use or when-not-to-use guidance relative to siblings, but the community-driven nature and curated aspect imply it's for computing-focused content.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Search the npm package registry. Returns package name, version, description, scores (quality/popularity/maintenance), and links.
| Name | Required | Description | Default |
|---|---|---|---|
| query | Yes | Search query (package name, keywords, or description) | |
| per_page | No | Results per page |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden. It discloses what is returned (scores and links) and implies a read-only search operation. It could mention pagination or rate limits, but overall provides clear 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?
One sentence with all key information: action, resource, and return data. No wasted words, perfectly 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 the tool is simple (2 params, no output schema, no nested objects), the description covers the primary purpose and return fields. Could mention if results are sorted by relevance, but not strictly necessary.
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 schema coverage is 100% and the description of parameters is directly from the schema (query, per_page). The description adds no extra meaning beyond what's in the schema, so 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 'Search' and the resource 'npm package registry', and lists the returned fields (name, version, description, scores, links). It distinguishes itself from sibling tools like pypi_search (Python) and bazaar_search (other package manager) by specifying 'npm'.
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 implies the tool is for finding npm packages, but does not explicitly state when to use this vs. alternatives like github_search or pypi_search. No guidance on when not to use or prerequisites.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Search Product Hunt for products and launches. Tries topic-based lookup first, then falls back to keyword filtering on recent posts. Returns votes, comments, topics, makers, and descriptions. Requires PH_CLIENT_ID/SECRET.
| Name | Required | Description | Default |
|---|---|---|---|
| query | Yes | Search query (topic slug or keywords) | |
| order | No | Sort order | VOTES |
| per_page | No | Results per page |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Since no annotations are provided, the description carries the full burden. It clearly discloses the two-step search behavior (topic then fallback), and explicitly states the authentication requirement ('Requires PH_CLIENT_ID/SECRET'), which is important for the agent.
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 three sentences long, front-loads the core purpose and behavior, and is efficient. The authentication requirement could have been placed earlier but is not omitted.
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?
The description covers the search behavior, return fields, and authentication requirement. There is no output schema, but the description lists what is returned (votes, comments, topics, makers, descriptions), which is sufficient for an agent to understand the output.
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 schema already documents all parameters. The description adds meaning by explaining the fallback search behavior, but does not add details about how parameters like 'order' or 'per_page' affect behavior beyond what the schema provides.
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 searches Product Hunt for products and launches, and describes the two-step search strategy (topic-based, then fallback to keyword filtering). It distinguishes from siblings by naming the platform (Product Hunt) and specifying what data is returned.
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 says 'tries topic-based lookup first, then falls back to keyword filtering on recent posts', which gives some guidance on how the tool works, but does not explicitly state when to use this tool over alternatives like the other search tools. There is no when-not-to-use guidance.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Look up Python packages on PyPI by name. Tries multiple name variants (hyphenated, underscored, with py- prefix). For best results, use the exact or approximate package name. Returns version, summary, links, and metadata.
| Name | Required | Description | Default |
|---|---|---|---|
| query | Yes | Package name or approximate name to look up on PyPI | |
| per_page | No | Max results to return |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The description mentions it tries multiple name variants and returns specific fields (version, summary, links, metadata). Since no annotations are provided, the description carries the burden, but it does not detail any destructive behavior or auth requirements. It is adequate but not thorough.
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 concise with three sentences, each adding value: purpose, behavior, and guidance. No wasted words.
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 simple parameters, the description covers the essential behavior and return types. However, it does not mention pagination or sorting, which could be needed for a search tool.
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 already has descriptions for both parameters (query and per_page). The description adds context about name variant handling and returned data, but given 100% schema coverage, this baseline 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 it looks up Python packages on PyPI by name, which is a specific verb and resource. It distinguishes from sibling tools like npm_search or github_search by being about PyPI packages.
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?
It advises using 'exact or approximate package name' for best results, which is helpful. However, it does not explicitly mention when not to use this tool or provide alternatives among siblings.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Search Qiita (Japan's largest developer article platform) for technical articles. Returns title, likes, stocks, comments, tags, and author info. Best for Japanese tech content. Complements Zenn search.
| Name | Required | Description | Default |
|---|---|---|---|
| query | Yes | Search query (supports Japanese and tag:xxx syntax) | |
| per_page | No | Results per page |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided, so description must disclose behaviors. It doesn't mention rate limits, API stability, or any quirks beyond basic features.
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?
Three sentences front-loading purpose then adding context. Slightly verbose with 'Japan's largest' but still efficient.
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 or output schema, description adequately covers purpose and fields, but lacks usage scenarios or response structure info.
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. Description adds context for tag:xxx syntax but no additional param semantics beyond 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?
Description clearly states this tool searches Qiita for Japanese tech articles and lists return fields. Distinguishes from sibling Zenn search by noting complementarity.
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?
Implied use for Japanese tech content and complemented by Zenn, but lacks explicit when-not or alternative selection guidance for other siblings.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Search Reddit for posts and discussions using public JSON feeds (no API key required). Returns title, score, comments, subreddit, and content preview. Great for community sentiment, user experiences, and real-world feedback. Rate limit: 10 req/min.
| Name | Required | Description | Default |
|---|---|---|---|
| query | Yes | Search query | |
| per_page | No | Results per page (max 25) | |
| sort | No | Sort order | relevance |
| time | No | Time filter | week |
| subreddit | No | Restrict search to a specific subreddit (e.g. 'programming') |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Description discloses behavioral traits: uses public JSON feeds, no API key required, returns specific fields, and rate limit. Since annotations are absent, description carries full burden for transparency; it provides good detail without contradiction.
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?
Description is concise with three front-loaded sentences: what it does (first), what it returns (second), and usage context/rate limit (third). No wasted words.
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, the description adequately covers return fields. Tool complexity is moderate with 5 parameters and 1 required. The description provides enough context for effective use, though it could mention handling of empty results or pagination for 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% with descriptions for each parameter. The description adds value by listing returned fields (title, score, comments, etc.) and stating 'no API key required', which helps parameter usage context. However, it doesn't add extra semantic details beyond schema for individual parameters, so 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?
Description clearly states the tool searches Reddit posts/discussions using public JSON feeds. It distinguishes from sibling search tools (e.g., arxiv_search, x_search) by specifying Reddit as the source and noting no API key required.
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?
Description provides clear context for when to use (community sentiment, user experiences, real-world feedback) and mentions rate limit (10 req/min). However, it does not explicitly state when not to use or compare to sibling tools.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Run a multi-source intelligence report. Searches across 18 sources (HN, GitHub, npm, PyPI, X, Product Hunt, Dev.to, Hashnode, Lobste.rs, StackExchange, ArXiv, Reddit, YouTube, Zenn, Qiita, Semantic Scholar, Lemmy, GitLab) in parallel. Use 'focus' to control source selection: 'balanced' (14 free APIs), 'trending' (HN+X+PH+Dev.to+Lobsters), 'comprehensive' (all 18). Or specify exact sources. X search uses xAI Grok API (~$0.005/call). Reddit requires API keys. YouTube requires API key.
| Name | Required | Description | Default |
|---|---|---|---|
| query | Yes | Search query to scout across sources | |
| sources | No | Specific sources to search (overrides focus) | |
| focus | No | Preset: balanced=14 free APIs, trending=HN+X+PH+Dev.to+Lobsters, comprehensive=all 18 | balanced |
| per_page | No | Results per source |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided, so description must fully disclose behavior. It does so by stating parallel execution across 18 sources, cost for X search ($0.005/call), dependency on API keys (Reddit, YouTube), and free vs paid sources.
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?
Concise, front-loaded with key action and scope, then efficient detail on sources, focus options, and cost/API key notes. Every sentence adds value without redundancy.
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 no annotations, the description fully covers what the tool does, how to use it (presets vs exact sources), cost implications, and dependencies. Provides enough context for an AI agent to decide when to use this versus single-source siblings.
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 covers all parameters with descriptions (100% coverage). Description adds value by explaining the 'focus' preset meanings (e.g., 'balanced=14 free APIs') and the specific API key requirements for certain sources, which go beyond basic 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 runs a multi-source intelligence report, searching across 18 specified sources in parallel. It distinguishes itself from sibling tools by offering a unified search across multiple platforms instead of single-source searches.
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?
Provides explicit guidance on when to use focus presets (balanced, trending, comprehensive) and how to override with exact sources. Mentions key cost and API key requirements for X, Reddit, and YouTube, helping decide if alternative siblings should be used instead.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Search Semantic Scholar for academic papers across all disciplines (200M+ papers). Returns title, abstract, citations, influential citations, authors, journal, open access PDF link, and fields of study. Superior to ArXiv alone because it covers all fields and includes citation graph data.
| Name | Required | Description | Default |
|---|---|---|---|
| query | Yes | Search query for papers | |
| per_page | No | Results per page | |
| year | No | Filter by year or range (e.g. '2024', '2020-2024') | |
| fields_of_study | No | Filter by field (e.g. 'Computer Science', 'Medicine') |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided, so description must carry burden. It discloses that it covers 200M+ papers, returns specific data, and lacks rate limits or auth details, but given the read-only nature and rich output list, it is sufficiently transparent.
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?
Compact two-sentence description that front-loads the core purpose. Slightly verbose with the 'Superior to ArXiv' comparison but adds value for sibling differentiation.
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, the description lists return fields (title, abstract, etc.) which aids completeness. No major gaps noted for a search tool.
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% and description does not add significant additional meaning beyond schema descriptions. 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 states it searches for academic papers across all disciplines, listing returned data elements (title, abstract, etc.). It clearly distinguishes from sibling ArXiv tool by emphasizing all fields and citation graph.
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 explicitly states it is 'Superior to ArXiv alone' for all-field coverage and citation data, providing clear context for when to use this tool instead.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Search Stack Overflow and other StackExchange sites for Q&A. Returns questions with score, answer count, views, tags, and accepted answer status. Great for technical problem-solving and community knowledge.
| Name | Required | Description | Default |
|---|---|---|---|
| query | Yes | Search query | |
| per_page | No | Results per page | |
| sort | No | Sort order | relevance |
| site | No | StackExchange site (e.g. stackoverflow, serverfault, superuser) | stackoverflow |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Description mentions safe search behavior (returns questions with metadata) but without annotations, it could add more depth like rate limits or authentication needs.
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?
Extremely concise, two sentences, front-loaded with purpose and returns.
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, description would benefit from stating return format (e.g., list of objects), but it mentions key fields. Still, good for a search tool.
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 has 100% coverage, so description adds limited value beyond parameter names. It does not elaborate on valid values for 'site' or 'sort' beyond what schema provides.
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?
Clearly states it searches Stack Exchange sites, lists what is returned (score, answer count, etc.), and distinguishes from sibling tools.
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?
Provides a general use case ('great for technical problem-solving and community knowledge') but lacks explicit guidance on when to use over alternatives or when not to use.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Search X (Twitter) for posts, discussions, and trends using xAI's Grok API with web search. Requires XAI_API_KEY. Cost: ~$0.05/call (web_search $0.005 × 8-9 calls + tokens).
| Name | Required | Description | Default |
|---|---|---|---|
| query | Yes | Search query for X/Twitter | |
| recency | No | Time filter for results | week |
| per_page | No | Number of results to return |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description reveals key behavioral traits: web search powered by Grok, API key needed, and cost breakdown. This provides good transparency beyond what annotations would offer, though it could mention rate limits or data freshness.
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?
Two sentences, front-loaded with purpose, then cost and key info. Efficient, though cost detail is specific and could be seen as extraneous for initial decision.
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 3 simple params, no output schema, no annotations, description covers purpose, authorization, cost. Could mention that results are from Grok's web search, not native X API, and what return format is. Still, fairly complete for a search tool.
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% and descriptions in schema are adequate. Description adds no extra meaning beyond schema for query, recency, per_page. No need for more since schema already describes them.
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 searches X/Twitter for posts, discussions, and trends using Grok API. Distinguishes from siblings like twitter_search by specifying the Grok API and web search integration.
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?
Mentions requirement for XAI_API_KEY and cost, but does not explicitly say when to use this vs siblings or when not to use it. The cost and API key hint at unique prerequisites, but no alternative tools are named.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Search YouTube for videos. Returns title, description, channel name, thumbnail URL, and video URL. Great for tutorials, demos, and educational content. Requires YOUTUBE_API_KEY.
| Name | Required | Description | Default |
|---|---|---|---|
| query | Yes | Search query | |
| per_page | No | Results per page | |
| order | No | Sort order | relevance |
| type | No | Result type filter | video |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so description bears full burden. It states it requires YOUTUBE_API_KEY, which is good. However, it doesn't mention rate limits, pagination, or output format details. Returns fields are noted but no details on behavior beyond that.
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?
Three sentences, front-loaded with purpose, then returns, then context. No wasted words.
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?
Tool has 4 params, no output schema, no annotations. Description covers purpose, returns, and a requirement (API key). It could mention pagination but overall sufficient for a search tool.
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?
All 4 parameters are described in the schema (100% coverage). The description adds no additional semantics beyond listing returns. However, the schema already provides enums and defaults, so additional description is not critical. 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 'Search YouTube for videos' and lists the return fields, distinguishing it from sibling tools. It specifies that it's for videos, which is a specific resource.
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 mentions it's 'Great for tutorials, demos, and educational content', providing context for when to use. However, it does not explicitly say when not to use or name alternative tools.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Search Zenn (Japanese tech blog platform) for technical articles. Uses topic-based lookup with keyword filtering. Returns title, likes, comments, topics, and author info. Best for Japanese tech content. Note: uses unofficial API.
| Name | Required | Description | Default |
|---|---|---|---|
| query | Yes | Search query (used as topic slug + keyword filter) | |
| per_page | No | Results per page | |
| article_type | No | Filter by article type: tech (technical) or idea (opinion/essay) | |
| order | No | Sort order by time period popularity | daily |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden. It states the tool uses an unofficial API, which is important for reliability awareness, but does not disclose other behavioral traits like rate limits, authentication needs, or potential data structure changes. The 'best for Japanese tech content' is vague and not actionable.
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 concise at three sentences, each adding value: platform, functionality, returns, usage context, and caveat. No redundant or extraneous content.
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 4 parameters, no output schema, and no annotations, the description provides adequate purpose and usage context. However, it lacks details on output structure (like topics, author info) and does not explain how the query parameter works as a topic slug + filter. May be sufficient for simple use but not comprehensive.
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 covers all parameters with 100% description coverage, explaining query as topic slug + keyword filter, article_type enum values, and order enum meanings. The description complements but does not add significant new info beyond the schema. Baseline 3 is elevated due to clear enum descriptions.
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 searches Zenn for technical articles using topic-based lookup with keyword filtering. It specifies the platform and content type, distinguishing it from other sibling search tools like qiita_search for Japanese tech 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 mentions it is best for Japanese tech content and notes the use of an unofficial API, providing some usage guidance. However, it does not explicitly advise when to use this tool over alternatives like qiita_search or other Japanese content sources.
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.
v0.1.0arxiv_searchbazaar_searchdevto_searchgithub_repo_infogithub_searchgitlab_searchhackernews_searchhashnode_searchlemmy_searchlobsters_searchnpm_searchproducthunt_searchpypi_searchqiita_searchreddit_searchscout_reportsemantic_scholar_searchstackexchange_searchx_searchyoutube_searchzenn_searchMost tools are clearly distinct by platform (e.g., arxiv_search vs. semantic_scholar_search), but some overlap exists between technical blogging platforms (devto_search, hashnode_search, zenn_search, qiita_search) which could cause confusion despite different niches.
All tool names follow a consistent pattern: platform name (lowercase, underscore-separated) followed by '_search' or '_info' for non-search functions. This is highly predictable.
21 tools is on the higher side for a search-focused server, bordering on excessive due to many similar search tools for different platforms. However, each serves a distinct niche, making the count borderline acceptable.
The server covers a wide range of sources (code repositories, academic papers, social media, blogs, Q&A, etc.) and includes a multi-source report tool. Missing some minor platforms, but overall comprehensive for an intelligence gathering server.
Unclaimed servers have limited discoverability.
If you are the server author, to access and configure the admin panel.
Search GitHub, npm, PyPI, StackOverflow, ArXiv from one MCP — built for coding agents.
Search public open-source code, documentation, metadata, vulnerabilities, changelogs, and examples.
Source code search for every package on PyPI and npm.
Package intelligence for AI agents across npm, PyPI, crates.io and deps.dev. No API keys.
We provide all the information about MCP servers via our MCP API.
curl -X GET 'https://glama.ai/api/mcp/v1/servers/bartonguestier1725-collab/scout-mcp'
If you have feedback or need assistance with the MCP directory API, please join our Discord server
