WitWiki

Sources and connectors

Pages are what people and agents write. Sources are what they write from: the files behind the pages, kept with the project so the next session knows where a fact came from and whether it has been folded in yet. Connectors bring three outside tools — Linear, Notion, Slack — into the same MCP tool list, read-only.

Sources

Sources in the nav lists the project's files: name, kind, size, state and when each was added. Add sources uploads one or more files (up to 100 MiB each); they are stored in object storage, encrypted at rest. Every plan meters sources across the organisation — Free includes 10; see Limits and plans.

A source carries a status. An uploaded file is uploaded (Not read yet) until it is marked ingested (Read by an agent), which is yours to set: it says a person or an agent has read the file and written what mattered into pages. Set it from the row (Mark as read) or let the agent set it. The saved originals of a Notion import arrive as processed. The Ingest monitor (/ingest) is a live log of upload and processing events for the project.

What an agent can do with sources

ToolDoes
wiki_listSourcesList the project's sources with status and size
wiki_getSourceRead one source's record — filename, type, size, status
source_uploadUpload a file the agent has (base64) and get its record back
wiki_markSourceIngestedSay the source's content is now in the wiki, so no session re-processes it
wiki_deleteSourceDelete a source and its file

One honest limit: over MCP an agent sees a source's record, not its bytes. The pattern that works today is the agent uploading what it has just read — a spec, a transcript, an export — with source_upload, writing the pages, and marking the source ingested, so the next session can see the file exists and is done. A file uploaded in the browser is listed to agents but they cannot open it yet; paste the relevant part into the prompt, or hand them the file. Tool reference has the parameters.

Connectors

Settings → Connections, which owners and admins see, connects a provider with a token: Linear, Notion or Slack. Granola is listed but not available — it has no public API. The token is encrypted at rest and never shown again; test checks it still works, disconnect removes it.

Once connected, the provider's tools appear in the MCP tool list of every agent connected to the organisation, next to the wiki tools. They are read-only:

ProviderTools
Linearlinear_search_issues (by text), linear_get_issue (by id), linear_list_teams
Notionnotion_search (pages and databases shared with the integration), notion_get_page, notion_query_database
Slackslack_list_channels (public channels), slack_read_channel (recent messages), slack_search_messages (needs a token with search:read)

A connector answers the question an agent used to have to ask a person — what is the state of that ticket, what did the channel decide — and the answer can go straight into a page with wiki_patchPage, with the source named. Connectors are per organisation, so one token serves every project and every agent in it.

Import from Notion

If your team's knowledge lives in Notion, an import turns it into a wiki project. It is switched on for your organisation by WitWiki, not by you, so the panel below does not appear until it is: ask at corey@witwiki.app and say which organisation.

Before you start. Connect Notion under Settings → Connections as above, then, in Notion, share with the WitWiki integration the pages and databases you want brought over. Each row of a shared database counts as a page. What is not shared is not read.

Start it. Under the connected Notion card, an owner or admin presses Check what would be imported. Nothing is asked of Notion until then. The panel shows how many pages, sections and databases would come over and how many have not been edited in over a year, then asks for a Project name and how much of it you expect to be out of date, which the report later sets against what happened. One import runs at a time, and one import takes at most 500 pages; share fewer pages and check again if there are more. An import creates a new project, so it counts toward your plan's project limit, and the start is refused when your plan has no room for another project.

What it does. A new project is created and the pages are written into it. Notion itself is never changed: the import only reads. Every Notion page is kept as a saved original, under Sources, as it was when it was read. Near-duplicate pages are merged into one. A page is left out only when another page replaced it or when it says itself that it is out of date, never only because it is old. Page text is sent to Anthropic to write the wiki.

Watch it, then read the report. The import's page, at /imports/…, shows the five steps with their counts, and the report when it is done: what was read, written, copied, merged and left out, each left-out page with its reason and a link to its original, and anything a person should look at. Owners and admins can cancel a running import; the pages written so far are kept.

When two pages disagree. Where two Notion pages say different things about the same subject, the import does not pick one. The wiki page shows a box with both claims, each with the page it came from and when that page was last edited. A member, admin or owner chooses This one is right on one claim, Both are true, or writes their own text; the box is replaced by what they chose, and the page's history records that a person settled it. Viewers see the box but no buttons. The report lists every disagreement still open.