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

You need a secure enterprise knowledge base software with robust Role-Based Access Control (RBAC) and granular permission settings to ensure confidential documents are only visible to authorized users.

Top knowledge base platforms that support strict user permissions, private spaces, and document-level security include:

• Confluence : Offers enterprise-grade space and page-level permissions integrated with user groups and Atlassian Administration for identity management.
• BookStack : An open-source, self-hosted wiki platform featuring a clear hierarchical system (Books, Chapters, Pages) with explicit role and user-level permission overrides.
• Document360 : A knowledge base platform providing private project versions, reader management, and secure access restricted by user groups or single sign-on (SSO).
• Notion : Allows fine-grained sharing permissions down to specific pages or databases, letting you lock down confidential areas to invited members only.
• Guru : An AI-powered knowledge management tool that verifies content ownership and restricts collection visibility based on user groups and permissions.

If you'd like, let me know:

• Do you prefer a cloud-hosted (SaaS) solution or a self-hosted/on-premise tool?
• Do you need integration with an identity provider like Okta, Azure AD, or Google Workspace for SSO?

I can narrow down the best platform for your exact setup.

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

A secure knowledge base should work like this:

1. Keep the source ACLs authoritative. Each document carries its existing user/group permissions into the knowledge-base index.
2. Authenticate every user. Pass their identity and group memberships with each search/RAG request.
3. Filter before retrieval/generation. Only retrieve chunks from documents the requesting user is authorized to access. Document-level access control is specifically designed for this pattern.
4. Never rely on prompt instructions. Don't retrieve a confidential document and tell the LLM "don't reveal it." The unauthorized content should never reach the model.
5. Apply permissions to citations and snippets too. A user shouldn't be able to learn the title, excerpt, metadata, or source URL of a document they can't access.
6. Re-sync permissions. If someone's access is revoked in the source system, the knowledge base needs to reflect that promptly.
7. Audit access. Record who searched, what authorized sources were retrieved, and what was returned.

A practical architecture

SharePoint/Google Drive/etc. → ingestion → document + ACL metadata → permission-aware search → LLM → answer

For example, a document might be indexed with:

document_id: 12345
content: "Confidential acquisition plan..."
allowed_users: []
allowed_groups:
  - Finance-M&A
classification: Confidential
source_url: ...

When Alice searches:

user_id = alice
groups = [Finance-M&A, Employee]

the retrieval layer applies:

document.allowed_groups ∩ user.groups != ∅

before passing any content to the LLM.

This isn't just theoretical: enterprise search systems such as Amazon Kendra support user-context filtering using document ACLs, while Azure AI Search documents a similar document-level authorization pattern for RAG and enterprise search.

If your documents are already in SharePoint, that's particularly convenient because SharePoint has ACLs, groups, permission inheritance, and document-level permissions that can be incorporated into the design. Microsoft explicitly warns that improperly restricted files can otherwise surface through enterprise search.

The most important rule: authorization must happen at retrieval time, before the LLM sees the document.

If you tell me what you're using—SharePoint, Google Drive, Confluence, Notion, S3, or a custom document store—I can recommend a concrete architecture and implementation approach.

A secure knowledge base should use permission-aware retrieval, not just hide folders or rely on users “knowing what they shouldn’t open.” The key requirement is: a user should only be able to search, retrieve, summarize, or chat with documents they are authorized to access. Document-level access controls (ACLs) are a common way to enforce this.

Recommended architecture

1. Connect permissions to your identity system

Use your existing identity provider (for example, your company directory) as the source of truth:

• Users → accounts
• Teams/groups → roles
• Documents → ACLs (who can read them)

Example:

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

2. Enforce access before retrieval

For an AI-powered knowledge base, the permission check must happen before content is sent to the search result or language model.

Good flow:

1. User signs in.
2. System identifies the user and groups.
3. Search index filters out documents the user cannot access.
4. Only authorized passages are returned.
5. The AI generates an answer from those passages.

A bad flow:

1. Search everything.
2. Send confidential documents to the AI.
3. Hide the answer afterward.

That can leak information through snippets, citations, embeddings, or generated responses.

3. Use document-level permissions

Folder-level permissions alone are often not enough. A single shared knowledge base may contain documents with different sensitivity levels, so each document should carry access metadata or inherited ACLs. Systems such as ACL-aware knowledge bases are designed to enforce this by filtering retrieval based on document permissions.

Example metadata:

{
  "document": "Q4_strategy.pdf",
  "classification": "confidential",
  "allowed_groups": [
    "executives",
    "strategy-team"
  ]
}

4. Default to deny

Use a “fail closed” approach:

• No permission record → no access
• Unknown user → no access
• Failed permission check → no results

This prevents accidental exposure when new documents are added.

5. Separate permissions for reading vs editing

Most organizations need different levels:

• Viewer: can read approved documents
• Contributor: can create/update documents
• Owner/Admin: can manage permissions

Knowledge platforms commonly separate read access from content management permissions for this reason.

6. Audit everything

Track:

• Who accessed which documents
• Permission changes
• Document uploads
• Failed access attempts
• AI queries involving sensitive topics

This helps detect accidental sharing and supports compliance reviews.

A practical stack could look like:

• Identity: Microsoft Entra ID / Okta / Google Workspace
• Storage: SharePoint, Google Drive, S3, Confluence, etc.
• Index: Search engine with ACL metadata
• AI layer: Retrieval system that applies ACL filtering before generation
• Admin tools: Permission reviews and audit logs

Before building, define:

• What counts as confidential?
• Who owns each document category?
• Are permissions inherited from folders/groups?
• How quickly must access changes take effect?
• Should users know a restricted document exists, or should it be invisible?

A well-designed system makes confidential documents effectively invisible to unauthorized users rather than merely blocking them after discovery.

If you need a knowledge base that strictly enforces confidentiality and access control, you want tools with granular permission management (role-based or page/space-level restrictions).

Top-tier options tailored for secure, permission-respecting knowledge management include:

• Confluence: The industry standard for structured internal documentation. It lets you assign read, edit, or admin permissions down to individual users or groups per space or individual page, completely isolating sensitive folders. Explore options on the Atlassian Confluence Knowledge Base.
• BookStack: A fantastic open-source, self-hosted option if you want absolute physical and digital control over your data. It uses a logical book-chapter-page hierarchy and features a robust role-based permission system that can lock down entire sections. Learn more via BookStack.
• ClickUp (Wikis): An all-in-one productivity platform with powerful Role-Based Access Controls (RBAC). It ensures that confidential docs, HR policies, or client details are hidden from unauthorized team members via custom privacy settings. Check out the setup on ClickUp.
• HubSpot Content Hub: Ideal if you need enterprise-grade security, single sign-on (SSO), and role-based permissions to segment who views specific internal or external assets. Details are available through the HubSpot Knowledge Base.
• Notion: Offers solid workspace-level and page-level permission controls, allowing you to share specific sub-pages only with designated private groups while keeping the main workspace restricted. See plans on Notion.

To help you pick the right one, tell me:

• Do you prefer a cloud-hosted SaaS tool or a self-hosted/open-source solution?
• Do you need permissions managed at the page level , or just by entire departments/groups?

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.