AI search across the knowledge base: where navigation breaks
A corporate knowledge base grows faster than it can be structured. Documents move between spaces, get duplicated during reorganizations, and accumulate nested pages — and document navigation that worked on a hundred pages stops working on ten thousand.
An engineer searches for a policy by keyword, gets thirty matches of which two are relevant, and goes off to ask in chat — because that's faster than sorting through the results.
Ordinary knowledge base search relies on exact word matching.
It doesn't understand synonyms, doesn't distinguish "contract approval procedure" from "how to approve a contract," and doesn't account for the fact that the answer lies in a table on a nested page rather than in a heading.
The more abbreviations, internal slang, and system names the base contains, the more often search returns nothing — even though the document exists and is two clicks away from the section being searched for.
The second failure is fragmentation. Confluence, SharePoint, and Notion each live by their own logic of permissions, tags, and nesting. An employee doesn't know which of the systems holds the current version and searches blindly across all three at once.
Document navigation breaks down into habits: "ask Ivan," "check the pinned message," "I think it was in the old wiki." The knowledge exists, but getting to it costs more than rebuilding it from scratch.
The third failure is obsolescence. Search honestly returns both the archived copy and the active policy, without distinguishing one from the other. The user loses trust in the results and stops using them — and with that, the whole point of the knowledge base goes too.
AI search closes exactly these gaps: it matches the meaning of a query against the content rather than letters against letters, and it can pull an answer from several systems at once.
Let's break down how this works and what's needed to make navigation across a corporate knowledge base stop being a lottery.
What smart search delivers: speed, accuracy, coverage
Smart search changes not "convenience" but the very way of working with the corporate knowledge base. Instead of remembering which space a document lives in, an engineer formulates a question in natural language and gets an answer with a link to the primary source.
Search time drops from minutes of wandering through sections to a few seconds — and this is not a one-time saving but a daily effect for every employee.
The accuracy of results rests on the vector representation of text: the query and the document are compared by meaning, not by word matching.
That is why "how to roll out a release without downtime" finds the right regulation even if it does not contain the word "downtime." The answer comes with an indication of where the fragments were taken from — this removes the main fear when working with language models: fabricated facts. The model answers only from indexed sources, not from general knowledge.
Source coverage is a separate engineering task. Confluence, SharePoint, and Notion are indexed into a single space, access rights are inherited from the source systems, so an employee will not see a document they do not have access to.
The index is updated by page-change events, not on a once-a-day schedule — a fresh edit becomes available to search within minutes.
For the business, this translates into concrete numbers: the share of questions resolved without turning to a colleague grows, the time to bring a new employee up to speed is reduced, and recurring questions in support chats stop taking up senior engineers' time.
The knowledge base stops being a dumping ground that no one visits and starts working like a product.
Implementation options: comparing approaches
The choice of approach determines how quickly search appears in the application and how it will behave as the volume of documents grows.
Below are the working options that teams realistically choose between: from quickly connecting a ready-made service to a fully custom search architecture.
| Option | When it fits | Limitations |
|---|---|---|
| Ready-made external service | You need to launch in a short time, documents are typical, and there are no strict requirements for data storage | Indexing and ranking follow someone else's logic, limited control over access, dependence on an external provider |
| In-house solution on your own infrastructure | Documents are sensitive, you need full control over permissions and storage | Longer launch, requires your own support team and monitoring |
| Hybrid: external search layer + your own connectors to sources | You need a balance of speed and control, and there are multiple sources | More complex to set up synchronization and access separation |
External solutions win at the start: connection to Confluence, SharePoint, and Notion goes through ready-made connectors, and the provider ensures retrieval quality.
The price of speed is less control: document access rules are not always inherited accurately, and the ranking logic remains someone else's.
The internal architecture is built around your own indexing and search layer: connectors pull documents from sources, normalize them into a unified form, split them into chunks, and store them in the search index.
Such a loop provides precise permission inheritance — an employee sees in the application only what they have access to in the source system.
The hybrid approach most often turns out to be a workable compromise: the search and answer generation layer is taken ready-made, while connectors and access rules are written in-house.
This makes it possible to launch AI search quickly while not exposing sensitive documents externally.
In practice, the choice comes down to three questions: how many sources need to be covered, how strict the requirements are for access separation, and whether the team has the resources to maintain its own loop. The answers to these determine which implementation option to build into the search architecture.
Stages of implementing AI search in a company
Implementing AI search begins not with configuring a model, but with taking inventory of knowledge. As long as it is unclear where documents are stored, who owns them, and how often they change, any search will produce confident but incorrect answers. Therefore, the first stage is technical, not "product."
- Audit of sources. We compile a list of Confluence spaces, SharePoint libraries, and Notion databases, recording access rights, duplicates, and "dead" sections. The output is a knowledge map: what we index, what we exclude, and why.
- Access rights alignment. We determine how search inherits existing access groups so that an employee does not see a document closed to their department. This is a key security requirement, and it is designed before connecting sources.
- Indexing setup. We connect connectors, set the synchronization schedule, and define rules for processing attachments. Index freshness matters more than its completeness: an outdated answer is worse than no answer.
- Search and ranking setup. We select an embedding model and configure hybrid search — by meaning and by exact terms — so that both abbreviations and rephrased questions are found.
- Quality check. We run a set of real employee questions, measuring the share of correct answers and cases with source attribution. We analyze and fix errors before handover to production.
- Pilot on one team. We give access to a limited group and collect feedback on wording and gaps in the knowledge base.
- Handover to production. We hand over the index update regulations, instructions for document owners, and the incident review procedure.
Each stage ends with a verifiable artifact, so the solution does not "stall" at a demo but reaches the working environment. Describe your sources and access constraints — we will come back with an assessment and a work plan.
What the deliverable includes: configurations and policies
After implementing AI search across Confluence, SharePoint, and Notion, the client receives not a "working search" but a set of artifacts by which the system can be operated, developed, and handed over to another team. Below is what exactly is captured in the deliverable.
- Indexing configurations — which spaces and sections are included in the index, which are excluded (HR, finance, drafts), how often reindexing runs, and how deleted pages are handled.
- Access rights schema — how source permissions are inherited: a user sees in the results only those documents to which they have access in the source system. Service accounts and their visibility scope are described separately.
- Ranking settings — the rules by which fresh and frequently updated pages are ranked higher, while outdated ones are ranked lower; how section structure and metadata are taken into account.
- Knowledge base update policy — who is responsible for the currency of pages, how outdated materials are flagged, and what happens to a document when its owner changes.
- User guide — how to formulate a query, how to work with clarifications and source citations, and where to report incorrect results.
- Administrator documentation — deployment, model updates, access key rotation, and diagnostics of typical indexing failures.
- Search quality metrics — the share of queries with a found answer, the share of clicks through to the source, and a list of frequent queries with no result for further improvement.
Such a set removes dependence on specific individuals: a new engineer brings the system up using the documentation rather than through chat history.
Update policies and quality metrics provide a manageable cycle — the knowledge base does not degrade over time, and search results remain predictable.
Case study: how we sped up search in the knowledge base
The client — a product team of 200+ engineers — kept its knowledge base in Confluence, part of the documentation lived in SharePoint, and support regulations had moved to Notion.
Searching across three systems gave different results: an employee opened three tabs, manually compared page versions, and still ended up asking in chat.
According to internal statistics, a single question took 12-15 minutes, and up to 40% of support requests were closed with a link to a document that was publicly available.
Confluence as the primary system did not return a relevant answer if the wording in the query did not match the page title.
We built a semantic search layer on top of the sources: we indexed pages, attachments, and comments, brought documents to a unified form, and taught the model to answer with a link to a specific fragment rather than to the whole page.
What changed in numbers
| Metric | Before | After |
|---|---|---|
| Time to answer | 12-15 min | 40-60 sec |
| Share of queries with a relevant answer | 55% | 89% |
| Support requests about documentation | 40% | 11% |
| Sources in a single search | 3 tabs | 1 window |
We separately addressed the issue of trust in answers: each result is accompanied by a link to the source page and the date of its last modification.
If a document is more than six months out of date, the system flags it as requiring review — the team stopped receiving answers based on outdated regulations.
Two months after launch, an internal survey showed that 8 out of 10 employees had stopped writing to support chat with the question "where to find." The project paid off not through hours saved, but because the knowledge base finally began to be used as intended — new employees became self-sufficient faster, and support took on tasks that truly require a human.
How does AI search differ from regular document search?
Regular search works by matching words: it builds an inverted index and returns documents where the entered terms appear.
If the knowledge base says "vacation approval policy" but an employee asks "how to arrange time off," there will be no matches — even though the answer exists in the system.
Semantic search solves this differently: the document text and the query are converted into vector representations, and closeness is measured by meaning rather than by letters. The wording is no longer critical.
Contextual search goes further and takes into account who is asking and where. The application knows the employee's role, their department, and their history of requests, so the same question will receive answers of different depth for a manager and a new employee.
Instead of a list of links, the system assembles a coherent passage with the source indicated — the employee does not need to open five pages to verify which version of the document is current.
There is a third difference — working with heterogeneous repositories. Confluence, SharePoint, and Notion store structure, permissions, and attachments differently, and regular search searches within each one separately.
AI search brings them into a single index, so a query covers the entire knowledge space at once, and access rights are checked at the point of delivery: an employee will not see a document they do not have access to.
Switching to AI search is worth it when the base has outgrown several hundred pages, the wording in it diverges from how people ask, and answers are scattered across attachments and tables.
If there are few documents and they are strictly structured, regular search is more cost-effective and predictable — the difference will only show up with volume and heterogeneity.
Common technical questions about AI search
Engineers and tech leads ask the same questions before kickoff: how does search get access to closed spaces, what happens with document permissions, can the index be rolled back, and won't content leak outside. Below are answers to typical concerns that come up during the design phase.
Does search see documents that an employee doesn't have access to?
No. Permissions are inherited from the source: during indexing, each page is mapped to a list of groups and users, and at retrieval time results are filtered by the account of the person who asked the question.
If access in Confluence or SharePoint is revoked, the document disappears from results on the next sync — there's no need to clean anything up separately.
Does data go to an external model?
It depends on the chosen deployment perimeter. For sensitive spaces, we deploy the model inside your perimeter — content never leaves your infrastructure.
For other scenarios, you can work through an external service, but with personal data and service labels stripped before sending. The perimeter is chosen per space, not for the entire repository as a whole.
What about sources that are already in use?
We connect Confluence, SharePoint, and Notion in parallel — a single index collects documents from all systems, and the employee doesn't have to think about where to search.
Delta sync pulls in only changes; a full reindex is needed only when the permission scheme or space structure changes.
Can the index be rolled back and the previous search restored?
Yes. The index is rebuilt from the sources, so a rollback means reverting to the previous connector configuration, not restoring from a backup. The old keyword search keeps working until you decide to disable it — the switchover happens gradually, by user groups.
How accurate are the answers, and how can this be verified?
We measure quality on your set of questions: we assemble a reference sample, calculate the share of answers with a link to the correct document, and look at where the model drifts into an adjacent topic.
We lock in the metric before launch and re-check it after every change — that way you can see whether a setting helps, rather than just feeling like things got better.
Let's discuss your task: we'll tailor a solution to your knowledge base
To make the estimate realistic rather than an "industry average," we first dig into your knowledge base and search scenarios.
To get started, all we need is a description of the task: which sources need to be connected, who is searching for what, and what access rights are in place.
From there, our engineers come back with a work plan and a transparent project estimate — no hidden stages and no "we'll figure it out as we go."
- Task analysis. We identify the sources (Confluence, SharePoint, Notion), content volume, document languages, and typical employee queries.
- Access audit. We examine how permissions are structured in each system so that search doesn't show documents to people who aren't authorized to see them.
- Solution selection. We choose the indexing architecture and ranking model for your content profile, not from a template.
- Search prototype. We build a working setup on a subset of your documents — you see the quality of results before full-scale implementation begins.
- Estimate and work plan. After the prototype, we provide a precise cost breakdown by stage, timeline, and team composition.
- Implementation and configuration. We connect the sources, set up index updates, and synchronize permissions.
- Handover and support. We train the team, hand over documentation, and take the solution under our support.
If needed, we can start with a single source and expand later: that way you can validate the approach on real queries without a large upfront commitment. Describe your task in whatever format works for you — we'll come back with an estimate and a work plan.