Brainiall Web
Server Details
Web search, URL content extraction to Markdown, site mapping, and recursive web crawler.
- Status
- Healthy
- Last Tested
- Transport
- Streamable HTTP
- URL
Available Tools
5 toolscheck_web_serviceCheck Web ServiceARead-onlyIdempotentInspect
Check whether the web reading service is responding.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint, openWorldHint, and idempotentHint, so the safety profile is covered. The description adds only that the tool verifies responsiveness, without detailing what 'responding' means, network behavior, or possible error states.
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, focused sentence that directly conveys the tool's purpose without elaboration. It is concise, front-loaded, and contains no redundant information.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a parameterless liveness check, the description is largely complete: it names the resource and the condition being tested. The lack of an output schema and absence of return-value details are minor given the simplicity of a status check.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool has zero parameters, so parameter semantics are trivially satisfied. The schema documents no inputs, and the description's behavior does not require any parameter explanation.
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 a clear verb ('check') and a specific resource ('the web reading service'), with the outcome condition 'is responding'. It distinguishes itself from sibling tools like read_page and crawl_site by indicating a liveness/health check rather than a data-gathering operation.
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 phrase 'whether the web reading service is responding' implies this is a health-check tool, so the intended usage is reasonably clear. However, the description does not explicitly state when to use it versus the sibling operations, nor does it mention exclusions or prerequisites.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
crawl_siteCrawl SiteARead-onlyIdempotentInspect
Read multiple linked pages with strict page and depth limits.
Use only when several pages are required. If you merely need to discover a site's structure, use map_site first because crawling is slower and costlier.
| Name | Required | Description | Default |
|---|---|---|---|
| url | Yes | Absolute HTTP(S) starting URL for a bounded multi-page crawl | |
| max_depth | No | Maximum link depth from the starting URL (capped at 5) | |
| max_pages | No | Maximum pages to read (capped at 50) |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint, openWorldHint, idempotentHint, and destructiveHint=false. The description adds meaningful behavioral context beyond annotations: strict page/depth limits and the cost/slowness tradeoff. It does not contradict annotations.
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 short sentences with no fluff: the core action and limits come first, followed by targeted usage guidance. Every sentence earns its place.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple three-parameter tool with strong annotations and full schema coverage, the description provides enough context for correct selection and invocation. It does not describe the exact return format, but no output schema exists and it clearly says it reads pages, so an agent can infer the outcome.
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 url, max_depth, and max_pages. The description only refers to 'page and depth limits' without adding syntax or format details beyond the schema, matching the baseline for high schema coverage.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses a specific verb and resource ('Read multiple linked pages') and explicitly differentiates from map_site, which discovers site structure. An agent can tell it apart from siblings like read_page and map_site without ambiguity.
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 explicit when-to-use guidance ('Use only when several pages are required') and names map_site as the preferred alternative for structure discovery, with a rationale (slower and costlier). This is model usage guidance.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
map_siteMap Site URLsARead-onlyIdempotentInspect
List a site's URLs so an agent can select pages before reading them.
Prefer this inexpensive discovery step before crawl_site. Map first, then call read_page for selected URLs unless content from many pages is required.
| Name | Required | Description | Default |
|---|---|---|---|
| url | Yes | Absolute HTTP(S) site URL whose available URLs should be listed | |
| limit | No | Maximum URLs to list (capped at 500) |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint, idempotentHint, and non-destructive behavior, so the description's safety burden is low. It adds valuable context by labeling the operation as 'inexpensive' and framing it as a discovery step, which helps agents anticipate performance and purpose. However, it doesn't disclose potential rate limits or response format specifics, though annotations cover the main safety profile.
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 with zero filler. The first sentence immediately states the operation and purpose, and the second delivers the workflow guidance. Every word earns its place, and the most critical information (purpose and usage) is 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?
For a 2-parameter tool with clear annotations and no output schema, the description fully covers what an agent needs: what it does, when to use it (before crawl_site, before read_page), and why it's preferable (inexpensive). The implied output (a list of URLs) is sufficient for this simple discovery tool, and the workflow guidance makes it self-contained.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, with both 'url' and 'limit' clearly described in the schema (absolute URL, max 500 cap). The description adds no additional parameter-level meaning beyond the schema, so the baseline of 3 is appropriate; it doesn't need to compensate for schema gaps.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action ('List a site's URLs') with a specific resource and purpose ('so an agent can select pages before reading them'). It explicitly differentiates from siblings by naming crawl_site as the heavier alternative and read_page for after mapping, making the tool's role unambiguous.
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 when-to-use guidance: 'Prefer this inexpensive discovery step before crawl_site. Map first, then call read_page for selected URLs unless content from many pages is required.' This states the recommended workflow and explicitly contrasts with crawl_site (for many pages) and read_page (for selected URLs), leaving no ambiguity about decision-making.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
read_pageRead Web PageARead-onlyIdempotentInspect
Read one known web page as clean Markdown without raw HTML noise.
Use this for documentation, articles, and product pages when the URL is already known. For an unfamiliar site, use map_site first to choose useful URLs instead of crawling every page.
| Name | Required | Description | Default |
|---|---|---|---|
| url | Yes | Absolute HTTP(S) URL of documentation, an article, or a product page to read without raw HTML noise |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already cover read-only, idempotent, open-world, and non-destructive behavior. The description adds useful behavioral context beyond annotations by specifying the output is clean Markdown with raw HTML noise removed and clarifying that the tool reads exactly one known page.
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, no filler. The core behavior is front-loaded in the first sentence, and the second sentence gives a clear usage boundary. Every word earns its place.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple single-parameter, read-only tool with 100% schema coverage and no output schema, the description fully equips an agent to select and invoke it. It states the input, the expected output format, and the primary alternative for unfamiliar URLs.
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 single url parameter is already well documented with type, minimum length, and intended URL scheme. The description adds no new parameter-specific syntax or constraints beyond the schema, so the baseline 3 applies.
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 a specific verb and resource: 'Read one known web page as clean Markdown.' It differentiates from siblings by emphasizing a single known URL rather than crawling or searching, and by naming the output format (Markdown).
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 explicitly says when to use the tool — for documentation, articles, and product pages when the URL is already known — and when not to: for unfamiliar sites, use map_site first instead of crawling every page. This gives concrete routing guidance relative to siblings.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
search_webSearch the WebARead-onlyIdempotentInspect
Find relevant web pages when you do not already know their URLs.
| Name | Required | Description | Default |
|---|---|---|---|
| query | Yes | Search query used to find pages by title, URL, and snippet | |
| max_results | No | Maximum results to return (capped at 25) |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint, openWorldHint, idempotentHint, and destructiveHint, so the description need not repeat safety properties. It adds a useful scoping detail about not requiring known URLs, but it does not disclose result format, pagination, or cap behavior beyond what the schema states.
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?
A single front-loaded sentence conveys the tool's purpose and primary use condition with zero filler. Every word contributes to an agent's ability to decide whether to call this tool.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple two-parameter search tool with rich annotations, the description plus schema is sufficient for selection and invocation. It does not describe the exact return structure, but the schema hints at result fields (title, URL, snippet) and the annotations cover the safety profile.
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 fully documents both query and max_results. The description adds no parameter-level detail, so the baseline score of 3 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description states a specific verb ('find') and resource ('relevant web pages'), and adds the key condition 'when you do not already know their URLs,' which clearly separates it from URL-based siblings like read_page and crawl_site. This is a precise, unambiguous definition.
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 condition 'when you do not already know their URLs' gives clear guidance on when to use search instead of direct navigation/reading tools. It does not explicitly name alternatives or exclusions, but the context is sufficient for an agent to route correctly among the listed siblings.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections. Dates show when Glama detected each change.
5 tool updates
- First observed
check_web_service - First observed
crawl_site - First observed
map_site - First observed
read_page - First observed
search_web
Frequently Asked Questions
Claiming proves that you control a remote MCP connector. It does not move, proxy, or interrupt the server.
Open the connector listing, choose Claim ownership, and sign in to Glama.
Complete one verification method:
GitHub identity — fastest for official registry listings. For a namespace such as
io.github.alice/server, link the matching GitHub user, then choose Claim with GitHub. An organization namespace such asio.github.acme/serveralso needs that organization to have installed the Glama AI GitHub App and approved its permissions, because GitHub discloses organization membership only to apps it has installed. Use HTTP or DNS when it has not.HTTP challenge — works when you can deploy a public file. Generate a token, publish the exact JSON Glama shows at
/.well-known/glama.jsonon the same origin as the connector, then choose Check HTTP challenge.DNS challenge — works when you control DNS but cannot change the server. Generate a token, create the exact TXT record Glama shows, wait for it to propagate, then choose Check DNS challenge.
After verification, Glama sends a confirmation email and gives you access to listing details, thumbnails, health checks, and analytics. Keep the HTTP file or DNS record in place: Glama periodically checks it and ownership remains verified while the token is discoverable.
The HTTP ownership file has this structure:
{
"$schema": "https://glama.ai/mcp/schemas/connector.json",
"claim": "glama_claim_..."
}Claim tokens are opaque, stable, and bound to the signed-in Glama account. They contain no email address or other personal information. If Glama can no longer discover a verified HTTP or DNS token, it starts a seven-day grace period before removing claim-based access. Restore the same token during that period to keep ownership verified. Never publish an email address, Glama session token, GitHub token, or connector credential as ownership proof.
If verification fails, confirm that you copied the current token exactly. The HTTP file must be public, return valid JSON with a successful HTTP response, and stay on the connector's origin. DNS changes may need more time to propagate. A claim cannot transfer to a different origin or hostname: if the connector target changes, Glama starts the grace period and the new target must be claimed separately after the previous claim is released.
For a connector linked to the official MCP Registry, registry updates continue to replace its name, description, and URL by default. After claiming, open Manage connector and enable Use Glama listing details as the source of truth if edits made on Glama should be preserved. Categories and thumbnails are always managed on Glama; registry linkage and technical connection settings continue to sync.
Control your server's listing on Glama, including description and metadata
Access analytics and receive server usage reports
Get monitoring and health status updates for your server
Feature your server to boost visibility and reach more users
To improve your MCP server's ranking:
Claim ownership of the server listing
Complete the server profile with an accurate description and thumbnail
Provide a test profile so Glama can connect to and evaluate the server
Keep tool definitions clear and complete to earn a high Tool Definition Quality Score (TDQS)
Route real usage through the Glama Gateway; more recorded successful server uses also improve the ranking
For users:
Full audit trail – every tool call is logged with inputs and outputs for compliance and debugging
Granular tool control – enable or disable individual tools per connector to limit what your AI agents can do
Centralized credential management – store and rotate API keys and OAuth tokens in one place
Change alerts – get notified when a connector changes its schema, adds or removes tools, or updates tool definitions, so nothing breaks silently
For server owners:
Proven adoption – public usage metrics on your listing show real-world traction and build trust with prospective users
Tool-level analytics – see which tools are being used most, helping you prioritize development and documentation
Direct user feedback – users can report issues and suggest improvements through the listing, giving you a channel you would not have otherwise
The connector status is unhealthy when Glama is unable to successfully connect to the server. This can happen for several reasons:
The server is experiencing an outage
The URL of the server is wrong
Credentials required to access the server are missing or invalid
If you are the owner of this MCP connector and would like to make modifications to the listing, including providing test credentials for accessing the server, please contact support@glama.ai.
Discussions
No comments yet. Be the first to start the discussion!
Related MCP Connectors
Turn any URL into clean Markdown and structured data. Scrape, crawl, search and extract.
Fetch pages as markdown, search web and news, extract structured data. For AI agents.
Web search, fetch, extract, and research for AI agents. Markdown output + AI-synthesized answers.
Read any web page as clean Markdown for AI agents: fetch, search, metadata, links. SSRF-safe.
Related MCP Servers
- AlicenseNot gradedqualityBmaintenanceProvides lightweight web crawling and scraping capabilities, enabling users to fetch pages as clean Markdown, recursively crawl domains, extract metadata, and perform search-and-crawl operations.5MIT
- FlicenseNot gradedqualityBmaintenanceEnables web search using DuckDuckGo and content retrieval from URLs, returning markdown with pagination support.-
- FlicenseAqualityDmaintenanceProvides web search capabilities across multiple engines and webpage content fetching to simplified Markdown. It enables AI assistants to access real-time internet information and extract text from specific URLs.213-
- AlicenseNot gradedqualityDmaintenanceFetches web pages and converts them to markdown for LLM consumption, supporting chunked reading and raw content extraction.MIT
Glama MCP Gateway
Add one secure layer between your agents and this server.
TDQS
Each tool targets a distinct operation: health checking, site mapping, single-page reading, multi-page crawling, and web search. The descriptions cross-reference each other to guide selection, leaving no ambiguity about when to use which tool.
All tool names follow a consistent verb_noun snake_case pattern: check_web_service, crawl_site, map_site, read_page, search_web. The naming style is uniform and predictable.
Five tools is a well-scoped set for a web reading service. Each tool covers a distinct need (discover, search, read, crawl, health check) and none feel redundant or superfluous.
The surface covers the full workflow: search to find URLs, map to discover site structure, read for single pages, crawl for bulk retrieval, and health check for service status. There are no obvious dead ends or missing core operations for the stated purpose.