Data Source Integrations
Connect SharePoint, Confluence, Jira, Google Drive, GitHub, and more. Knowably syncs your documents and respects existing access permissions.
SharePoint was the first connector I built. Every organization structures their drives differently - that was the first lesson. The second lesson: no one knows where their own documents are.
Your company's knowledge is scattered across seven or eight systems. SharePoint for policies, Confluence for technical docs, Jira for decisions that never made it anywhere else, email threads that three people remember, a GitHub repo with docs only the author can find. The knowledge exists. It is just unreachable from a single place.
Knowably connects to all of them. One platform, live connections, automatic syncing. You connect a data source once, and its content becomes searchable by your AI agents immediately.
Supported Data Sources
Each connector handles authentication, document discovery, and content extraction specific to that system. Building them taught me that every integration has its own quirks.
Microsoft SharePoint
SharePoint is where most enterprises keep their formal documentation. Policies, procedures, handbooks, project files.
Knowably connects through OAuth sign-in. You authenticate with your Microsoft account, select the SharePoint sites and document libraries you want, and Knowably pulls in the documents. PDFs, Word files, Excel spreadsheets, PowerPoint presentations - whatever lives in those libraries.
The challenge with SharePoint is structural diversity. One organization nests everything three levels deep. Another dumps 4,000 files in a single library. The connector handles both.
Atlassian Confluence
Confluence is the go-to wiki for engineering and product teams. It also tends to grow into a sprawling mess where finding the right page takes longer than writing a new one.
The connector uses OAuth authentication with Atlassian. Select the spaces you want to index, and Knowably pulls page content directly from the Confluence API. Pages are ingested as structured content - not downloaded as files - which preserves headings, tables, and formatting.
Atlassian Jira
Jira issues are not files. They are structured content. Requirements, bug reports, decision logs, acceptance criteria - information that never makes it into formal documentation but gets referenced constantly.
The Jira connector authenticates via OAuth and pulls issue content from selected projects. The client ingests them directly from the API, preserving their field structure.
Microsoft Email (Outlook / Exchange)
Email is still where important information lands. Vendor agreements, regulatory correspondence, support threads, internal announcements.
The Email connector uses OAuth sign-in with your Microsoft account. You select which mailbox folders to include. Knowably pulls the email content - subject, body, and metadata - from those folders.
GitHub
Documentation-as-code is real. README files, markdown docs, architecture decision records, API references - a lot of developer knowledge lives in repositories.
The GitHub connector authenticates via OAuth and pulls repository content. Markdown files, text files, code documentation - anything stored in the repos you select.
Website Crawler
Not everything lives behind a login. Public documentation sites, help centers, product pages.
No OAuth needed. Provide a URL, and Knowably crawls the site. It follows links and processes sitemaps to discover pages automatically. This is a configuration-based connector - you set it up, it runs.
File Uploads
Sometimes you just need to upload a file. A legacy document. A PDF from a vendor. A spreadsheet that does not live in any connected system.
No external connection required. Drag and drop files directly into Knowably. Multiple files at once, with per-file progress tracking.
Supported File Formats
PDF - reports, policies, forms, manuals.
Microsoft Office - Word (DOC, DOCX), Excel (XLS, XLSX), PowerPoint (PPT, PPTX). The bulk of enterprise content.
Text formats - Plain text (TXT), Markdown (MD), CSV, Rich Text Format (RTF).
OpenDocument formats - ODT, ODS, ODP for organizations using LibreOffice or similar tools.
Jira issues and Confluence pages are a special case. They are ingested as structured content directly from the API, not as file downloads. Their formatting, headings, and table structure stay intact natively.
How Connections Work
OAuth Authentication
Most connectors use OAuth - the same sign-in flow you use when a service says "Sign in with Microsoft" or "Sign in with Atlassian."
You click "Connect" on a data source, sign in with your existing account, and grant Knowably read-only access. No passwords stored. No API keys to generate. Just a standard sign-in that issues a secure token.
Knowably requests only the permissions it needs to read documents. Nothing more.
Automatic Token Refresh
OAuth tokens expire. That is by design - it is a security feature. When a token expires, Knowably refreshes it automatically using the refresh token from the original sign-in.
This happens silently. You do not need to re-authenticate.
If a refresh token itself expires or gets revoked - say an admin changes permissions on the external service - the data source status will indicate the issue and prompt re-authentication. One new sign-in and you are back.
Configuration-Based Connections
The website crawler does not use OAuth. It uses configuration-based setup - you provide a URL directly. The fields vary per connector type, but the idea is the same: provide connection details, Knowably handles the rest.
Document Processing Pipeline
Connecting a data source is the first step. Every document goes through a six-stage processing pipeline before it becomes searchable.
Each stage is a separate queued job. I designed it this way because failures should be granular. If text extraction fails on one PDF, the download was still fine. You do not reprocess the whole thing - you retry from the point of failure.
The Six Stages
Collected. Knowably discovers the document in the remote system. It has the metadata, but has not downloaded content yet.
Downloaded. Content has been retrieved from the remote system and stored locally.
Extracted. Text and structure have been pulled from the document. For PDFs, that means text extraction. For Office files, document parsing. For Confluence pages, the structured content is already text.
Chunked. The extracted content has been split into passages - smaller, focused pieces of text that can be individually searched and cited. The chunking strategy depends on your configuration.
Indexed. Vector embeddings have been generated for each chunk and stored in the database. The document is now searchable via semantic search.
Ready. Processing is complete. The document and all its chunks are fully searchable by any agent with access to this knowledge base.
Initial Sync
After you connect a data source and save, Knowably begins the initial sync automatically. Documents are discovered, queued, and processed through the pipeline. Depending on the size of the data source, this takes anywhere from seconds to hours.
You do not need to wait. The platform is usable while documents process in the background.
Incremental Re-Sync
Knowledge changes. Documents get updated, new files are added, old ones are deleted.
Trigger a re-sync manually from the dashboard - either for a single data source or as a batch sync across multiple sources at once. Knowably detects what changed. New documents enter the pipeline. Updated documents get reprocessed. Deleted documents are removed.
Unchanged documents are skipped entirely.
Background Processing
Every stage runs as a queued background job, independently. The system processes thousands of documents without blocking anything.
Failed jobs retry automatically - up to two attempts with exponential backoff. If a document still fails, it gets marked as failed with a reason you can inspect.
Status Tracking
You should not have to wonder what is happening with your documents. Knowably tracks status at two levels.
Data Source Status
Every data source shows its current state:
Configuring - initial setup, waiting for configuration to be saved.
Collecting - discovering documents from the remote source.
Importing - downloading document content.
Indexing - processing and indexing documents for search.
Ready - all documents processed and searchable.
Failed - an error occurred. The reason is displayed so you can take action.
Document-Level Status
Each document has its own processing status, following the six pipeline stages.
Two additional statuses handle problems:
Invalid - the document is permanently unavailable. A 404, an unsupported file type, or a permission issue on the remote system. Retrying will not help.
Failed - a transient error during processing. The failure reason is displayed. You can retry individual failed documents without re-syncing the entire data source.
Status counts are displayed per data source: total documents, processing, processed, and failed. At a glance, you know where things stand.
Ingestion Modes
Fast mode handles 90% of documents. Hi-res mode exists for the PDFs with embedded tables that fast mode butchers.
Fast Mode
The default. Optimized for text-based documents and significantly faster than Hi-Res mode on text-heavy content like Word files and markdown.
Word files, plain text, markdown, Confluence pages, Jira issues - fast mode handles these well. For documents that contain images, those images are still processed using the Hi-Res path automatically. Speed where it matters, quality where it counts.
Hi-Res Mode
For complex document formats. Dense PDFs, PowerPoint presentations with embedded graphics, Word files with intricate table layouts.
Hi-Res mode extracts text, images, and tables with full layout awareness. It handles multi-column layouts, embedded figures, and complex table structures that Fast mode oversimplifies. If a document format is not supported by Hi-Res, it falls back to Fast mode automatically.
Choose Hi-Res when your content is visually complex. Choose Fast when your documents are primarily text.
Advanced Configuration
Every data source can be tuned beyond the defaults.
Document Limits
Set a maximum number of documents per data source. Useful when connecting to a large SharePoint site with thousands of files but you only need the most recent ones processed. Controls both processing time and costs.
Chunking Modes
How documents are split into searchable passages matters. Different content calls for different strategies.
Hierarchy Depth splits based on document structure depth - sections, subsections, and their nesting levels.
Hierarchy Heading splits based on heading structure. Each heading starts a new chunk. Good for well-structured documentation with clear heading hierarchies.
Static Length splits at fixed token lengths. Predictable, consistent. Works well for content without clear structural markers.
Page Level splits per page. Natural for PDFs and presentations where page boundaries are meaningful.
You can also configure minimum and maximum chunk length in tokens. This prevents chunks that are too short to be useful or too long to be focused.
Figure Captioning
Enable AI-powered captioning for images and figures within your documents. When a document contains a chart, diagram, or screenshot, the captioning system generates a text description that becomes part of the searchable content.
Custom captioning prompts let you guide how images are described. Technical diagrams? Focus on component names and relationships. Product screenshots? Focus on UI elements and features.
This makes visual content findable through text search.
Table Splitting
Large tables are problematic for search. A 200-row spreadsheet embedded in a document is too big for a single chunk but contains valuable structured data.
Enable table splitting to break large tables into smaller, searchable pieces. Configure the maximum table cell count that triggers splitting. Tables below the threshold stay intact. Tables above it get split into manageable chunks.
Security
Data source connections handle sensitive organizational content. The security model reflects that.
Encrypted token storage. OAuth tokens are encrypted at rest in the database. Not base64-encoded. Not plaintext. Encrypted.
Read-only access. Knowably requests only the permissions needed to read content. It does not modify, delete, or write to your external data sources.
Role-based access control. Data source management requires the appropriate permissions within your workspace. Not everyone should be able to connect or configure sources.
Plan-based limits. The number of data sources you can connect may be limited by your subscription plan. Enforced at the connection level.
Token revocation. Disconnecting a data source removes its stored OAuth tokens. The connection is fully severed. Reconnecting later means authenticating from scratch.
Tenant isolation. Each workspace operates on its own database. Data sources, documents, and chunks from one workspace are physically separated from every other workspace. Not filtered. Separated.
Getting Started
Connecting your first data source takes under five minutes.
Pick a system. Authenticate if needed. Select which content to include. Save.
Knowably starts processing immediately. Within minutes, your agents can answer questions from that content.
The real power comes from connecting multiple sources. An agent that searches across your Confluence docs, Jira tickets, and SharePoint policies simultaneously gives your team something no individual search tool can: answers that pull from everywhere, cited back to the original source.
Connect your first data source | Learn about knowledge bases | Configure AI agents