Skip to content

Concept buildA worked example of how we would build this for a typical business. Not client work: no client, no client data, no achieved results.

Custom AI

Concept build

Private Knowledge Assistant on Your Own Cloud

A concept build for an internal assistant that answers staff questions from a firm’s own documents, inside the firm’s cloud account. Every answer cites its sources, and retrieval is filtered by each person’s existing document permissions, so nobody gets an answer built from a file they could not open.

Concept build cover: sage particles settling into a smooth manifold on dark inkConcept build
Built for
A typical professional services firm
Industry
Professional services
Market
US market
Typical timeline
6–8 weeks from source mapping to a pilot with one practice group

The brief

The problem this concept answers

A typical US professional services firm keeps its know-how in documents that are hard to find. Precedents, templates, policies and past work sit across shared drives and a document management system, and finding the right one depends on knowing who wrote it. Public AI chat tools are quick, but the firm’s own policies keep client material out of them, and a generic assistant that indexes everything would show people documents behind ethical walls or matter-level restrictions. The firm needs search that answers in plain language, shows where each answer came from and respects the permissions it already has.

In the first version

  • Connectors for the document stores in scope, with their access lists
  • Deployment in the firm’s cloud account behind single sign-on
  • Permission-aware retrieval and cited answers
  • Audit log, flag-an-answer and content-owner routing
  • Evaluation set used as the go-live gate

Left out on purpose

  • Drafting client documents or giving advice
  • Indexing email or chat archives
  • Changing who may open which documents: permissions stay in the source systems
  • Training or fine-tuning a model on the firm’s documents

Explainer

The build in seven slides

Watch the narrated video, step through the slides or read the transcript.

Explainer · 7 slides · about 45 s

Concept build

Concept build: Private Knowledge Assistant on Your Own Cloud

Concept build, explained in 7 slides: a concept build for an internal assistant that answers staff questions from a firm’s own documents, inside the firm’s cloud account.

Concept build: Private Knowledge Assistant on Your Own CloudConcept build

Custom AI

Private Knowledge Assistant on Your Own Cloud

A concept build for an internal assistant that answers staff questions from a firm’s own documents, inside the firm’s cloud account.

Concept build: Private Knowledge Assistant on Your Own CloudConcept build

The problem

What a typical professional services firm is up against

A typical US professional services firm keeps its know-how in documents that are hard to find. Precedents, templates, policies and past work sit across shared drives and a document management system, and finding the right one depends on knowing who wrote it.

Concept build: Private Knowledge Assistant on Your Own CloudConcept build

The approach

How we would build it, in 5 steps

  • Sources, permissions and the question set
  • Deployment inside your cloud account
  • Permission-aware retrieval
  • Cited answers and honest refusals
  • Evaluation gate and a staged rollout
Concept build: Private Knowledge Assistant on Your Own CloudConcept build

Architecture

How the pieces connect

Diagram: Document stores to Permission sync (files + access lists); Permission sync to pgvector index (tagged chunks); Signed-in staff to Filtered retrieval (question + identity); pgvector index to Filtered retrieval (candidates); Filtered retrieval to Model in your VPC (permitted passages); Model in your VPC to Signed-in staff (cited answer); Model in your VPC to Content owner (no source found); Model in your VPC to Audit log (answer + sources).

Diagram with 8 parts: Signed-in staff (source), Document stores (source), Permission sync (processing), pgvector index (processing), Filtered retrieval (processing), Model in your VPC (model), Content owner (human), Audit log (system of record).

Connections:

  • Document stores → Permission sync (files + access lists)
  • Permission sync → pgvector index (tagged chunks)
  • Signed-in staff → Filtered retrieval (question + identity)
  • pgvector index → Filtered retrieval (candidates)
  • Filtered retrieval → Model in your VPC (permitted passages)
  • Model in your VPC → Signed-in staff (cited answer)
  • Model in your VPC → Content owner (no source found)
  • Model in your VPC → Audit log (answer + sources)
Concept build: Private Knowledge Assistant on Your Own CloudConcept build

Demo · sample run

Sample data

Two associates ask the same question

Scenario: Two associates ask the same question

  1. Associate asks a questionSample question: our usual limitation-of-liability wording for software deals.Done
  2. Identity checked through SSOThe signed-in user and their matter-team groups are attached to the query.Done
  3. Filtered retrievalSix passages found; two from a restricted matter removed before ranking.Needs review
  4. Cited answerAnswer built from four permitted passages, each linked to its source document.Done
  5. Associate on the matter teamSame question; the restricted precedent is included and cited with its matter tag.Done
  6. Audit log writtenBoth questions, answers, citations and users logged in the firm’s account.Done
Concept build: Private Knowledge Assistant on Your Own CloudConcept build

Typical targets

What we would measure it against

  • Typical targetAnswers drawn only from documents the asking user may openBasis: Design property: permission filter at retrieval, tested with role-based test accounts before go-live
  • Typical targetDocuments and the index stay in the firm’s cloud accountBasis: Design property: deployed in the firm’s account;
  • Typical target85–95% of in-scope evaluation questions answered correctly, with a correct sourceBasis: Graded on an evaluation set built from your real questions; unanswerable questions never count as correct
  • Typical targetEvery answer logged with its sources for later reviewBasis: Design property: question, answer, citations and user are written to an audit log the firm controls
Concept build: Private Knowledge Assistant on Your Own CloudConcept build

Next step

Scope a build like this for your business

A free call to map your workflow, data and the first version.

Book a Strategy CallFree 30-minute call · no commitment

Slide 1 of 7

Architecture

How the pieces connect

  • Signed-in staff· channel
  • Document stores· source
  • Permission sync· processing
  • pgvector index· processing
  • Filtered retrieval· processing
  • Model in your VPC· model
  • Content owner· person
  • Audit log· system of record
Show the architecture diagram

Architecture of the Private Knowledge Assistant on Your Own Cloud concept: Document stores → Permission sync (files + access lists); Permission sync → pgvector index (tagged chunks); Signed-in staff → Filtered retrieval (question + identity); pgvector index → Filtered retrieval (candidates); Filtered retrieval → Model in your VPC (permitted passages); Model in your VPC → Signed-in staff (cited answer); Model in your VPC → Content owner (no source found); Model in your VPC → Audit log (answer + sources).

Diagram with 8 parts: Signed-in staff (source), Document stores (source), Permission sync (processing), pgvector index (processing), Filtered retrieval (processing), Model in your VPC (model), Content owner (human), Audit log (system of record).

Connections:

  • Document stores → Permission sync (files + access lists)
  • Permission sync → pgvector index (tagged chunks)
  • Signed-in staff → Filtered retrieval (question + identity)
  • pgvector index → Filtered retrieval (candidates)
  • Filtered retrieval → Model in your VPC (permitted passages)
  • Model in your VPC → Signed-in staff (cited answer)
  • Model in your VPC → Content owner (no source found)
  • Model in your VPC → Audit log (answer + sources)

Connections

  1. Document stores → Permission sync (files + access lists)
  2. Permission sync → pgvector index (tagged chunks)
  3. Signed-in staff → Filtered retrieval (question + identity)
  4. pgvector index → Filtered retrieval (candidates)
  5. Filtered retrieval → Model in your VPC (permitted passages)
  6. Model in your VPC → Signed-in staff (cited answer)
  7. Model in your VPC → Content owner (no source found)
  8. Model in your VPC → Audit log (answer + sources)

Sample run

One run, step by step

Two associates ask the same questionSample data
  1. Associate asks a questionRoutine

    Sample question: our usual limitation-of-liability wording for software deals.

  2. Identity checked through SSORoutine

    The signed-in user and their matter-team groups are attached to the query.

  3. Filtered retrievalNeeds care

    Six passages found; two from a restricted matter removed before ranking.

  4. Cited answerRoutine

    Answer built from four permitted passages, each linked to its source document.

  5. Associate on the matter teamRoutine

    Same question; the restricted precedent is included and cited with its matter tag.

  6. Audit log writtenRoutine

    Both questions, answers, citations and users logged in the firm’s account.

Build plan

How we would build it

Typical timeline
6–8 weeks from source mapping to a pilot with one practice group
Stack
  • Open-weight LLM on a private GPU
  • Or a no-retention provider API
  • Postgres with pgvector
  • Permission sync from document stores
  • Single sign-on and role-based access
  • Audit log in your cloud account
  • Evaluation set and flag-an-answer
  1. Sources, permissions and the question set

    We list the document stores in scope and how each one records access: groups, matter teams and individual exceptions. With practice leads we write an evaluation set of real questions, including some the documents cannot answer, which the assistant must decline. That set becomes the go-live gate.

  2. Deployment inside your cloud account

    Everything runs in the firm’s own cloud account: the index, the application and the model. The default is an open-weight model on a private GPU; where the firm prefers a commercial model, we use the provider’s zero-retention or enterprise data settings where offered and record the terms. Staff sign in through the firm’s existing single sign-on.

  3. Permission-aware retrieval

    Documents are chunked and indexed in Postgres with pgvector, each chunk tagged with the access list of its source document. At question time, retrieval filters by the signed-in person’s identity before ranking, so a restricted document cannot reach the model for someone who could not open it. Permission changes re-sync on a schedule, and the delay is stated in the runbook.

  4. Cited answers and honest refusals

    The model answers only from retrieved passages and cites each one with a link to the source document. If retrieval finds nothing relevant, it says so and offers to send the question to the content owner for that area instead of answering from general knowledge. Every question, answer and citation is written to an audit log the firm controls.

  5. Evaluation gate and a staged rollout

    The assistant opens to one practice group only after it passes the evaluation set, with refusals tested as carefully as correct answers. During the pilot, staff can flag an answer in one click, and flagged answers feed a weekly review with content owners before the next group is added.

Typical targets

What we would measure it against

Targets for a typical business of this kind, not achieved results. A real project measures its own baseline first.
  • Typical target

    Answers drawn only from documents the asking user may open

    Basis: Design property: permission filter at retrieval, tested with role-based test accounts before go-live

  • Typical target

    Documents and the index stay in the firm’s cloud account

    Basis: Design property: deployed in the firm’s account; queries leave it only if the firm picks a no-retention API

  • Typical target

    85–95% of in-scope evaluation questions answered correctly, with a correct source

    Basis: Graded on an evaluation set written from your real questions before launch. Questions your sources cannot answer must be declined or handed off, and never count as correct.

  • Typical target

    Every answer logged with its sources for later review

    Basis: Design property: question, answer, citations and user are written to an audit log the firm controls

Your project

What a real project adds

  • A data-path review

    Where each piece of data goes and which provider processes it; residency is checked per project, never assumed.

  • Model choice tested on your data

    Candidate models compared on a held-out sample of your own documents or images before one is chosen.

  • The deployment shape that fits

    On accounts in your name, self-hosted open-weight models, or on-premise as an Enterprise scope.

  • Monitoring and a refresh plan

    Drift checks, a review cadence and the steps to update the model or the index when your data changes.

Decisions this concept leaves for scoping

  • Drafting client documents or giving advice
  • Indexing email or chat archives
  • Changing who may open which documents: permissions stay in the source systems
  • Training or fine-tuning a model on the firm’s documents

FAQ

Questions about this build

Is a firm already using this private knowledge assistant?

No. It is a concept build for a typical US professional services firm, and the associates, matter and precedent in the demo are fictional. The 85–95% range is a go-live bar we would set with a real firm’s practice leads on their own questions; it is not a score any deployment has achieved.

Can someone see an answer drawn from a document they can’t open?

Not by design. Every indexed passage carries the access list of its source, and retrieval filters by the signed-in person before anything is ranked or sent to the model. Before launch we test this with accounts set up for different roles and matter teams, and permission changes re-sync on a stated schedule.

Does a law firm’s duty of confidentiality rule this out?

It shapes the design rather than ruling it out. The ABA’s Formal Opinion 512 (2024) asks lawyers who use generative AI to protect client information, understand the tool’s limits and review its output; private deployment, permission filtering, citations and audit logs are built to support those duties. The firm’s own counsel still signs off before anyone uses it.

Why run an open-weight model instead of a commercial API?

Because it keeps every query and document inside the firm’s account, which some firms and their clients require. Open-weight models can trail the strongest commercial models on harder questions, so the evaluation set decides: if the private model misses the go-live bar, a commercial API under no-retention terms is the documented alternative.

Who keeps the documents and answers up to date?

Each practice area has a named content owner. Questions the assistant could not answer, and answers staff have flagged, are routed to that owner, who decides whether a document needs writing, updating or retiring. The index re-syncs from the source stores, so fixing the document fixes the answer.

Worked examples

More concept builds for this service

Concept builds are worked examples, not client work.

See all concept builds
Concept build

Custom AI

Visual Defect Triage for a Small Manufacturer

A concept build for a camera inspection step that sorts machined parts into pass, flagged or unsure with a detector trained on the plant’s own images. Unsure parts always go to a person, and the quality team keeps the final say on scrap and rework.

  • Manufacturing
  • India market
  • Oct 2026

Next step

Have a workflow in mind? Let’s scope it together.

Book a free 30-minute strategy call. Bring one process you want to automate and we will talk through scope, integrations and a sensible first step.

Free 30-minute call · no commitment

Send an RFP or security questionnaire