parkour-mcp

# Parkour MCP

> **parkour**
> 
> _"an activity in which people move quickly around buildings and objects in a city while performing jumps and other skilful movements, usually trying to move between points as quickly, smoothly, and safely as possible"_
>
> -- [Cambridge Dictionary](https://dictionary.cambridge.org/dictionary/english/parkour)

Parkour is a content exploration toolkit that helps LLMs surface high signal, unsummarized web content. It makes extensive use of clean APIs and Markdown conversion to enable targeted content extraction and knowledge synthesis. A rolling 2Q page cache keeps recently visited pages in memory so that follow-up requests (section extraction, BM25 search, slice retrieval, comparison pivots) are served quickly and without additional round-trips. While primarily designed for Claude Code and Claude Desktop, it should be adaptable to most agentic toolchain needs.

API integrations:
- Kagi Search
- Semantic Scholar
- arXiv
- IETF
- deps.dev (library package lookups)
- GitHub
- MediaWiki (Wikipedia and other MediaWiki sites — dedicated tool with footnote and inline-citation resolution)
- Reddit (userless OAuth API, oauth.reddit.com)
- Discourse (header-detected, raw markdown API)

## Why Parkour?
What sets Parkour apart from the standard approaches are three principles:

### Tool calls should participate in steering the LLM.

We design our tool outputs with the LLM in mind. The LLM is our immediate user, and if our user has a good experience the humans behind them have an even better experience.

The standout feature of Parkour is a frontmatter tool envelope that intelligently advises the LLM and steers its decisionmaking. This is a fancy way of saying "our tool payloads are prefaced with instructional YAML frontmatter". It's a technique that is simple on its face but deceptively powerful.

- Frontmatter leverages the LLM's existing document training to prime the next tool decision. Envelope fields are relevant to the activity at hand, and are positioned for actionability.
- The key:value pairs of YAML are self-documenting for both humans and LLMs, giving us a free out of band channel that doesn't require a new MCP standard.
- The tool outputs proactively steer the LLM toward sources of high signal and away from dead ends. This adds a small amount of tool latency for the background web calls we perform, but every unnecessary tool call we avoid pays dividends on that investment.
- We maintain a design document to ensure that the frontmatter envelope is used in a consistent fashion across tools. You can read more about it [here](https://github.com/blightbow/parkour-mcp/blob/main/docs/frontmatter-standard.md).

Parkour also intercepts requests for content from websites with robust first-party APIs. When the LLM asks to fetch a URL that belongs to a known source, the server skips the generic HTTP-fetch-and-convert path and calls the source's structured API directly. Faster, richer metadata, no scraping:

| Source | Detection | API used |
|--------|-----------|----------|
| Wikipedia | `/wiki/` URLs | MediaWiki API (clean markdown, footnotes, no navboxes) |
| arXiv | `/abs/`, `/pdf/` URLs | Atom API (authors, affiliations, categories, versions) |
| Semantic Scholar | `semanticscholar.org/paper/` | S2 Graph API (bypasses CAPTCHA) |
| DOI | `doi.org/10.*` URLs | Content negotiation (CrossRef/DataCite metadata) |
| GitHub | `github.com/*` | REST API (bypasses JS SPA) |
| Reddit | `reddit.com`, `redd.it` | Userless OAuth API (`oauth.reddit.com`, anonymous token, no account or API key) |
| Discourse | `x-discourse-route` response header | JSON API with raw author markdown |
| IETF | `rfc-editor.org/rfc/rfcN[.json]`, `datatracker.ietf.org` | RFC Editor JSON / Datatracker REST. `.html`/`.txt`/`.xml` body URLs deliberately fall through to the generic HTML pipeline so `section=` / `search=` work over the rendered RFC. |

For example, asking Parkour to fetch `https://arxiv.org/abs/1706.03762` doesn't scrape the landing page. It returns structured metadata via the Atom API, with frontmatter hints pointing to the HTML full text and a Semantic Scholar cross-reference for citation counts:

```
>>> web_fetch_incisive("https://arxiv.org/abs/1706.03762")
---
title: Attention Is All You Need
source: https://arxiv.org/abs/1706.03762v7
api: arXiv
full_text: Use WebFetchIncisive with https://arxiv.org/html/1706.03762v7 for full paper text with search/slices
see_also: ARXIV:1706.03762v7 with SemanticScholar for citation counts
shelf: 1 tracked (0 confirmed) — use ResearchShelf to review
---

# Attention Is All You Need

**Authors:** Ashish Vaswani, Noam Shazeer, Niki Parmar, Jakob Uszkoreit, ...
**Primary category:** cs.CL
**Categories:** cs.LG

**Abstract:** https://arxiv.org/abs/1706.03762v7
**PDF:** https://arxiv.org/pdf/1706.03762v7
**HTML:** https://arxiv.org/html/1706.03762v7

## Abstract

The dominant sequence transduction models are based on complex recurrent
or convolutional neural networks in an encoder-decoder configuration...
```

The frontmatter does the heavy lifting here. `full_text` tells the LLM where to find the rendered paper. `see_also` steers it toward Semantic Scholar for citation data. `shelf` confirms the paper is now tracked for citation export. None of this required the LLM to guess or make extra tool calls.

### Enable LLMs to be slightly more responsible with citations.

LLMs lack training to be responsible scholars. They would be better at tracking citations than humans _if_ they were instructed to do so, but most instructions for compacting context aren't designed to preserve these at all -- to say nothing about gathering those citations as they work.

While we can't do anything about the training, we _can_ make sure the MCP server passively accumulates citations for actively browsed Github projects, research papers, and IETF publications. We can't force the LLM to do anything **with** those citations, but we do give it a little reminder nudge in the tool payload every time one of those citations are accumulated. This increases the odds that the LLM has access to that information when it's time to write documentation, which will reduce the odds of it being forgotten or hallucinated. Is the solution perfect? No, but we think it's a step in the right direction. Researchers will also find it legitimately useful. We're very open to feature suggestions on how this can be improved for academics.

We also do some errand running that the average user won't think of doing, let alone a LLM.

- We don't let the LLM hit the GUIs of Github repos, hard stop. If a LLM asks for a file from the repo, it gets the raw without the extra tool call.
- Background DOI lookups. When's the last time someone who wasn't an academic clicked on your Github repo's CITATION.cff? 
- **Retraction** lookups. Frontmatter tells the LLM up front that the knowledge well is poisoned before it drinks deeply.
- Does ArXiv have a HTML version of a paper? We tell the LLM it's missing before it burns a tool call on the 404, and point it toward the snippets tool. If the HTML version exists, the LLM is told up front where to look for it.

### Don't enshittify the web more than necessary.

Modern LLM solutions have converged on agentic toolchains that pair cheaper text analysis LLMs (Haiku) with larger models that excel at reasoning (Opus), but sometimes the finer details get lost in this process. In a worst case scenario, sometimes these details get hallucinated during the summarization process...**including the attributed authors of research papers and software**. Considering that the very frontier of LLM capabilities live and die by the quality of research papers, this is unacceptable to us.

The best way to minimize the damage of LLM enshittification is to make it easy for their pilots to do the right thing. By providing a tool that synthesizes better data while also making a best effort to steer the LLM toward being a good netizen, we reduce the "litter" left in the wake of irresponsible LLM use. The caveat is that the quality of outputs _must_ create the incentive to use the tool on their own merit, otherwise this MCP server would simply be yet another doomed recycling initiative.

There is no magic wand for making LLMs go away, so let's build LLM toolkits that make things better for more than just the venture capitalists.

### Don't summarize when you can enrich.

Why is LLM summarization so popular?

- Security: **unsummarized** LLM content creates a broader prompt injection surface.
- Brevity: Fewer tokens are used, which in turn improves the LLM's attention focus on the problem you are solving.
- Cost: Fewer tokens in context mean fewer tokens that you're billed for. Poorly chosen walls of text are cost amplifiers that sit in context until it scrolls out or gets compacted.
- Laziness: The traditional problem with "AI". The technology moves too rapidly to be concerned with the long term effects. Today's "good enough" doesn't concern itself with what's good for the world ten years from now.

Our counterpoint:

- The attack surface for prompt injection can be responsibly mitigated, and summarizers aren't entirely exempt from being prompt injection surfaces.
- Hallucination is much more likely to present itself when the details in context are vague, which is an artifact of both first-tier summarization _and_ recursive LLM summarization. Hallucinations pollute the web at best, and at worst force corrective action.
- Corrective action is a hidden cost, both in terms of human labor and the energy labor of LLMs being instructed to redo the work.
- Search results are already very polluted with SEO optimized AI slop, a non-zero percentage of which will make it into the next round of training for frontier LLM models.

QED:
  - Summarization enshittifies the web through hallucination and model collapse.
  - LLMs summarizing LLMs are the path to madness. Frontier model providers avoid this at the training layer, but _they aren't