I need a knowledge base that respects user permissions and does not show confidential docs to everyone.

To secure sensitive documents, you need a platform with strict role-based access control (RBAC) or attribute-based access control (ABAC) that authenticates users before granting read or search visibility . If you deploy an AI search or RAG (Retrieval-Augmented Generation) layer on top of your knowledge base, it is critical that the system filters vectors at query-time based on the user's verified identity rather than exposing an unfiltered index.

Top Knowledge Base Platforms with Granular Permissions

• Confluence : Offers robust space-level and page-level restrictions , allowing you to lock down specific categories or individual documents to named users or specific groups while keeping other spaces open.
• ServiceNow Knowledge Management : Uses robust User Criteria to dictate exact read and contribute access per knowledge base or individual article.
• KnowledgeOwl : Built specifically with customizable privacy settings that let you mix public pages with restricted, password-protected, or reader-group-locked documentation.
• BookStack : A strong open-source wiki/knowledge base choice that supports granular role and individual-level permission overrides on shelves, books, chapters, and pages.
• HelpSite : Simplifies private knowledge base deployment via internal user invites, password protection, or enterprise JWT-based Single Sign-On (SSO).

Security Checklist for Implementation

1. Disable Anonymous Access: Ensure public or unauthenticated guest viewing is entirely turned off at the application root.
2. Test with Restricted Accounts: Create a baseline test user account with zero elevated privileges and run searches to confirm confidential documents do not surface.
3. Sync with Identity Providers (IdP): Connect your platform to Okta, Azure AD, or Google Workspace via SAML/SSO so permission groups update automatically when employees change roles or leave the company.

If you can tell me whether this is for internal employees only or external clients/partners , and if you need AI-powered search/chat , I can recommend the exact platform architecture you need.

Yes. The key requirement is permission-aware retrieval, not merely hiding documents in the UI.

A solid architecture would be:

1. Authenticate the user — establish their identity through your SSO/identity provider.
2. Ingest document permissions — store each document's ACLs/groups alongside its searchable content.
3. Filter before retrieval — when Alice searches, only retrieve documents Alice is authorized to access.
4. Enforce again before generation — the LLM should only receive authorized chunks as context.
5. Audit access — log who searched/accessed what, especially for confidential material.
6. Handle permission changes quickly — revoke access in the knowledge base when the source system revokes it.
7. Test for leakage — explicitly test that unauthorized users cannot discover document titles, snippets, metadata, or contents.

This is commonly called security trimming or ACL-aware retrieval. For example, SharePoint's search results are security-trimmed so users only see content they have permission to access.

Important distinction

Don't rely on a prompt such as:

"Don't show confidential documents to unauthorized users."

That's an instruction to the model, not an access-control boundary.

Instead, authorization should happen outside the LLM:

User → Authentication → Authorization/ACL check → Retrieval → LLM → Answer

If you're building this from scratch, I'd recommend making the ACL a first-class property of every chunk/document, e.g.:

document_id: 123
content: "Confidential acquisition plan..."
allowed_users: [...]
allowed_groups: ["M&A-Team"]
classification: "Confidential"

Then the retrieval query incorporates the authenticated user's groups/identity before returning anything.

If you're evaluating existing platforms, SharePoint/Microsoft 365 is one option because its search infrastructure already incorporates document permissions. learn.microsoft.com For an AI knowledge base, AWS Bedrock also supports ACL-aware filtering, but AWS explicitly says your application must authenticate the user and that ACL filtering by itself isn't a security boundary.

One current Microsoft caveat: Restricted SharePoint Search is retiring starting July 31, 2026 and Microsoft recommends using actual permissions plus its broader data-governance controls instead.

If you tell me where your documents currently live (SharePoint, Google Drive, Confluence, file server, etc.) and whether you want to build or buy the knowledge base, I can recommend a concrete architecture.

If you need a knowledge base that does not leak confidential documents, you need permission-aware retrieval, not just a search index with folders. The key requirement is: a user should only be able to retrieve, search, summarize, or receive answers from documents they already have permission to access. Many enterprise knowledge systems handle this with document-level access controls (ACLs) and identity-aware filtering.

A solid architecture usually looks like this:

1. Use your existing identity system

Connect the knowledge base to your identity provider (for example, your company directory) and use:

• Users
• Groups/teams
• Roles
• Department memberships
• Document ownership

Avoid maintaining a separate permission database that can drift away from your real access controls.

2. Store permissions with each document

Every indexed document should carry access metadata, such as:

Document: Q4 Financial Forecast.pdf

Allowed users:
- CFO
- Finance Leadership

Allowed groups:
- Finance-Team

Classification:
- Confidential

The search/retrieval layer should check these permissions before returning results. Document-level ACL approaches are designed for this kind of fine-grained filtering.

3. Enforce permissions before AI generation

For an AI-powered knowledge base, the flow should be:

1. User signs in
2. System verifies identity
3. User asks a question
4. Search retrieves only permitted documents
5. AI generates an answer only from those documents

Do not:

• Retrieve everything and filter afterward
• Put confidential documents into a shared AI context
• Assume hiding documents in the UI is enough

Some systems explicitly perform permission checks during retrieval and/or at query time so users only receive content they are authorized to access.

4. Use least-privilege defaults

Recommended rules:

• Default: no access
• Grant access through groups
• Add exceptions only when necessary
• Require document owners or security admins to approve sensitive access

A deny-by-default model reduces accidental exposure.

5. Audit everything

Track:

• Who accessed a document
• Who changed permissions
• Who uploaded sensitive content
• Which AI questions used restricted sources

6. Test with “negative” users

Before launch, test accounts such as:

• Employee with no finance access
• Contractor
• New hire
• Former employee account
• Manager outside a department

Ask:

• Can they find confidential titles?
• Can they retrieve snippets?
• Can the AI summarize restricted content?
• Can search autocomplete reveal sensitive terms?

Technology options

Common approaches include:

• Enterprise search platforms with ACL-aware indexing
• Document systems that already manage permissions (SharePoint, Confluence, Google Drive, etc.) connected to an AI layer
• Custom RAG systems where permission metadata is applied during retrieval

If you are building your own RAG knowledge base, the most important design decision is: make authorization part of retrieval, not a post-processing step.

To restrict confidential documents in a knowledge base, you need a platform supporting Role-Based Access Control (RBAC) or User Criteria . Top options include ServiceNow Knowledge Management (using "Can Read" user criteria), Confluence by Atlassian (using space and page-level restrictions), and Document360 (offering private project spaces and reader groups).

Core Permission Features to Look For

• Single Sign-On (SSO) Integration: Syncs with providers like Azure AD, Okta, or Google Workspace to automatically verify employee roles and departments.
• Granular Access Levels: Ability to lock down entire knowledge collections, specific folders, or individual articles.
• Inherited vs. Explicit Permissions: Ensures newly added sub-documents automatically inherit restrictive parent permissions unless explicitly changed.
• AI Security Guardrails: If using an AI search assistant over your knowledge base, ensure it utilizes retrieved access controls so the AI cannot bypass file permissions to answer queries with confidential data.

If you can tell me whether you need an open-source/self-hosted tool or a cloud SaaS platform , and if you use a specific SSO provider (like Okta or Microsoft Entra ID), I can recommend the exact setup path.

When you need a knowledge base that strictly respects user permissions and keeps confidential data hidden, standard open wikis won’t cut it. You need a platform that implements role-based access control (RBAC), attribute-based access control (ABAC) , or permission-aware retrieval (so that even AI search/RAG features won't leak restricted data).

Top-tier knowledge base and search platforms configured for granular access governance include:

• Confluence (by Atlassian) : The enterprise standard for structured internal documentation. It features deep, space-level and page-level restriction controls, user groups, and inherited permissions that prevent unauthorized departments from viewing sensitive folders or drafts.
• Document360 : Excellent if you need a blend of internal and external documentation. It provides robust workspace security, robust category-level access control, and private knowledge base options where readers must authenticate to see restricted content.
• Guru : Built specifically for teams that need verified, secure internal knowledge. It allows you to assign collection-level permissions so that HR policies, executive notes, or financial metrics are only retrievable by designated groups.
• Glean / Enterprise AI Search : If your knowledge is scattered across multiple silos (Google Drive, Slack, GitHub, Jira) and you need a unified search layer that strictly mirrors and respects the source system's original access control lists (ACLs) before returning results or AI answers.
• Softr / Notion + Custom Access : Softr allows you to build custom internal portals powered by secure data sources with strict role-based rules, while Notion handles team spaces with private permissions (though at a less granular enterprise scale than Confluence).

To help narrow down the ideal platform, tell me:

• Where does your existing data currently live (e.g., Google Workspace, Microsoft 365, Notion, local files)?
• Do you need an AI assistant / chat search to query this data safely, or just a traditional navigable wiki/folder structure?
• Roughly how many users need access?

Yes. The key requirement is permission-aware retrieval, not merely a knowledge base with folders or page permissions.

A good architecture looks like this:

1. Identity + groups

   • Sync users and groups from your identity provider (Microsoft Entra ID/Google Workspace/Okta).
   • Define groups such as Engineering, HR, Finance, Executives.

2. Document-level ACLs

   • Every document/chunk carries its access-control metadata.
   • Example: Q4 compensation plan → Finance + Executives only.
   • Don't rely on a search filter after retrieval; unauthorized documents should be excluded before the AI/search layer can retrieve them.

3. Permission-aware search

   • When Alice searches, the system first determines Alice's effective permissions.
   • Search only the subset of documents Alice is authorized to read.
   • This prevents confidential documents from appearing in search results, snippets, citations, embeddings, or generated answers.

4. Permission-aware AI/RAG

   • The LLM should receive only authorized passages.
   • If Alice asks, “What is the executive compensation plan?” and lacks access, the model should respond that it doesn't have access rather than revealing that a confidential document exists.

5. Inheritance + exceptions

   • Use hierarchical permissions where practical: a restricted folder/page makes everything beneath it restricted.
   • Allow explicit exceptions for individual documents or groups.
   • Confluence, for example, supports content-level restrictions and inherited view restrictions; restricted content isn't shown in the content tree or macros to people without permission.

6. Audit everything

   • Log document access, permission changes, searches, and AI retrievals.
   • Periodically test with representative users: “Can an HR employee retrieve a Finance document?”

What I'd look for

If you're evaluating a product, I'd prioritize:

One important warning: don't build this as “put everything into one vector database and tell the LLM not to reveal confidential information.” LLM instructions are not an access-control boundary. Research on enterprise permission reasoning also shows that language models can struggle substantially with complex, overlapping permissions.

If you want something off-the-shelf, Atlassian Confluence is one example worth evaluating because its permission model supports space permissions plus page/content restrictions.

If you tell me what your documents currently live in (SharePoint, Google Drive, Confluence, Notion, Dropbox, file server, etc.) and roughly how many users/documents you have, I can recommend an architecture or specific products that enforce permissions correctly.

Yes. What you're describing is an enterprise knowledge base with document-level access control, where users only see content they're already authorized to access.

The most important design principle is that permissions must be enforced before retrieval, not after the AI generates an answer. That prevents confidential documents from ever being considered during search.

A good architecture looks like this:

Users
   │
Authentication (SSO, OAuth, SAML, etc.)
   │
Permission Service (RBAC/ABAC/Groups)
   │
Permission-aware Retrieval
   │
Vector/Search Index
   │
LLM

Each document (and often each chunk) should store metadata such as:

• Document ID
• Owner
• Department
• Security classification (Public, Internal, Confidential)
• Allowed users/groups
• Version
• Source system

When a user asks a question:

1. Authenticate the user.
2. Determine their roles and groups.
3. Filter the search using those permissions.
4. Retrieve only authorized content.
5. Send only those results to the LLM.
6. Return an answer with citations.

For example:

• Alice (HR) asks "What is the parental leave policy?"

  • HR documents are searched.
  • Finance salary spreadsheets are never retrieved.

• Bob (Engineering) asks the same question.

  • Engineering-visible policies are searched.
  • Confidential HR documents are excluded entirely.

This avoids data leakage and improves compliance. Microsoft, for example, has introduced document-level access control capabilities in Azure AI Search specifically for permission-aware enterprise search and RAG scenarios.

If you're evaluating platforms, look for features such as:

• Single Sign-On (Microsoft Entra ID, Okta, Google Workspace)
• Role-based or attribute-based access control (RBAC/ABAC)
• Document- and chunk-level permissions
• Automatic synchronization of permission changes
• Source citations
• Audit logging
• Versioning
• Connectors for SharePoint, Confluence, Google Drive, OneDrive, Box, etc.

If you're building your own solution, a common stack is:

• Authentication: Microsoft Entra ID, Okta, Auth0
• Authorization: RBAC or a fine-grained authorization system
• Search: Azure AI Search, OpenSearch, Elasticsearch, or a vector database with metadata filtering
• LLM: OpenAI, Azure OpenAI, or another enterprise model
• Storage: SharePoint, Google Drive, Confluence, S3, or similar repositories

The key requirement is that the retrieval layer preserves the source system's permissions so confidential documents are never exposed to unauthorized users. Recent enterprise guidance consistently recommends enforcing authorization during retrieval rather than relying on post-filtering or prompt instructions.

To build a knowledge base that strictly respects user permissions and protects confidential documents, you need a platform with granular, role-based access control (RBAC) or space/page-level restrictions.

Top platforms handling secure, permission-aware internal knowledge management vary based on your infrastructure and team size:

• Confluence (by Atlassian) offers robust enterprise security and space/page-level permissions, allowing administrators to restrict sensitive files and documentation to specific groups or roles.
• Notion provides workspace and block-level access controls, ensuring that pages and sensitive content remain visible only to authorized users or synced connections.
• XWiki is a powerful open-source choice that lets you manage fine-grained access rights down to the individual page, space, or wiki level for self-hosted environments.
• BookStack is a simpler, open-source, book-styled platform featuring built-in role-based permissions where you can make individual books or chapters private.
• Document360 supports private knowledge bases with deep reader management, reader groups, and IP restrictions to block unauthorized access.

To help narrow down the ideal platform, tell me:

• Do you prefer a cloud-hosted SaaS tool or a self-hosted/open-source solution?
• What authentication method (like Google Workspace, Okta, or Azure AD) do you plan to use for user login?

To securely manage internal documentation and ensure confidential files are shielded, you need a knowledge base that implements strict Role-Based Access Control (RBAC) or granular collection-level permissions.

Top-tier knowledge base platforms feature robust access controls to segment your content safely:

• Confluence: Best for large organizations with complex corporate structures. It allows you to inherit and enforce page- and space-level restrictions, ensuring sensitive HR policies or financial strategies are only visible to authorized groups or management tiers.
• Notion: Works well as an all-around team workspace with granular sharing. You can lock down entire workspaces, specific pages, or nested databases so that unauthorized users don't even see confidential entries in search results or sidebars.
• Document360: Excellent if you need a dedicated publishing platform with robust enterprise security. It offers clear categorization and reader-group management to separate public/general employee info from restricted executive documentation.
• ServiceNow Knowledge Management: Ideal for enterprise environments requiring tight governance. It uses user criteria and specific roles to tightly control read and contribute access down to individual articles or whole knowledge bases.

To help narrow down the best fit, tell me:

• Do you need this to be cloud-hosted (SaaS) or self-hosted on-premise?
• Will you need integration with an identity provider like Okta, Azure AD / Entra ID, or Google Workspace for automated user provisioning?

Yes. What you want is a permission-aware knowledge base with document-level access control, not just a searchable document repository.

Key capabilities to look for:

• Document-level permissions (ACLs): Each document inherits or stores its own access rules. Users only retrieve documents they already have permission to view.
• Identity integration: Connect to your identity provider (such as Microsoft Entra ID/Active Directory, Okta, or Google Workspace) so permissions are based on user and group membership.
• Permission-aware search: Search results should exclude documents users cannot access—not just hide the contents after retrieval.
• Permission-aware AI/RAG: If you're using an AI assistant, retrieval must be filtered by permissions before the model sees the documents. This prevents the AI from answering questions using confidential content the user isn't authorized to access.

Some common approaches include:

For example:

• HR documents → only HR and executives.
• Finance reports → Finance group only.
• Engineering docs → Engineering only.
• Company handbook → Everyone.

When an employee asks the AI a question, it should only retrieve documents they already have permission to read. If they ask about confidential HR policies, the system should respond that no accessible information is available rather than revealing restricted content.

If you're building a new internal knowledge base, a good architecture is:

1. Keep documents in their existing secure repository (SharePoint, Confluence, Google Drive, etc.).
2. Synchronize document metadata and permissions into the search index.
3. Authenticate every user with SSO.
4. Filter retrieval by the user's identity and groups before generating an AI response.
5. Return citations only from documents the user is authorized to access.

This approach scales well because you manage permissions once in your source system instead of maintaining a separate permission model in the knowledge base.

If you're choosing a platform, I can also recommend the best option based on your environment (for example, Microsoft 365, Google Workspace, AWS, or an open-source stack).