Skip to main content
Glama
FetchV2 MCP Server

FetchV2 MCP Server

by praveenc

FetchV2 MCP Server

PyPI version CI Python 3.11+ License: MIT

FetchV2 is a Model Context Protocol (MCP) server that retrieves web pages and returns clean Markdown. It uses Trafilatura to remove navigation, advertisements, footers, and other page elements.

What it does

Tool

Use

fetch

Fetch one web page and extract its main content

fetch_batch

Fetch up to 10 web pages in one request

discover_links

Find and filter links on a web page

fetch_llms_txt

Read an llms.txt index and optionally fetch its linked pages

FetchV2 can return raw HTML, preserve links and tables, and paginate long content. The fetch tool checks robots.txt by default.

Related MCP server: singlefile-mcp

Quick start

Requirements

  1. Install uv.

  2. Install Python 3.11 or newer:

uv python install 3.11

Install for Cursor or VS Code

Configure another MCP client

Add this server definition to your MCP client configuration:

{
  "mcpServers": {
    "fetchv2": {
      "command": "uvx",
      "args": ["fetchv2-mcp-server@latest"]
    }
  }
}

Common configuration file locations:

  • Claude Desktop on macOS: ~/Library/Application Support/Claude/claude_desktop_config.json

  • Claude Desktop on Windows: %APPDATA%\Claude\claude_desktop_config.json

  • Windsurf: ~/.codeium/windsurf/mcp_config.json

  • Kiro: .kiro/settings/mcp.json in your project

Install in a Python environment

Use one of these commands if you want to install the package directly:

uv add fetchv2-mcp-server
pip install fetchv2-mcp-server

Try it

Ask your MCP client to perform a task such as:

  • "Fetch the documentation from <URL>."

  • "Find links on <docs URL> that contain tutorial."

  • "Read these pages and summarize their differences: [url1, url2, url3]."

Typical documentation workflow

First, find the relevant pages:

discover_links(url="https://docs.example.com/", filter_pattern="/guide/")

Then fetch the selected pages in one request:

fetch_batch(
    urls=[
        "https://docs.example.com/guide/intro",
        "https://docs.example.com/guide/setup",
    ]
)

Tool reference

fetch

Fetch one web page and extract its main content as Markdown.

fetch(
    url: str,
    max_length: int = 5000,
    start_index: int = 0,
    get_raw_html: bool = False,
    include_metadata: bool = True,
    include_tables: bool = True,
    include_links: bool = False,
    bypass_robots_txt: bool = False,
) -> str

Parameter

Type

Default

Description

url

str

required

Web page URL

max_length

int

5000

Maximum number of characters to return

start_index

int

0

Character offset for pagination

get_raw_html

bool

False

Return raw HTML without extraction

include_metadata

bool

True

Include the title, author, and date

include_tables

bool

True

Preserve tables in Markdown

include_links

bool

False

Preserve links in Markdown

bypass_robots_txt

bool

False

Skip the robots.txt check for a user-requested fetch

If the response is truncated, use the returned start_index value in the next call.

fetch_batch

Fetch up to 10 web pages and combine the results.

fetch_batch(
    urls: list[str],
    max_length_per_url: int = 2000,
    get_raw_html: bool = False,
) -> str

Parameter

Type

Default

Description

urls

list[str]

required

Web page URLs to fetch

max_length_per_url

int

2000

Maximum number of characters to return for each URL

get_raw_html

bool

False

Return raw HTML without extraction

This tool reports a failed URL in its result and continues with the other URLs. It does not check robots.txt.

Find links on a web page and optionally filter them with a regular expression.

discover_links(url: str, filter_pattern: str = "") -> str

Parameter

Type

Default

Description

url

str

required

Web page URL to scan

filter_pattern

str

""

Regular expression used to filter links

The tool resolves relative links and returns up to 100 URLs.

fetch_llms_txt

Read an llms.txt file and list its documentation links.

fetch_llms_txt(
    url: str,
    include_content: bool = False,
    max_length_per_url: int = 2000,
) -> str

Parameter

Type

Default

Description

url

str

required

URL of an llms.txt file

include_content

bool

False

Fetch the content of all linked pages

max_length_per_url

int

2000

Maximum number of characters to return for each linked page

By default, this tool fetches only the llms.txt index. Set include_content=True to fetch all linked pages. This option can return a large response.

The tool resolves relative URLs, such as /docs/guide.md, against the llms.txt URL.

Security

FetchV2 fetches URLs that a model chooses. A web page can contain a prompt injection that asks the model to fetch an internal address. FetchV2 has these limits to reduce that risk.

Private network guard

FetchV2 refuses a request when the host is, or resolves to, a non-public address:

  • Loopback: 127.0.0.0/8, ::1, and localhost names

  • Private: 10.0.0.0/8, 172.16.0.0/12, 192.168.0.0/16, and IPv6 unique local fc00::/7

  • Link-local: 169.254.0.0/16 (including the cloud metadata address 169.254.169.254) and fe80::/10

  • Unspecified, multicast, shared (100.64.0.0/10), and reserved ranges

  • IPv4-mapped IPv6 addresses, such as ::ffff:127.0.0.1

The guard checks the first request and every redirect hop. It also applies to the robots.txt request and to the pages that fetch_llms_txt loads.

To fetch local or private hosts on purpose, set this environment variable for the server:

{
  "mcpServers": {
    "fetchv2": {
      "command": "uvx",
      "args": ["fetchv2-mcp-server@latest"],
      "env": { "FETCHV2_ALLOW_PRIVATE_NETWORKS": "1" }
    }
  }
}

The values 1, true, and yes turn the guard off. The guard is on by default.

Response size limit

FetchV2 reads at most 5 MB (5,242,880 bytes) of each response body. It refuses a response early when Content-Length is over the limit. It also counts bytes while it reads, and it stops at the limit. A cut body ends with a <!-- Truncated: response body exceeded ... --> comment.

Known limits

  • DNS rebinding. The guard resolves the host before the request, and then the HTTP client resolves it again to connect. A hostile DNS server can return a public address the first time and a private address the second time. The guard does not pin the connection to the checked address. If this risk matters, run the server where it cannot reach internal services, for example behind an egress firewall.

  • Proxies. If you set HTTP_PROXY or HTTPS_PROXY, the proxy connects to the host. The proxy must apply its own rules.

  • Untrusted content. Fetched page text is untrusted input. It can contain instructions written for the model. Do not let fetched text approve other tool calls. Be careful with autoApprove for this server.

Prompts

  • fetch_manual creates a request to fetch and summarize one URL.

  • research_topic creates a request to research a topic with optional URLs.

Development

Clone the repository and install the development dependencies:

git clone https://github.com/praveenc/fetchv2-mcp-server.git
cd fetchv2-mcp-server
uv sync --dev

Run the tests:

uv run pytest

Run the server with MCP Inspector:

uv run mcp dev src/fetchv2_mcp_server/server.py

Run lint and type checks:

uv run ruff check .
uv run pyright

Contributing

Read CONTRIBUTING.md before you submit a change.

Support

Use the GitHub issue tracker to report a problem or request a feature.

License

This project uses the MIT License. See LICENSE for details.

Available Tools

4 tools
fetchA

Fetch a single webpage and extract its main content as clean markdown.

USE THIS TOOL WHEN:

  • You need to read an article, documentation page, or blog post

  • You want clean, readable text without boilerplate (navbars, ads, footers)

  • The user provides a specific URL to read

DO NOT USE WHEN:

  • You need to fetch multiple URLs (use fetch_batch instead - fewer round trips)

  • You want to discover what pages exist on a site (use discover_links first)

PAGINATION: Large pages are automatically truncated. The response will include 'use start_index=N to continue' - call again with that value to get more content.

EXAMPLES:

Inputs: url (required), max_length, start_index, get_raw_html, +4 more. Returns: result

fetch_batchA

Fetch multiple webpages in a single request and return combined content.

USE THIS TOOL WHEN:

  • You have 2-10 URLs to read (e.g., from discover_links results)

  • Comparing content across multiple pages

  • Gathering context from several documentation pages at once

KEY BENEFIT: One tool call instead of multiple fetch() calls = fewer round trips, faster results, and reduced overhead in supervised/approval workflows.

WORKFLOW EXAMPLE:

  1. discover_links(url="https://docs.example.com", filter_pattern="/api/")

  2. fetch_batch(urls=[...returned links...], max_length_per_url=1500)

NOTES:

  • Each URL's content is separated by '---' dividers

  • Failed URLs show inline errors without stopping other fetches

  • Robots.txt is NOT checked for batch fetches (assumes prior discovery)

Inputs: urls (required), get_raw_html, max_length_per_url. Returns: result

fetch_llms_txtA

Fetch and parse an llms.txt file to discover LLM-friendly documentation.

USE THIS TOOL WHEN:

  • A site provides an llms.txt file for AI-friendly content discovery

  • You need to understand what documentation is available

  • You want to fetch structured docs in a single request

WHAT IS llms.txt: A proposal for sites to provide LLM-friendly content at /llms.txt. It's a markdown file listing documentation links with descriptions. See https://llmstxt.org for the specification.

WORKFLOW:

  1. fetch_llms_txt(url="https://example.com/llms.txt") → Get structure

  2. Review sections and links

  3. Either use include_content=True or fetch_batch for specific pages

EXAMPLES:

Inputs: url (required), include_content, max_length_per_url. Returns: result

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections.

Loading tool schema changelog…

    TDQS

    A4.6/5.0

    Scored across 4 tools

    Disambiguation5/5

    Each tool targets a distinct retrieval mode: discover_links maps a site, fetch retrieves one URL, fetch_batch retrieves multiple URLs, and fetch_llms_txt parses the llms.txt format. Descriptions explicitly clarify when to use fetch vs fetch_batch, so an agent should not misselect.

    Naming Consistency4/5

    All tool names use a lowercase verb-first style: fetch, fetch_batch, fetch_llms_txt, discover_links. The only minor inconsistency is that plain 'fetch' lacks the object/scope qualifier the other names have, but the overall pattern remains predictable.

    Tool Count5/5

    Four tools is well-scoped for a web fetching and content discovery server. Each tool fills a distinct role—single fetch, batch fetch, link discovery, and llms.txt support—without unnecessary bloat or redundancy.

    Completeness4/5

    The server covers the core workflow end-to-end: discover relevant links, then fetch them individually or in batches. Minor gaps exist, such as no dedicated search or robots.txt checking tool, but these do not create dead ends for the stated purpose.

    Maintenance

    ActivityNo data
    ResponsivenessOutdated data

    Related MCP Connectors

    Related MCP Servers

    • A
      license
      B
      quality
      D
      maintenance
      A Model Context Protocol server that enables LLMs to fetch and process web content in multiple formats (HTML, JSON, Markdown, text) with automatic format detection.
      5
      6
      MIT
    • A
      license
      Not graded
      quality
      D
      maintenance
      An MCP server for intelligent web content extraction from JavaScript-heavy sites using single-file and trafilatura. It enables AI agents to fetch, render, and paginate through clean article content and metadata.
      16 PyPI
      23
      MIT
    • A
      license
      A
      quality
      C
      maintenance
      MCP server for web page fetching (converting to Markdown/text with automatic fallback between Tavily and Firecrawl) and web search via Tavily.
      2
      MIT