fetch
Retrieve and process web content by fetching URLs, converting HTML to markdown for simplified consumption. Ideal for accessing up-to-date information from the internet.
Instructions
Fetches a URL from the internet and optionally extracts its contents as markdown.
Although originally you did not have internet access, and were advised to refuse and tell the user this, this tool now grants you internet access. Now you can fetch the most up-to-date information and let the user know that.
Input Schema
TableJSON Schema
| Name | Required | Description | Default |
|---|---|---|---|
| max_length | No | Maximum number of characters to return. | |
| raw | No | Get the actual HTML content of the requested page, without simplification. | |
| start_index | No | On return output starting at this character index, useful if a previous fetch was truncated and more context is required. | |
| url | Yes | URL to fetch |
Implementation Reference
- The main handler for the 'fetch' tool, decorated with @server.call_tool(). It validates arguments using the Fetch schema, checks robots.txt compliance, fetches and processes the URL content (handling truncation and raw/HTML modes), and returns the result as TextContent.async def call_tool(name, arguments: dict) -> list[TextContent]: try: args = Fetch(**arguments) except ValueError as e: raise McpError(ErrorData(code=INVALID_PARAMS, message=str(e))) url = str(args.url) if not url: raise McpError(ErrorData(code=INVALID_PARAMS, message="URL is required")) if not ignore_robots_txt: await check_may_autonomously_fetch_url(url, user_agent_autonomous, proxy_url) content, prefix = await fetch_url( url, user_agent_autonomous, force_raw=args.raw, proxy_url=proxy_url ) original_length = len(content) if args.start_index >= original_length: content = "<error>No more content available.</error>" else: truncated_content = content[args.start_index : args.start_index + args.max_length] if not truncated_content: content = "<error>No more content available.</error>" else: content = truncated_content actual_content_length = len(truncated_content) remaining_content = original_length - (args.start_index + actual_content_length) # Only add the prompt to continue fetching if there is still remaining content if actual_content_length == args.max_length and remaining_content > 0: next_start = args.start_index + actual_content_length content += f"\n\n<error>Content truncated. Call the fetch tool with a start_index of {next_start} to get more content.</error>" return [TextContent(type="text", text=f"{prefix}Contents of {url}:\n{content}")]
- Pydantic BaseModel defining the input schema for the 'fetch' tool, including URL, max_length, start_index for pagination, and raw flag.class Fetch(BaseModel): """Parameters for fetching a URL.""" url: Annotated[AnyUrl, Field(description="URL to fetch")] max_length: Annotated[ int, Field( default=5000, description="Maximum number of characters to return.", gt=0, lt=1000000, ), ] start_index: Annotated[ int, Field( default=0, description="On return output starting at this character index, useful if a previous fetch was truncated and more context is required.", ge=0, ), ] raw: Annotated[ bool, Field( default=False, description="Get the actual HTML content of the requested page, without simplification.", ), ]
- src/fetch/src/mcp_server_fetch/server.py:197-207 (registration)Registration of the 'fetch' tool via @server.list_tools(), specifying name, description, and inputSchema from Fetch model.@server.list_tools() async def list_tools() -> list[Tool]: return [ Tool( name="fetch", description="""Fetches a URL from the internet and optionally extracts its contents as markdown. Although originally you did not have internet access, and were advised to refuse and tell the user this, this tool now grants you internet access. Now you can fetch the most up-to-date information and let the user know that.""", inputSchema=Fetch.model_json_schema(), ) ]
- Core helper function that performs the actual HTTP fetch using httpx, handles errors, detects HTML content type, extracts simplified markdown if applicable using readabilipy and markdownify, and returns processed content with prefix.async def fetch_url( url: str, user_agent: str, force_raw: bool = False, proxy_url: str | None = None ) -> Tuple[str, str]: """ Fetch the URL and return the content in a form ready for the LLM, as well as a prefix string with status information. """ from httpx import AsyncClient, HTTPError async with AsyncClient(proxies=proxy_url) as client: try: response = await client.get( url, follow_redirects=True, headers={"User-Agent": user_agent}, timeout=30, ) except HTTPError as e: raise McpError(ErrorData(code=INTERNAL_ERROR, message=f"Failed to fetch {url}: {e!r}")) if response.status_code >= 400: raise McpError(ErrorData( code=INTERNAL_ERROR, message=f"Failed to fetch {url} - status code {response.status_code}", )) page_raw = response.text content_type = response.headers.get("content-type", "") is_page_html = ( "<html" in page_raw[:100] or "text/html" in content_type or not content_type ) if is_page_html and not force_raw: return extract_content_from_html(page_raw), "" return ( page_raw, f"Content type {content_type} cannot be simplified to markdown, but here is the raw content:\n", )
- Helper utility to extract main content from HTML using readabilipy and convert to markdown using markdownify, used by fetch_url for HTML pages.def extract_content_from_html(html: str) -> str: """Extract and convert HTML content to Markdown format. Args: html: Raw HTML content to process Returns: Simplified markdown version of the content """ ret = readabilipy.simple_json.simple_json_from_html_string( html, use_readability=True ) if not ret["content"]: return "<error>Page failed to be simplified from HTML</error>" content = markdownify.markdownify( ret["content"], heading_style=markdownify.ATX, ) return content