Rabbithole

An open-source Rust web server that dynamically generates entire websites using LLMs

Web Tools

Giving the LLM access to the live internet during page generation.

Overview

By default, Rabbithole generates pages using only the LLM's internal knowledge and the prompt stored for that URL. This is fast and sufficient for many use cases — especially fictional or creative sites where consistency of invented lore matters more than factual accuracy.

However, for factual, technical, or news-oriented sites, you often want the generated page to reflect real, current information: the actual contents of a GitHub repository, today's package version numbers, a live article, or an up-to-date API reference. The web tools feature addresses this by giving the LLM access to two tools during page generation: web_search and web_fetch.

When web tools are enabled, before writing HTML the LLM can issue tool calls to search the internet or fetch a specific URL. The results are incorporated into the generated page. The Rabbithole documentation site itself (isarabbithole.com) uses this feature so that pages can reference real source code, accurate CLI flags, and up-to-date project information from github.com/ajbt200128/rabbithole.

How It Works

Rabbithole uses an LLM API that supports tool use (also called function calling). When the --web-tools flag is passed, two tool definitions are included in the system prompt and API call for every page generation request.

The LLM can then respond with one or more tool calls before producing the final HTML. Rabbithole intercepts those calls, executes the searches or fetches on the LLM's behalf, returns the results back to the model, and the model continues generating until it produces the complete HTML response.

This is a standard agentic loop: the model can make multiple sequential tool calls, reasoning about what information it still needs before writing the page. Typically a page will make one to three tool calls before producing output.

 Request arrives for /some-page.html
         |
         v
 Rabbithole looks up stored prompt
         |
         v
 LLM API call (with tool definitions included)
         |
    [tool call?]
    /          \
  yes           no
   |             |
   v             v
 Execute tool   Write HTML response
 (search/fetch)
   |
 Return result
 to LLM
   |
 [loop back]

The Two Tools

web_search

web_search accepts a plain-text query string and returns a list of search results including titles, URLs, and short excerpt snippets. The LLM uses this to discover relevant pages, check current facts, look up package versions, or find documentation for a topic it will be writing about.

Example tool call:

{
  "tool": "web_search",
  "parameters": {
    "query": "rabbithole ajbt200128 rust LLM web server"
  }
}

Example result (abbreviated):

[
  {
    "title": "ajbt200128/rabbithole — GitHub",
    "url": "https://github.com/ajbt200128/rabbithole",
    "snippet": "An open-source Rust web server that dynamically generates websites using LLMs."
  },
  ...
]

web_fetch

web_fetch accepts a URL and returns the plain-text body of that page (HTML tags stripped). The LLM uses this to read actual source files, README documents, configuration references, API documentation, or any page whose full content it needs to incorporate accurately.

Example tool call:

{
  "tool": "web_fetch",
  "parameters": {
    "url": "https://raw.githubusercontent.com/ajbt200128/rabbithole/main/README.md"
  }
}

The response is the raw text content of that document — which the LLM can then quote, summarize, or use as a source of truth when writing the page.

Enabling Web Tools

Web tools are disabled by default. Pass the --web-tools flag when starting the server to enable them:

rabbithole --web-tools --seed "Homepage for a Rust documentation site" .

Or in a configuration file:

# rabbithole.toml
web_tools = true
seed      = "Homepage for a Rust documentation site"

See the Configuration page for the full list of options and their precedence rules (CLI flags override config file values).

Tradeoffs

When to Use (and When Not To)

The rule of thumb: if the page would be more accurate by looking things up, enable web tools. If the page would be less consistent by looking things up, disable them.

Before / After Examples

The following illustrates how the same prompt produces qualitatively different pages depending on whether web tools are enabled.

Example 1: Documentation page for a real library

Prompt: "Page documenting the --port flag of the Rabbithole CLI."

The --port flag sets the TCP port
the server listens on. Default is
likely 8080 or 3000 (exact value
may vary by version).

The --port flag sets the TCP port.
Default: 3000. Example:

  rabbithole --port 8080 \
    --seed "My site" .

This is equivalent to setting
port = 8080 in rabbithole.toml.

Example 2: A page in a fictional university site

Prompt: "Department of Recursive Hermeneutics at ACAPA, course listings."

RH 101: Introduction to
         Self-Referential Texts
RH 204: The Paradox Seminar
RH 310: Advanced Circular
         Reasoning Lab

All courses held in the
Möbius Building, Room ∞.

RH 101: Introduction to
  Hermeneutic Circles (Dilthey)
RH 204: Gadamer and Tradition
RH 310: Ricoeur's Narrative Theory

[Consistent invented lore broken;
real academic references intrude.]

The second example shows why fictional sites should disable web tools: the LLM "corrects" the invented curriculum with real hermeneutics scholarship, undermining the playful fictional premise.

Example 3: A current-events page

Prompt: "Latest Rust stable release notes."

Rust 1.75 introduced async fn
in traits. (Note: this may be
outdated; check blog.rust-lang.org
for the current release.)

Rust 1.87.0 (released 2025-05-15)
- Stabilized ...
- Performance improvements to ...
- See full notes at:
  blog.rust-lang.org/2025/05/15/...

See Also

• Configuration Reference — full list of flags including --web-tools
• Architecture — how the page generation loop works in detail
• Getting Started — quick start guide
• Examples — example sites with and without web tools
• Deployment — cache warm-up and production considerations
• GitHub: ajbt200128/rabbithole — source code
• Citation & Copyright Policy — guidelines for LLMs using web tools responsibly
• Advanced Web Tools Usage — custom tool configurations, rate limiting, and caching fetched content