Site Sampler MCP Server

Ask a chat assistant which pages of a site to check. It reads the sitemap, sorts every page into page types, and draws a random sample from each one, so a claim about the whole site rests on more than the homepage.

Add It To Your Assistant

  • Claude
  • ChatGPT
  • Gemini
  • Grok
  • Perplexity
  • Le Chat
  • Meta Muse
  • Manus
  • Copilot
# Connector address
https://mcp.jakelabate.com/site-sampler
# Then ask
Pick a fair sample of pages for me to audit, and tell me how you chose them. Ask me for the site first.

No sign-in. It reads public sitemaps, changes nothing and keeps nothing.

22

Sitemap addresses

Places it looks for a sitemap when robots.txt names none.

10

Pages per type

Drawn from each page type, by default.

100

Pages per sample

The most pages in one sample, by default.

4

Tools

None of them changes or stores anything.

How To Add It

  1. In Claude, open Customize, then Connectors, choose Add custom connector and paste the address. Claude's own instructions have the details.
  2. In any other assistant that supports MCP, add the address as a remote MCP server.
  3. Ask it about a site. The prompt in the box works as it is copied.

What To Ask

  • "What is this site made of?" It reads the sitemap and sorts every page into page types by address pattern, with a count for each. find_page_types
  • "Which pages should I check to audit this site?" It draws a random sample from every page type, plus the homepage, about and contact pages. draw_sample
  • "Give me the same pages you gave me last month." The same seed always draws the same pages, so a repeat audit is run on the same sample. draw_sample
  • "I only care about the blog. Leave tag pages out." It narrows the site with include and exclude before sampling. draw_sample
  • "12 of the 60 pages I checked had no meta description. How many is that site-wide?" It weights each page type by its size and returns the share with a margin of error. estimate_from_sample
  • "How many pages do I have to check to be within 5 points?" It works out the sample size and shows the arithmetic. sample_size

What It Returns

A small shop of 31 pages, sent to find_page_types. This is the server's own answer, run when this page was built.

find_page_types.jsonJSON
{
  "pages": 31,
  "page_types": [
    {
      "type": "/products/{slug}",
      "pages": 8,
      "example": "https://www.example.com/products/camp-mug"
    },
    {
      "type": "/blog/{slug}",
      "pages": 5,
      "example": "https://www.example.com/blog/breaking-in-leather"
    },
    {
      "type": "/stores/{slug}",
      "pages": 4,
      "example": "https://www.example.com/stores/austin"
    },
    {
      "type": "/{slug}",
      "pages": 4,
      "example": "https://www.example.com/about"
    },
    {
      "type": "single pages",
      "pages": 4,
      "example": "https://www.example.com/"
    },
    {
      "type": "/collections/{slug}",
      "pages": 3,
      "example": "https://www.example.com/collections/apparel"
    },
    {
      "type": "/news/{number}/{number}/{slug}",
      "pages": 3,
      "example": "https://www.example.com/news/2025/03/spring-catalog"
    }
  ]
}

A page type is the closest thing to a template that can be seen from outside. A template problem is one fix across every page of the type, which is why the sample is drawn type by type.

How It Finds The Pages

The server reads the site's own list of its pages. Nothing is crawled.

  1. robots.txt first. A Sitemap line there is the site saying where its sitemap is.
  2. Then the usual places. With no Sitemap line, 22 common addresses are tried, the most likely first.
  3. Then every file the index lists. Sitemap indexes are followed down to the files that list pages. Gzipped files are read too.
  4. Only pages on that site are kept. Addresses on other hosts, images, PDFs and repeats are set aside and counted.

A site with no sitemap, or one that refuses requests from servers, can be sampled from a list of addresses instead: up to 3,000 in urls.

How Page Types Are Formed

A page type is an address pattern: the folders that stay the same, with the part that changes written as a placeholder. /blog/how-to-size-a-boot and /blog/layering-for-rain are both /blog/{slug}.

  • A part with pages beneath it is a section. It keeps its name, so /blog/ and /products/ stay apart.
  • 3 or more pages side by side are one type. The part that changes is written {slug}, or {number}, {date} or {id} when every one is a number, a date or a long id.
  • A folder with more than 12 sections keeps only the real ones. A section keeps its name when it has at least 5 pages and 5% of the folder. The rest become {slug}, which is how sixty product categories become one type.
  • A pattern that fits one page is not a type. The homepage, hub pages and one-off pages are grouped as single pages.
  • Language folders are set aside first. /fr/blog/x and /blog/x are one type. A folder counts as a language only when it is a real language or country code and the site has several, or it holds most of the site.

The grouping can be changed. page_type_rules names a type by hand, include and exclude narrow the site, group_by: "first_folder" groups by first folder only, and languages: "separate" keeps language folders apart.

How The Sample Is Drawn

  • Every page type gets at least one page. No type goes unchecked. Past the first page, larger types get proportionally more, up to 10 per type and 100 in all by default.
  • Pages are chosen at random within a type. Each page gets a number from a hash of the seed and its address, and the smallest numbers are the sample. No page is hand-picked, and the order of the sitemap does not matter.
  • The same seed draws the same pages. The seed defaults to the site's domain, so asking again repeats the sample and an audit can be run again on the same pages. A new seed draws a fresh one.
  • When the site changes, most of the sample stays. A page keeps its number, so adding or removing pages only swaps the few whose rank changed.
  • The homepage, about and contact pages are always in. The homepage is the top of the site. The about and contact pages are taken when the sitemap lists them. So are any pages asked for by address. They count as themselves, outside the random draw.

Every sampled page comes back with its type and how many pages of that type it stands for.

How The Estimate Is Made

Send back what was found on each sampled page, a yes or no or a number, and the server works out the figure for the whole site.

  • Each type is weighted by its size. The site figure is the sum over types of the type's share of the site times what its sample showed.
  • The margin of error is the standard one for a stratified sample. For each type: pages squared, times one minus the share measured, times the spread within its sample, divided by the pages measured. Summed, square-rooted, and scaled to 90, 95 or 99% confidence.
  • Each type also gets its own exact range. The Clopper-Pearson range holds for small samples, and it does not shrink to nothing when every page measured gave the same answer.
  • It says when the sample is too thin. A type with one measured page, a type with none, and a sample under 30 pages are each named, with what that means for the figure.

100 pages chosen at random put a yes or no share within about 10 points, 95 times in 100, on a site of any size. A draw that holds a very large type to 10 pages is wider than that, and draw_sample states the margin its own sample gives. sample_size works out the number of pages for any other margin.

Limits

One call reads this much and no more. When a limit is reached the answer says so and names what was not read. Nothing is cut off silently.

  • 45 requests. Files of a large sitemap index are read in an order that spreads across the whole index, so what was read is a cross-section of the site and not its first section.
  • 4 MB of sitemap. Counted after decompression.
  • 2,000 pages sorted into types. When the files list more, an evenly spaced share is taken from every file, and page counts are stated as estimates.
  • 20 seconds. For the whole call.

To read one part of a large site in full, send that part's own sitemap in sitemap_url.

The 4 Tools

  • find_page_types Reads a site's sitemap and sorts every page into page types by address pattern, with how many pages each type has and example addresses.
  • draw_sample Picks the pages to look at.
  • estimate_from_sample Turns what was found on the sampled pages into a figure for the whole site, with a margin of error.
  • sample_size Works out how many pages have to be measured for a yes or no share to land within a chosen margin of error, for a site or a page type of a given size.

From A Fair Sample To A Plan

A sample tells you which page types carry a problem and how much of the site that is. Deciding what to fix first, and proving it worked, is the work. That is what an engagement is for.