Sources

A Docsbook source is a repository, a website or a single page that this project's assistant and agents are allowed to fetch. Connect one, and "update the documentation" or "is this page still true" starts with a read instead of a recollection.

Open Integrations ▸ Connectors in your project's admin panel. Every kind of source — a repository, a documentation platform, a knowledge base — is a card in that grid, beside the apps and delivery channels the project is wired to. There is no separate Sources screen: what this project may READ and what it is CONNECTED TO are the same question, so they are answered in one place.

What you get#

• An address the assistant can go to. Ask what your product costs, and it fetches your pricing page for this question rather than answering from what it absorbed in training.
• The same registration in your own tools. The two tools that are the feature, list_sources and read_source, are served over your project's MCP endpoint, so a source you connect here means the same thing in Claude Code or Cursor.
• A sentence of yours attached to each one. The note you write ("the API server the reference pages describe") is read as instruction by everything that later reads that source.
• A read that fails loudly. An unreachable repository comes back as an error with a hint, never as an empty list that reads like an empty repository.
• No plan gate. Sources are on every plan, deliberately: a paywall here would be selling the ability to tell the truth.

What can I connect as a source?#

Four kinds exist under the covers — Website, Page, Repository and Repository folder — and the table presents them as a catalogue of the named things owners actually ask about, in five groups: Your project, Documentation platforms, Knowledge bases, Code and APIs and Community. A published documentation site is a website whoever built it, so Mintlify, GitBook, ReadMe, Docusaurus, Read the Docs, MkDocs, Nextra, VitePress, Starlight, Redocly, Stoplight, Scalar and the rest need nothing built per vendor.

The table lists every kind Docsbook knows about, connected or not, narrowed through a Filters menu rather than split into sections. Each connection is its own row: two connected websites are two rows.

Grey means two different things, and the row says which:

• Not connected — the row offers a Connect. Reading it works today, through the same public fetch every other url row uses.
• Not available yet — the row offers no button and prints what it would need: an authorisation you grant once (Notion workspace, Confluence, Coda), a bot token (Telegram, Discord, Slack), or a reader for a repository host Docsbook does not read yet (GitLab, Bitbucket). Where a workaround exists the row names it — a public help centre connects as a Website today.

A row without a button is deliberate. A row is only allowed to offer Connect if read_source can genuinely read it as it stands; a Connect that cannot connect makes every other row on the screen untrustworthy.

How do I connect a source?#

Open the card for the kind of source you have and press Add addresses. You can paste as many as you like at once — one per line — because a project's documentation is usually written from its repository and its pricing page and its API reference, and connecting them one dialog at a time is how a source list ends up with one row in it.

The address decides what each source is, not the card you opened. The card only sets the placeholder and the heading; before you commit, the dialog lists every line you pasted and says which card each one will actually land on, so a GitBook link pasted onto the Mintlify card is caught while it is still cheap to fix.

A file extension in the path is what separates a page from a website. A link pasted from an issue or a pull request connects the repository, not the issue — storing /issues as a subtree would produce a source that reads back empty forever. Tracking parameters (utm_*, fbclid, gclid, ref, si…) are stripped, so the same page pasted from a tweet and from your address bar is one source rather than two. A bare host gets https://; an http:// you typed on purpose is left alone, because silently upgrading it produces a source that 404s for a site with no TLS and no way to see why from the row.

A private repository needs the picker, not a paste. GitHub answers the same 404 for "private" and for "does not exist", so a pasted address cannot tell Docsbook which it is, and a hand-typed private address connects as public and reads nothing. Use Or pick one of your GitHub repositories in the dialog: the picker knows, and a source marked private stores the connecting account's GitHub authorisation, encrypted at rest, so a scheduled run with no browser session behind it can still read the repository. That authorisation never leaves the server — the API answers has_token, never the token — and a token GitHub has since rejected is reported as "reconnect this repository" rather than retried in silence.

Two entries appear without you adding them, and neither can be renamed, paused or removed here:

• This site's repo — the repository your documentation is built from. It is already being read; making you "connect" it would imply it was not.
• From Branding — the Site source URL, if your workspace set one. It still lives on the Branding card.

Re-pasting an address you already connected updates that row rather than failing or duplicating it, and a re-paste with no note does not wipe the note you typed the first time.

What reads a connected source?#

Three things, and nothing else. A connected source is not crawled on a timer, is not added to your published documentation, and is not searched by the reader-facing chat on your docs site — that one answers only from your own pages (Answer quality is the pipeline it uses).

The assistant in your admin panel. list_sources and read_source sit in its base toolbox rather than behind a lookup, because a capability that costs an extra round trip to discover is one the model answers from memory instead — the exact failure sources exist to prevent.

Your own MCP agents. The same two tools over your project's MCP endpoint, plus connect_source and configure_source for setting one up without opening a browser. Those two need a read-write MCP token.

Background runs. Scheduled prompts and agent runs read them too, which is where it matters most: there is nobody sitting there to paste a link.

Not every automated run reaches a source, so the panel says which do rather than implying they all can. Wherever runs are listed, the chips are drawn in three states:

• Lit — this run fetches the source: your site's pages, your repository's files.
• Unlit — this run knows the source is connected and will name it, but never declared that it leaves the property, so it will not fetch it. Ask the assistant instead; it has no such fence.
• Nothing at all — this run reaches no source. A settings write has no business reading your repository, and a chip there would say otherwise.

How is a source fetched, and how fresh is what comes back?#

Nothing is pre-fetched and nothing is mirrored. A read happens when a tool asks for one, against the live address, and these are its edges:

Code, lockfiles and build output are filtered out of the listing (node_modules, dist, build, .next, coverage and friends), not out of the reads: read_source with a path fetches any file, the filter only decides what gets named without being asked for.

Sitemap scoping is matched at a path boundary, not as a string prefix. Connect acme.com/docs and /docs-for-fintech stays out of it. A section the sitemap lists nothing under falls back to the entry page alone — never to the whole site — and the result says which of the three things happened: pages came from the sitemap, the site has a sitemap but nothing under your section, or there is no sitemap at all. A thin read is never allowed to read as a thin site.

Every outbound fetch goes through the same guard the rest of Docsbook's web reading uses: robots.txt is honoured, redirects are followed manually with the address re-validated at each of at most five hops, and private and link-local ranges are refused, so a public URL cannot bounce into a cloud metadata endpoint. Pages that render their content with JavaScript come back with a note saying no readable text was found, rather than as an empty page.

Online, paused, and what the green dot means#

Every connected source shows a green dot and the word Online. A paused one shows a grey dot and Paused.

Online means the source is connected and your agents may read it. It is not a health check. Nothing pings the host and nothing checks the repository still exists. The honest signal is the Last used column, written only when a tool actually fetched the source successfully — a failed fetch never stamps it.

Each connected address is listed on its card's own page. Disconnect keeps the address and stops everything reading it; press it again (it reads Connect) to resume. Remove deletes the connection outright, along with any GitHub authorisation attached to it. Open visits the address. The two ways to stop reading a source are different on purpose: "stop reading this for now" should not make you retype the address later.

What happens when a source cannot be read#

Every failure is a sentence with a next step, and none of them is an empty result:

That last row is the point of the whole design. The failure mode a source prevents is not an error message — it is a confident paragraph about a repository nobody read.

What does reading a source cost?#

Sources themselves are free to connect and free to keep. Two of the four tools are metered when called over MCP, and they are priced by what serving them actually costs:

• list_sources reads rows Docsbook already stores, and is priced as an ordinary read.
• read_source leaves the Docsbook network for GitHub or for somebody's website — and a website source fetches several pages in one call — so it is priced as an outbound call, the same class as fetch_url.

Both come off the balance of the project the call is about. Amounts are on the pricing page.

Why this is the right way (evidence)#

Limits#

• A source is read on demand, not indexed. There is no background crawl, no stored copy and no freshness guarantee between calls. What a tool saw is what the address served at that moment.
• The green dot is not a reachability check. See above. A repository deleted this morning shows Online until something tries to read it.
• A hand-typed private repository connects as public and reads nothing. Docsbook cannot tell a private repo from a missing one by its address. Use the repository picker, which can.
• Only GitHub repositories are read as repositories. GitLab and Bitbucket rows exist and offer no Connect; a public project page on either can be connected as a Website, which reads the rendered pages and not the tree.
• A website source is not a crawler. At most ten pages per call, from the sitemap only, no recursion, no link-following. A large documentation site is better connected as its repository.
• JavaScript-rendered pages come back empty. The fetcher does not execute scripts. The result says so, so the emptiness is never reported as an absence of content — but you still have no content.
• Notes are instructions, and they are yours to keep honest. Everything that reads a source reads your note as guidance. A stale note ("the v1 API, deprecated") steers an agent as effectively as a correct one.
• We publish no measurement of how much sources reduce wrong answers. The mechanism is above and the evidence for it is external; a before-and-after number over customer corpora is not something Docsbook has run. Treat "sources improve accuracy on your docs" as a well-supported expectation, not as a figure we have measured.

Related#

• AI chat — the assistant on your docs site, and what it may answer from.
• Answer quality — the retrieval and grounding pipeline, in full.
• Chat hooks — the other way to hand a model a fact it cannot read.
• MCP server — the same tools, for your own agents.
• MCP tools reference — list_sources, read_source, connect_source, configure_source in full.
• Source of Truth — a different feature with a similar name: a local graph of your own pages, built on the agent's machine.
• Pricing — what a source read draws on.