Full disclosure up front: every knowledge-base page you are about to see — the onboarding checklist, the flowcharts, the PowerShell recipe, the traffic chart — was written by an AI assistant. Not pasted in by a person. The assistant connected to a fresh Knowledge Base on one of our lab servers through the server's built-in MCP endpoint, signed in through the browser OAuth flow as a moderator account, and authored a complete partner-exchange knowledge base: four topics, nine pages, two Mermaid diagrams, a bar chart it rendered and attached itself, and download links to real files on the server.
We know it did — and you would too — because the Knowledge Base's git-backed version history labeled every one of its revisions generated by AI agent. That label is the point of this post. But let's start with what this feature actually is.
A knowledge base inside your file server
Stylus SFTP Server's Enterprise edition ships a browser-based Knowledge Base served from the same admin web server, at /knowledge/. It exists for one reason: the documentation your trading partners need lives next to the files they exchange, behind the same accounts and the same group model. Connection instructions, file-naming conventions, onboarding checklists, operational runbooks — published where partners already sign in, not on a wiki in someone else's cloud.
Knowledge users are the server's regular SFTP accounts. Two group capability flags split the audience: access_knowledge makes someone a reader — they browse and search the published pages their groups are entitled to see; manage_knowledge (hosting-organization groups only) makes someone a moderator — they author, publish, organize, and see every topic. Sign-in honors MFA, and a signed-in reader who clicks a link to a file on the server is admitted to the File Portal through single sign-on, with their own folder permissions deciding access.
The demo: a partner file exchange documents itself
For this post we gave the assistant a scenario — a fictional company running a B2B file exchange on Stylus SFTP Server — and asked it to write the knowledge base that company's partners would need. It produced the classic shape: Getting Started (environments, SFTP client walkthrough, client downloads), Partner Onboarding (checklist, file-naming conventions), Integration Guides (a scripted-upload recipe, a data-flow reference), and an Operations Runbook for internal staff.
Before we get to how the assistant did this, it is worth dwelling on the authoring surface itself — because the AI is the second audience for it. The first is a person, and the editor a person gets is a full authoring studio, not a wiki textarea.
The page editor: what a human author gets
Moderators author in place: the editor fills the content area while the index tree stays beside it, with Save, Publish, and Close in the toolbar. The Style drop-down applies paragraph styles Word-style — Normal, Heading 1–3 — and follows the caret so it always shows the style you are in; around it sit fonts, sizes, colors, alignment, lists, hyperlinks, and a source view for direct HTML work. Every way of leaving a modified page — navigation, sign-out, closing the editor — prompts with Save / Discard / Cancel, so work is never silently lost.
Tables people actually want to read
Insert a table by sweeping a row×column matrix — or skip hand-entry entirely with From CSV: upload a CSV file, pick its dialect (separator, line endings, encoding, string marker, first-line header), and the data lands as a table with a proper header row. While the caret is inside a table, a floating toolbar appears beside it:
- Table styles — a gallery of built-in looks (grid, striped, header row) in several color themes, shown as preview tiles you click to apply.
- Borders — scoped to a cell, a row, the table frame, or the whole table, with per-side checkboxes that reflect the current state, plus line width, style, and color.
- Structure — insert column before/after, row above/below; auto-size columns to content; properties dialogs for cell, row, column, and table; delete at any scope.
Columns and rows also resize directly with the mouse — drag a boundary, drag the table's right or bottom edge to scale everything proportionally, or drag the corner for both at once. Borderless tables show faint guide lines while editing so they stay workable; readers never see the guides. And on the reading side, every table grows a hover button that exports it as CSV, with the same dialect options in reverse.
Code and diagrams-as-text
Insert code snippet… opens a dialog with a language picker — Java, XML/HTML, JavaScript, JSON, SQL, Shell, PowerShell, Python, C#, CSS, YAML, or plain text — and published pages render the snippet with syntax coloring; double-click a snippet in the editor to modify it. The same dialog offers Mermaid diagrams: write a flowchart, sequence diagram, or ER diagram as text, and readers see it rendered as a real diagram, drawn fresh on every view. The stored page stays plain, diffable text — and diagram text that fails to parse is shown as-is with an error note rather than disappearing.
Real diagramming with draw.io
For diagrams that deserve a canvas rather than a grammar, Insert diagram… opens the embedded draw.io editor — the full diagramming application, shapes, connectors, and stencil libraries included — right over the page. Saving exports the diagram into the page as an ordinary image every reader sees, with the editable diagram source embedded inside the same file. Months later, double-click the image: draw.io reopens the original, fully editable, and saving replaces it in place. No separate tool, no lost source file, no “does anyone have the Visio for this?”
Pictures, attachments, video
The paperclip menu rounds out the media story. Upload picture places an image at the caret — click it and drag the corner handles to resize, proportionally. Upload attachment puts a download link exactly where the prose needs it. Insert YouTube video takes a URL (or a bare video ID) and embeds the player — the privacy-enhanced player host, so readers who never press play get no tracking cookies. Insert video embeds a player for an .mp4 or .mpg by URL — external or a server file link — always with controls, never autoplaying. And Insert link to file on server browses the portal filesystem — home directory plus shared virtual folders — and links a file that stays on the server: no copy, current forever, every reader's click checked against their own folder permissions through single sign-on.
Attachments are bounded and screened: 20 MB per file, 200 MB per page, a strict content-type allow-list — and HTML and SVG uploads are rejected outright, because browsers would execute scripts inside them.
The assistant speaks the same language
Nearly everything in that editor is expressible through the MCP tools, which is what made the demo possible: code snippets with the same language set, Mermaid diagram text, styled tables, uploaded images, YouTube and video embeds, and server-file links the assistant discovers with a bounded, names-only search of the token account's portal filesystem. In our demo it used most of the vocabulary in one sitting:
- Shell and PowerShell snippets in the connection and automation guides;
- a feed-pipeline flowchart and an acknowledgment sequence diagram, as Mermaid text;
- grid tables for environments, feed codes, and the onboarding checklist;
- a bar chart it rendered as a PNG on its side and attached with
upload_image; - a YouTube walkthrough it verified and embedded on the client-setup page;
- download links to a real installer — plus its checksum and signature sidecars — that it found in a shared folder with
find_server_files.
The one deliberate exception is the draw.io canvas — that is a human's interactive tool. An assistant that wants a diagram writes Mermaid, which has the pleasant side effect that its diagrams live in history as diffable text.
Drafts first, readers later
Everything an author creates — human or AI — starts life as a draft: visible to moderators, marked plainly, excluded from reader search, invisible in the reader tree. A page reaches readers only when a moderator publishes it. That one rule is what makes it safe to let an assistant write freely: nothing it does is reader-visible until someone (or an explicit, deliberate publish call) says so.
Every save is a version. Every version has an author. Some have a warning label.
Knowledge content lives under the server's data directory as plain files, and every change is committed to an embedded git repository. Nothing is ever overwritten. In the page editor, the History panel lists each version with its time, author, and message — and when the change arrived through the MCP endpoint, the message carries the suffix (generated by AI agent).
Click any version and the compare view takes over the full width: the selected version renders on the left, the current page on the right, and the raw change list sits below — additions in green, removals in red. Clicking a change line highlights the corresponding spot in both rendered panes. Revert to this version restores the page as a new version, so history is never rewritten and a revert can itself be reverted.
The MCP server: how an assistant gets in
The Knowledge Base exposes a native MCP server (Model Context Protocol) at /knowledge/mcp. Claude Code, Claude Desktop, VS Code with Copilot, Open WebUI — anything that speaks MCP over HTTP can connect. Registration is one command:
# Browser sign-in (OAuth) — no token to copy or store:
claude mcp add --transport http knowledge https://your-server:9980/knowledge/mcp
# Or with a personal access token:
claude mcp add --transport http knowledge https://your-server:9980/knowledge/mcp \
--header "Authorization: Bearer <token>"The OAuth path is the one we used for this post, and it is the one we recommend: the client discovers the server's authorization endpoints, registers itself, and opens a browser page where a person signs in with their own SFTP credentials — MFA included — and approves the access. No credential ever passes through the assistant. PKCE is mandatory, access is short-lived and auto-refreshed, refresh tokens rotate on every use, and reuse of a rotated token revokes the whole grant. The approval shows up in the admin token list (kind OAuth) where it can be revoked at any moment, cutting the client off instantly.
Prefer tokens for headless integrations? Administrators mint personal access tokens from any admin surface. Each token is bound to one account (disable the account and the token dies with it), carries a read or read,write scope, expires after 90 days by default, is prefixed ssskb_ so it is recognizable in config files and logs, and is stored server-side only as a SHA-256 hash — shown once, revocable always.
Either way, the crucial property is the same: the connection is a user, not a superuser. The assistant sees exactly what that account's organization and groups allow — nothing more. Its writes land as drafts. Its actions land in the audit trail under that account's name. And its revisions carry the AI label in history, forever.
Multi-tenant by construction
Topic visibility is granted to groups, and groups belong to organizations — the same identity model that governs folders and the portal. A grant on a topic covers the topic and everything beneath it; a topic with no grants is visible to moderators only. Because enforcement is server-side and uniform — tree, page reads, search results, attachment downloads — the visibility model doubles as a tenant wall: each customer organization gets a documentation area the others cannot see, or even discover.
And this wall applies to AI connections identically, because the connection is a user. Hand a partner-facing assistant a read-only token bound to a reader account in the Acme organization, and it can search and read exactly what an Acme employee could — a support chatbot with tenant isolation you did not have to build.
The kill switches
The AI Integration page in the Web Admin (with matching desktop Admin Console tab and get-ai-integration/set-ai-integration CLI commands) holds the master enable switch, ready-to-copy client registration commands, and token management. Flip the master switch off and MCP clients get a clean “disabled by an administrator” refusal while tokens and configuration are preserved for re-enabling. Below that: revoke a single grant, disable the underlying account, or simply narrow the account's group memberships — each is a progressively finer blast radius.
What this looked like in practice
The making of this post is its own best demo. The sequence, end to end:
- We registered the lab server's MCP endpoint in Claude Code — the OAuth variant, no token.
- A person signed in through the browser consent page as
hector, a moderator account, and approved the grant. - The assistant authored the entire knowledge base over MCP: topics, pages, code snippets, tables, Mermaid text, a chart PNG it generated and attached, and server-file links it discovered with
find_server_files. - It published the partner-facing pages with explicit publish calls and deliberately left the internal runbook as a draft.
- We took the screenshots you see here from the live UI. The history panel had already labeled every revision.
Total authoring time was minutes. And the part that matters for a compliance conversation: at no point did the assistant hold a password, see another tenant's content, touch a reader-visible page without a publish step, or make a change that isn't attributed, versioned, and labeled in git-backed history.
Your file server's documentation now talks to AI — on your server, as a real account, behind your MFA, with a warning label on everything it writes.
The full feature reference — capability flags, token administration, client setup for Claude Desktop, VS Code, and Open WebUI, attachment limits, branding — is in the Knowledge Base chapter of the User's Guide.