The MCP Web Utilities Server provides web search, page fetching, and date utilities via MCP (stdio) or OpenAPI HTTP endpoints.
Search the Web (search_on_web): Query the web and retrieve a configurable number of results, each formatted as a titled Markdown link with a description.
Search Specific Websites (search_on_website): Same as web search but restricted to specified domains/sites.
Fetch a Webpage (fetch_webpage): Retrieve the content of any URL as simplified Markdown, using stealth crawling to avoid detection.
Get Current Date/Time (get_current_date): Retrieve the current UTC and local date-time in ISO format.
Provides a tool to fetch web pages and convert their content into simplified Markdown, facilitating easier reading and processing of web-based information.
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type @ followed by the MCP server name and your instructions, e.g., "@MCP Web Utilities Server search for the latest news on OpenAI and summarize the top result"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
Lightweight server exposing web search and page fetching through:
MCP (stdio) for MCP clients
OpenAPI HTTP (FastAPI)
search_on_web and search_on_website using ddgs (DDGS | Dux Distributed Global Search, a multi-source search engine).
fetch_webpage that returns simplified Markdown using crawl4ai with stealth settings.
Python 3.13+
uv installed
Install uv on Windows (PowerShell):
powershell -ExecutionPolicy ByPass -c "irm https://astral.sh/uv/install.ps1 | iex"uv syncThen activate the virtual environment and run the crawler setup:
.venv\Scripts\activate
crawl4ai-setupMCP (stdio):
uv run src\main.pyOr when developing:
start_mcp_server.cmdOpenAPI HTTP (127.0.0.1:8000):
uv run uvicorn src.mainhttp:app --host 127.0.0.1 --port 8000Or when developing:
start_mcp_server_http.cmdOpenAPI schema:
http://127.0.0.1:8000/openapi.jsonTo use this server in LM Studio, add the following to your MCP settings (mcp.json):
{
"mcpServers": {
"web-utilities": {
"command": "uv",
"args": [
"--directory",
"D:\\Dev\\McpServer",
"run",
"src\\main.py"
]
}
}
}Note: Replace D:\\Dev\\McpServer with the actual path to your project.
search_on_web(query: str, results: int = 10) -> str
Returns results formatted as:
[title](url)
descriptionsearch_on_website(query: str, sites: list[str], results: int = 10) -> str
Same format, restricted to the provided sites.
fetch_webpage(target_url: str) -> str
Returns simplified Markdown for the target page.
GET /search/web?query=...&results=10
GET /search/website?query=...&sites=example.com&sites=docs.python.org&results=10
GET /webpage?target_url=https://example.com
GET /date
python -m unittest src.testsAvoid writing to STDOUT (e.g., print) when the server is running; it will break JSON RPC communication.
Network-dependent tests may fail if external services are blocked in the current environment.
Fetches a webpage and returns a simplified markdown representation.
| Name | Required | Description | Default |
|---|---|---|---|
| target_url | Yes |
| Name | Required | Description |
|---|---|---|
| result | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure. It mentions 'returns a simplified markdown representation', which adds some context about output format. However, it fails to disclose critical traits such as error handling, rate limits, authentication needs, or whether it's a read-only operation, leaving significant gaps for a tool that interacts with external resources.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is extremely concise with a single sentence that front-loads the core action and outcome. There is no wasted language, making it efficient and easy to parse for an agent.
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 an output schema, the description doesn't need to explain return values in detail. However, with no annotations and low schema coverage, it lacks completeness in behavioral aspects like safety or performance. The description is adequate for a simple fetch operation but misses key contextual details for reliable use.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, so the description must compensate. It implies the parameter is a URL for fetching, but doesn't add specific meaning beyond what the schema's property name 'target_url' suggests. The baseline is 3 because the description provides minimal context without detailing format constraints or examples.
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 'fetches' and resource 'webpage', specifying what the tool does. It distinguishes from siblings like 'search_on_web' by focusing on fetching a specific URL rather than searching. However, it doesn't explicitly contrast with 'search_on_website', which might involve similar operations.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is provided on when to use this tool versus alternatives like 'search_on_web' or 'search_on_website'. The description implies usage for fetching a specific URL, but it lacks explicit when-to-use or when-not-to-use instructions, leaving the agent to infer context.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Returns current UTC and local date-time strings in ISO format.
Return format: { "utc": "YYYY-MM-DDTHH:MM:SSZ", "local": "YYYY-MM-DD HH:MM:SS" }
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
| Name | Required | Description |
|---|---|---|
| result | Yes |
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 key behavioral traits: it returns current date-time (implying real-time data), specifies UTC and local formats, and details the exact return structure. However, it does not mention potential issues like timezone dependencies or performance characteristics, leaving some gaps.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is appropriately sized and front-loaded: the first sentence states the core purpose, and the subsequent lines provide essential return format details without redundancy. Every sentence earns its place by adding value (e.g., clarifying ISO format and structure).
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 low complexity (0 parameters, no annotations, simple output), the description is complete enough. It explains what the tool does, the return format, and includes an output schema implicitly in the description. No additional context is needed for such a straightforward utility 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 tool has 0 parameters, and schema description coverage is 100% (as there are no parameters to describe). The description does not need to add parameter semantics, so it appropriately focuses on output. A baseline of 4 is applied since no parameters exist, and the description efficiently handles this by not discussing inputs.
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 with specific verbs ('Returns') and resources ('current UTC and local date-time strings'), and distinguishes it from sibling tools (which are web-related, while this is a date/time utility). It goes beyond just restating the name by specifying the format and content of the return values.
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 context through the return format details (e.g., when ISO format date-time strings are needed), but it does not explicitly state when to use this tool versus alternatives or provide any exclusions. Given the sibling tools are unrelated (web fetching/searching), no direct comparison is needed, but general guidance is lacking.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Searches the web for information related to the given query.
Return format :
result 1 title
result 1 description
result 2 title
result 2 description
...
Use relevants links with fetch_webpage to get all the page content
| Name | Required | Description | Default |
|---|---|---|---|
| query | Yes | ||
| results | No |
| Name | Required | Description |
|---|---|---|
| result | Yes |
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 return format and suggests using 'fetch_webpage' for detailed content, which adds useful behavioral context. However, it doesn't mention potential limitations like rate limits, authentication needs, or error handling, leaving gaps for a web 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?
The description is appropriately sized with three sentences that each serve a purpose: stating the tool's function, specifying the return format, and suggesting a follow-up action. It's front-loaded with the core purpose, though the return format details could be more concise. Overall, it's efficient with little 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 the tool's moderate complexity (web search with 2 parameters), no annotations, and the presence of an output schema (which handles return values), the description is reasonably complete. It covers the purpose, output format, and integration with 'fetch_webpage,' but lacks details on parameter semantics and some behavioral aspects like error handling.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has 0% description coverage, so the description must compensate. It mentions 'given query' which aligns with the 'query' parameter but doesn't explain the 'results' parameter or its default value of 10. The description adds minimal meaning beyond the schema, failing to adequately address the coverage gap.
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 as 'Searches the web for information related to the given query,' which is a specific verb+resource combination. However, it doesn't explicitly differentiate from its sibling 'search_on_website,' which might search a specific website rather than the broader web. The purpose is clear but lacks sibling differentiation.
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 by mentioning 'Use relevants links with `fetch_webpage` to get all the page content,' which suggests a workflow with a sibling tool. However, it doesn't provide explicit guidance on when to use this tool versus alternatives like 'search_on_website' or general web search contexts. The guidance is implied but not comprehensive.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Searches the web for information related to the given query, restricted to specific sites.
Return format :
result 1 title
result 1 description
result 2 title
result 2 description
...
Use relevants links with fetch_webpage to get all the page content
| Name | Required | Description | Default |
|---|---|---|---|
| query | Yes | ||
| sites | Yes | ||
| results | No |
| Name | Required | Description |
|---|---|---|
| result | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure. It mentions the return format and suggests using 'fetch_webpage' for full content, which adds some context. However, it lacks critical details like whether this is a read-only operation, potential rate limits, authentication needs, or error handling. The description doesn't contradict annotations (none exist), but it's insufficient for a tool with behavioral implications.
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 relatively concise but could be more front-loaded. The first sentence states the purpose clearly, but the return format details and reference to 'fetch_webpage' might be better structured. It's not overly verbose, but some sentences (like the return format example) could be streamlined for efficiency.
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 moderate complexity (3 parameters, no annotations, but with an output schema), the description is partially complete. It covers the basic purpose and hints at usage, but gaps remain in parameter explanations and behavioral details. The output schema likely handles return values, so the description's focus on format is somewhat redundant, but overall it's minimally adequate with clear room for improvement.
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 0%, so the description must compensate for undocumented parameters. It mentions 'query' and 'sites' implicitly but doesn't explain their semantics (e.g., what 'sites' expects as input format). It omits the 'results' parameter entirely. The description adds minimal value beyond the schema, failing to address the coverage gap adequately.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose: 'Searches the web for information related to the given query, restricted to specific sites.' This specifies the verb ('searches'), resource ('web'), and key constraint ('restricted to specific sites'). However, it doesn't explicitly differentiate from its sibling 'search_on_web', which likely performs broader web searches without site restrictions.
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 context by mentioning site restrictions and referencing 'fetch_webpage' for detailed content, suggesting this tool is for initial search results. However, it doesn't explicitly state when to use this versus 'search_on_web' (e.g., for site-specific vs. general web searches) or provide clear alternatives or exclusions.
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.
v0.1.0fetch_webpageget_current_datesearch_on_websearch_on_websiteScored across 4 tools
There is significant overlap between 'search_on_web' and 'search_on_website' - both perform web searches with nearly identical descriptions and return formats, differing only in site restriction. 'fetch_webpage' is distinct for content retrieval, but 'get_current_date' feels disconnected from the web utilities theme, creating conceptual ambiguity about the server's purpose.
Three of four tools follow a consistent verb_noun pattern with snake_case ('fetch_webpage', 'search_on_web', 'search_on_website'), which is good. However, 'get_current_date' uses a different verb style ('get' vs 'fetch/search'), breaking the pattern slightly but maintaining readability.
With only 4 tools, the count feels thin for a 'Web Utilities Server' - one would expect more comprehensive web-related functionality. However, the tools do cover basic web operations (fetching, searching), so it's borderline rather than severely inadequate.
For a web utilities server, there are significant gaps: no tools for analyzing webpage content (beyond fetching), no HTTP request utilities, no cookie/session management, and no web scraping capabilities beyond basic fetching. The inclusion of 'get_current_date' feels out of scope, further highlighting the incomplete coverage of web-related operations.
Web search, URL content extraction to Markdown, site mapping, and recursive web crawler.
Web data tools for AI agents: pages as markdown, search, maps, commerce, jobs, AI answers.
Web search, fetch, extract, and research for AI agents. Markdown output + AI-synthesized answers.
Fetch pages as markdown, search web and news, extract structured data. For AI agents.
