scrapedatshi-mcp

Server Quality Checklist

Profile completionA complete profile improves this server's visibility in search results.

Latest release: v0.2.1
Disambiguation4/5
Tools are mostly distinct, with clear purposes like scrape_url vs crawl_site vs extract_data. However, some overlap exists: autorag combines crawl_site and sync_to_vectordb, and ingest_file is similar to the file-based equivalent. Descriptions help disambiguate.
Naming Consistency4/5
Naming follows a consistent verb_noun pattern (scrape_url, list_embedding_providers, verify_provider_key). Minor deviations: autorag is a brand name, get_usage_guide uses 'get' instead of a verb like 'show', and sync_to_vectordb has a preposition. Overall mostly consistent.
Tool Count5/5
12 tools is an appropriate number for a web scraping and RAG pipeline server. Each tool covers a distinct step or combination of steps, and the count is neither too few nor too many for the scope.
Completeness5/5
The tool set covers the full workflow: provider discovery, key verification, scraping (single/multi page, structured extraction), file processing, and full RAG pipelines (chunk, embed, inject). Includes a usage guide. No obvious gaps for the stated purpose.
Average 4.3/5 across 12 of 12 tools scored. Lowest: 3.7/5.
See the Tool Scores section below for per-tool breakdowns.
- No community issues in the last 6 months
- 30 commits in the last 12 weeks
- No stable releases found
- No critical vulnerability alerts
- No high-severity vulnerability alerts
- No code scanning findings
- CI status not available
This repository is licensed under MIT License.
This repository includes a README.md file.
No tool usage detected in the last 30 days. Usage tracking helps demonstrate server value.
Tip: use the "Try in Browser" feature on the server page to seed initial usage.
Add a glama.json file to provide metadata about your server.
If you are the author, simply .
If the server belongs to an organization, first add glama.json to the root of your repository:
```
{
  "$schema": "https://glama.ai/mcp/schemas/server.json",
  "maintainers": [
    "your-github-username"
  ]
}
```
Then . Browse examples.
Add related servers to improve discoverability.

How to sync the server with GitHub?

Servers are automatically synced at least once per day, but you can also sync manually at any time to instantly update the server profile.

To manually sync the server, click the "Sync Server" button in the MCP server admin interface.

How is the quality score calculated?

The overall quality score combines two components: Tool Definition Quality (70%) and Server Coherence (30%).

Tool Definition Quality measures how well each tool describes itself to AI agents. Every tool is scored 1–5 across six dimensions: Purpose Clarity (25%), Usage Guidelines (20%), Behavioral Transparency (20%), Parameter Semantics (15%), Conciseness & Structure (10%), and Contextual Completeness (10%). The server-level definition quality score is calculated as 60% mean TDQS + 40% minimum TDQS, so a single poorly described tool pulls the score down.

Server Coherence evaluates how well the tools work together as a set, scoring four dimensions equally: Disambiguation (can agents tell tools apart?), Naming Consistency, Tool Count Appropriateness, and Completeness (are there gaps in the tool surface?).

Tiers are derived from the overall score: A (≥3.5), B (≥3.0), C (≥2.0), D (≥1.0), F (<1.0). B and above is considered passing.

Tool Scores

Behavior3/5
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 discloses that the tool uses an LLM for extraction, requires a provider key verification, supports optional headless rendering, and allows API keys via env vars. However, it does not mention rate limits, error handling, timeouts, or any side effects (though likely read-only). The transparency is adequate but could be more comprehensive.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is well-structured with a main purpose, usage examples, and a clear 'PRE-FLIGHT REQUIRED' section. It is concise, with each sentence adding value. The use of bullet points in the pre-flight steps enhances readability. Slightly verbose in parts but overall efficient.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's complexity (9 parameters, no output schema), the description covers the main purpose, pre-flight process, and parameter details. However, it lacks details on the output format beyond 'returns a JSON object', error handling, or what happens if the schema cannot be matched. For a tool with nested objects and multiple optional parameters, this is a notable gap.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has 100% description coverage, so the baseline is 3. The description adds significant meaning beyond the schema: it explains the purpose of the 'schema' parameter with an example, advises using advanced models for long pages, clarifies that 'llm_api_key' can be omitted if set as an env var, and explains when to use 'extract_as_list'. This extra context improves understanding.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description starts with a specific verb+resource combination ('scrape a URL and extract structured data') and includes examples of use cases (e.g., product name, price, stock status). It clearly conveys the tool's function of extracting user-defined fields via LLM. However, it does not explicitly differentiate from its sibling tool 'scrape_url', which also deals with URL content, leaving some ambiguity.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides clear guidance on when to use this tool (when the user wants specific fields from a page) and includes a 'PRE-FLIGHT REQUIRED' section with step-by-step instructions for the agent (call verify_provider_key, present models, ask about js_render). It also clarifies that Contextual Retrieval is not applicable. However, it does not explicitly state when NOT to use it or name alternative tools like 'scrape_url' for raw HTML extraction.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided, so description carries full burden. Describes the full pipeline, supported formats, max file size, and pre-flight requirements. Mentions cost for contextual retrieval and that keys can be omitted as env vars. Does not detail error handling or edge cases, but provides substantial 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.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Well-structured: purpose first, then supported formats/size, then usage instruction, then numbered pre-flight list. Sentences are informative and not redundant. Slightly long but each part earns its place.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Covers purpose, usage, parameters, pre-flight dependencies. Missing description of return value/output (no output schema provided). Does not explain error scenarios or what happens on failure. Adequate for a complex tool but incomplete in capturing all aspects.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Input schema has 100% description coverage. Description adds some value by reinforcing that file_path must be absolute, embedding_model should come from verify_provider_key, and pre-flight steps relate to parameters. However, the schema already covers these details, so the description provides marginal additional meaning.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose: 'Full RAG pipeline for local files: upload a file, embed the chunks... and inject the vectors into your vector database.' It distinguishes from sibling tools like sync_to_vectordb by calling itself the file-based equivalent, and from chunk_file by implying it does the full pipeline.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
Explicitly states when to use: 'Use this when the user wants to ADD a local document... to their vector DB.' Provides a detailed pre-flight checklist. Does not explicitly say when not to use or list alternatives beyond the sibling, but context is clear.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
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 states the tool returns a workflow, but does not disclose behavioral traits such as side effects, rate limits, or whether it requires authentication. However, as a read-only guide, its behavior is relatively simple.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is two sentences with no wasted words. It front-loads the purpose and provides a clear usage scenario. Every sentence earns its place.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given no output schema, the description could elaborate on what the guided workflow includes (e.g., tool list, sequence steps). It only says 'complete guided workflow', which is adequate but not fully descriptive for an agent to set expectations.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool has no parameters, so the input schema provides full coverage. The description does not need to add parameter information. Baseline for 0 parameters is 4.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool returns a 'complete guided workflow' for using scrapedatshi tools. It specifies the action ('returns') and the resource ('guided workflow'), and distinguishes itself from sibling action tools by being a meta-guide.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description explicitly advises to call it 'at the start of any scrapedatshi conversation' and explains why (to understand tool selection and pre-flight sequence). It does not mention alternatives, but the context is clear enough for an agent to know when to invoke it.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries full burden. It discloses chunking behavior, cost (surcharge for js_render, ~$0.001/chunk for contextual retrieval), prerequisite steps (verify_provider_key), and important flags (js_render for SPAs). However, it omits output format details, error handling, rate limits, or caching behavior, which would increase transparency for a tool with 9 parameters.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is concise in the first paragraph but includes a detailed multi-step pre-flight sequence that, while informative, makes it longer than necessary. Every sentence serves a purpose, but the pre-flight instructions could be more succinct. Overall structured logically: purpose, usage, special case.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The tool has 9 parameters, no output schema, and moderate complexity. The description covers the main use case and the contextual retrieval flow. However, it does not describe the return format (e.g., array of chunks with text, metadata) or error handling. Without output schema, the agent needs more detail on what to expect. Given the richness of the description for the main flow, it's adequate but not complete.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so baseline is 3. The description adds value by explaining when to use js_render (JavaScript-heavy pages, SPAs), that llm_model must come from verify_provider_key, and that llm_api_key can be an env var. The pre-flight sequence for contextual_retrieval adds operational context beyond schema. However, some schema descriptions already suffice, limiting extra contribution.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool scrapes a single URL, chunks it into RAG-ready segments, and returns structured chunks. It distinguishes from sibling tools like extract_data (which extracts structured fields) and crawl_site (which does multiple pages). The verb 'scrape' and resource 'single web URL' are specific and unambiguous.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
Explicitly states when to use: 'when the user wants to read, summarize, or process content of a specific web page WITHOUT extracting structured fields.' Provides a detailed pre-flight sequence for contextual_retrieval. Does not explicitly list when not to use, but the positive criteria imply exclusion of structured extraction. Sibling names provide context, but description could be more explicit about alternatives.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided, so description carries full burden. It discloses file format support, size limit, absolute path requirement, and the optional contextual retrieval workflow. Lacks details on error handling or file disposal, but adequate for typical use.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Well-structured with bullet points and ordered sections. Every sentence adds value. Slightly lengthy due to detailed pre-flight sequence, but still efficient.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Covers input requirements, supported formats, size limit, and optional features. Does not detail return structure or error cases, but the tool's output is implied. Overall sufficient for agent invocation.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100%, but description adds value by explaining absolute path, env var fallback for llm_api_key, and the verify_provider_key dependency for contextual_retrieval parameters.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action (upload, chunk) and resource (local file) and distinguishes from siblings like 'ingest_file' and 'autorag' by specifying it returns RAG-ready chunks without embedding or vector DB.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
Provides explicit trigger phrases ('chunk this PDF', 'process this document') and a detailed pre-flight sequence for contextual retrieval. Lacks explicit exclusion cases but gives clear usage context.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
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 discloses the composite operation, pre-flight requirements, headless browser for js_render, and extra cost for contextual_retrieval. It does not cover rate limits, error handling, or idempotency, but provides sufficient transparency for a complex tool.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is lengthy but well-structured with numbered steps and bullet points. It front-loads the purpose and systematically guides the user. Slightly verbose but efficient for the tool's complexity.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given high complexity (15 params, nested objects, no output schema), the description covers the workflow and pre-flight thoroughly. It lacks explicit return value description, but the process is clear enough for an agent to proceed.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100%, baseline 3. The description adds value by explaining workflow context (e.g., embedding_endpoint only for Ollama, env var fallbacks, and pre-flight steps). It does not repeat schema but enhances usability beyond schema alone.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool is a full RAG pipeline that scrapes, embeds, and injects into a vector DB. It explicitly says 'Use this when the user wants to ADD web content to their vector DB for later retrieval,' distinguishing it from sibling tools like chunk_file or ingest_file that handle only parts of the pipeline.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides explicit usage context ('ADD web content') and a detailed pre-flight checklist with steps. However, it does not explicitly mention when NOT to use this tool or compare directly with siblings like autorag, leaving some ambiguity about alternatives.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Despite no annotations, the description discloses behavioral traits like two modes, default max_pages, credit usage warning, surcharge for js_render, and pre-flight requirements. Could mention non-destructive nature, but overall strong.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is well-structured with sections, bullet points, and front-loaded purpose. Slightly lengthy but every part earns its place.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given 11 parameters, no output schema, and no annotations, the description covers the tool's behavior, parameters, and workflow comprehensively. Lacks detail on output format but still strong.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100%, so baseline is 3. The description adds context beyond the schema, e.g., explaining crawl_mode types, surcharge for js_render, and the pre-flight sequence for contextual_retrieval. Adds value.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose: 'Crawl an entire website, chunk all pages, and return structured JSON chunks.' It distinguishes two modes and contrasts with extract_crawl for structured field extraction.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines5/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
Explicit guidance is given: use when user wants chunks from multiple pages without structured extraction; use extract_crawl for structured extraction. Includes a pre-flight sequence for contextual_retrieval and warns about confirming max_pages.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided; description doesn't add behavioral traits beyond purpose. For a read-only list, minimal but adequate.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Two concise sentences front-loading the purpose and usage, with no unnecessary words.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple list tool with no parameters and no output schema, the description adequately covers what the tool returns and why it should be called.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
No parameters exist; schema coverage is 100%. Description adds value by explaining what the output contains (config fields, optional fields, setup notes).
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description explicitly states it returns supported vector database providers with config fields and setup notes, and distinguishes itself from sibling tools like list_embedding_providers.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines5/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
Clearly says to call this before sync_to_vectordb to understand required fields, providing explicit when-to-use guidance.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden. It discloses return values (key validity, model list, error message) and mentions that API keys can be omitted. It does not mention side effects, rate limits, or idempotency, but for a verification tool, the behavioral traits are adequately covered.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is concise, comprising three clear sentences that front-load the primary purpose. It states the action, return values, and supported providers without any extraneous information. Every sentence adds value.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given there is no output schema, the description fully describes return values (key validity, model list, error). It lists all supported providers and explains how the key can be omitted. The tool is straightforward, and the description covers everything needed for an agent to use it correctly.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100%, so baseline is 3. The description adds value by explaining that 'provider_type' indicates whether models are used for LLM or embedding, with examples of where they are applied (extract_data, sync_to_vectordb). It also elaborates on the 'api_key' parameter's optionality with env var names, going beyond the schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose: verifying an API key and returning live available models. It uses specific verbs ('verify', 'return') and identifies the resource (LLM/embedding API key). This clearly distinguishes it from sibling tools like 'extract_data' or 'sync_to_vectordb' which perform different operations.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description explicitly states when to use the tool: 'Call this BEFORE any operation that requires an LLM or embedding provider' and advises against hardcoding model names. It lists supported providers and notes that the API key can be omitted if env vars are set. However, it does not explicitly discuss scenarios where the tool should not be used or contrast it with alternatives, though the context is clear.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden. It discloses page independence, billing for successful extractions, per-page time estimates, and model context size. Missing rate limits or concurrency details, but the key behaviors are well covered.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Well-structured with a clear purpose sentence, use-case line, warnings, and a numbered pre-flight list. Every sentence adds value; no redundancy. Length is appropriate for the tool's complexity.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Covers the main aspects: purpose, usage, pre-flight, timing, billing, parameter guidance. However, it lacks description of the output format (what the extracted data looks like) and does not address error handling for non-page failures. Given no output schema, this is a minor gap.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100%, so baseline is 3. The description adds significant context: instructions to not hardcode llm_model, to confirm max_pages, and explanation of crawl_mode options. It also describes pre-flight steps that affect parameter usage.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb-resource pair 'crawl a domain and extract structured data' and distinguishes from siblings like extract_data (single page) and crawl_site (no structured extraction). It provides a concrete use case example.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines5/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
Explicitly states when to use (multiple pages with structured fields) and provides a detailed pre-flight checklist including calling verify_provider_key, confirming max_pages, and noting js_render unavailability. Warnings for large page counts are given.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The description explains it returns labels and notes, which is sufficient for a read-only listing tool. No annotations are present, so the description carries the burden; it is brief but adequate.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Two concise sentences, front-loaded with the primary action, no wasted words.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given no output schema and no parameters, the description covers the return values and workflow steps. It is reasonably complete for a helper tool, though could mention if the list is static.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
No parameters exist, so the description does not need to add parameter info. The schema coverage is 100%, meeting the baseline for zero parameters.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool returns all supported embedding providers with labels and notes. It distinguishes itself from siblings by specifying its role before sync_to_vectordb.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines5/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
Explicitly advises when to call (before sync_to_vectordb) and the next step (call verify_provider_key after user choice), providing a clear workflow.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior5/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description details the full pipeline, default settings (max_pages=5), crawl modes, and key handling (env vars). It also explains contextual retrieval's cost and benefits, leaving no behavioral ambiguity.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Well-structured with sections, bullet points, and warnings. Slightly verbose but every sentence serves a purpose. Could be tightened slightly, but excellent overall.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Covers the complex pipeline thoroughly, including pre-flight checks and parameter interactions. Lacks error-handling details or return value description, but the absence of an output schema makes this acceptable.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters5/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Despite 100% schema coverage, the description adds critical context: instructions to verify providers, not guess models, confirm limits, and call list_vector_db_providers for config. This far exceeds the schema's basic descriptions.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states it is a 'Full AutoRAG pipeline' combining crawling, chunking, embedding, and injection into one call. It explicitly distinguishes from sibling tools like crawl_site and sync_to_vectordb.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines5/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
Provides explicit when-to-use guidance ('bulk-ingest an entire website'), mandatory pre-flight steps with tool calls, warnings about max_pages and credit usage, and alternative upgrade recommendation (Contextual Retrieval).
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

GitHub Badge

Glama performs regular codebase and documentation scans to:

Confirm that the MCP server is working as expected.
Confirm that there are no obvious security issues.
Evaluate tool definition quality.

Our badge communicates server capabilities, safety, and installation instructions.

Card Badge

Copy to your README.md:

[![scrapedatshi-mcp MCP server](https://glama.ai/mcp/servers/scrapedatshi/scrapedatshi-mcp/badges/card.svg)](https://glama.ai/mcp/servers/scrapedatshi/scrapedatshi-mcp)

Score Badge

Copy to your README.md:

[![scrapedatshi-mcp MCP server](https://glama.ai/mcp/servers/scrapedatshi/scrapedatshi-mcp/badges/score.svg)](https://glama.ai/mcp/servers/scrapedatshi/scrapedatshi-mcp)

Latest Blog Posts

Who's Calling? MCP Hosts Are an Identity Blind Spot (And the Spec Knows It)
By Om-Shree-0709 on July 25, 2026.
mcp
Agent Identity
OAuth 2.1
Your AI Chatbot Just Exposed Your CEO's Salary to an Intern
By Om-Shree-0709 on July 2, 2026.
Agent Identity
MCP Security
OAuth Delegation
Why MCP Servers Need Execution Sandboxing (And Why Your Current Stack Isn't Enough)
By Om-Shree-0709 on June 30, 2026.
Agentic Ai
Prompt Injection
WebAssembly

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/scrapedatshi/scrapedatshi-mcp'

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