Data handling: what flows where
This page describes what data DioscHub moves and what it keeps, so you can map it against your own compliance obligations rather than take a claim on faith. Nothing here is an assurance about your MCP servers or your app — only about what DioscHub itself does with the data that passes through it.
The path a message takes
Section titled “The path a message takes”- The widget connects. The chat widget opens a connection and, until it is bound, has no identity.
- Your backend binds it. Your server calls DioscHub’s bind endpoint, server-to-server, asserting who the user is and handing over the auth artifacts to forward. This hop is authenticated with a scoped admin API key — the browser never asserts identity, and the public embed key cannot. DioscHub derives which assistant is in play from the connection, not from anything the caller supplies.
- The identity is stamped on the session. From bind onward, the connection’s session carries the user’s id and resolved Role, and holds the auth artifacts so they can be forwarded.
- A turn runs. When a tool fires, the user’s credentials go to your MCP server on the transport (HTTP request headers), while the model works only with tool results and a small envelope of non-identifying context. This split is the credential-blind guarantee.
The auth artifacts your backend hands over are held for the life of the session so DioscHub can forward them to your MCP servers, and are forwarded verbatim — DioscHub does not parse or interpret them, and does not write them into its logs (log lines record counts and ids, never credential values).
What DioscHub persists to run a conversation
Section titled “What DioscHub persists to run a conversation”Running a conversation and its history means keeping some data. The durable stores, and what each holds:
| Store | What it holds | Carries user content or identifiers |
|---|---|---|
| Message history | The conversation itself — the messages exchanged, and the tool calls and results, including file text the assistant read — so a session can be resumed and reviewed | Yes — message text and file content |
| Conversation analytics | Aggregate signals about a conversation: topic, intent, counts, duration | Keyed to the user; no message text |
| Session records | The identity snapshot for the session — user id, name, resolved Role, the pages visited, a first-message preview | Yes — identifiers and a preview |
| Chat files | Files a user uploads inside a chat — private to that user | Yes — private user data |
| Knowledge-base files | Shared reference documents an operator uploads | Shared, not per-user |
| Approval records | A record of each reviewed tool call — the tool, the operation, the decision | Tool and decision; not the forwarded auth |
| Problem reports | What a user approved to report about a failure: their draft, optionally a conversation excerpt, a page path and the failed tool calls (see Problem reports) | Yes — user-written text, the user id, and what they chose to attach |
The line between a user’s private data and shared organizational data is drawn deliberately, and the admin portal stays on the shared side of it — see Privacy boundary. When you need to remove a person’s data, Data erasure & GDPR sets out exactly which of these stores are scrubbed and which are retained by design. To give a person a copy of it, see Subject access export.
Conversations and files are kept until they are deleted or erased, unless you turn on the retention window below.
How long conversations are kept
Section titled “How long conversations are kept”The retention window deletes conversations and users’ files automatically once they have gone unused for a period you choose. It is one setting for the whole deployment. It works on every tier, Free included, and it is off by default.
The setting
Section titled “The setting”The window is on the Retention tab of the Data Privacy page. Anyone with data-privacy:read can
see it; changing it needs data-privacy:execute, which the built-in Owner and DPO roles have.
| Control | Default | Range |
|---|---|---|
| Delete old conversations and user files | Off | |
| Days after the last message (user files: last use) | 30 to 3650 days | |
| Keep pinned conversations | On | |
| Delete pinned conversations after a limit, with Pinned limit in days | Off: pinned conversations are kept with no limit | 30 to 3650 days |
The tab states the period in force in words, for example Conversations are deleted 365 days after their last message, and user files 365 days after their last use. Pinned conversations are kept.
- A change that deletes sooner waits 7 days. That is turning the window on, shortening it, switching
Keep pinned conversations off, or setting or shortening the pinned limit. Before it is saved, the
page shows a dry run (From [date], N conversations would be deleted in the first run, with the pinned
conversations kept and deleted) and asks you to type the resulting period, for example
90 days. The current setting stays in force until the date, and the tab shows the change waiting and when it starts. A new change of this kind replaces the waiting one and starts its 7 days again. - A change that keeps data longer applies at once. That is lengthening the window, turning it off, switching Keep pinned conversations on, or lengthening or removing the pinned limit. It also cancels a change that is waiting.
- Every change is audited with the old and new values (
retention_settings_changedon the data-privacy audit trail). - Configuration transfer never carries it. An export has no retention setting in it, and an import never sets or changes the target’s (see Configuration transfer).
When something expires
Section titled “When something expires”- A conversation expires when its last message is older than the window. Only a stored message, from the user or the assistant, moves the clock. Pinning, renaming or a status change doesn’t, so a conversation in regular use never expires.
- A pinned conversation is kept while Keep pinned conversations is on. With a pinned limit, it expires that many days after its last message, but never before the window (the longer of the two applies). With Keep pinned conversations off, pinned conversations expire like any other.
- An anonymous visitor’s conversation expires by the same rule as any other. Its 24-hour limits on files and the access token (see Anonymous sessions) are unchanged, and there is no user record to remove for it.
- A user’s file expires when its last use is older than the window: the last time it was read, attached to a message or downloaded, or its upload time if it was never used. Pins don’t keep files. This is separate from file retention, which stamps an expiry when a file is written; when both are on, whichever comes first removes the file.
- A person is removed from an assistant when they have no conversations and no files left in it and haven’t been seen within the window. Their identity is replaced by the one-way erasure tombstone, their links in knowledge-gap signals are removed, any export of their data is deleted, and their preferences are deleted unless another assistant still holds a live record of the same person.
What the window removes
Section titled “What the window removes”An expired conversation goes through the same path as erasing a conversation, so the same scrub and verification apply, and then the conversation itself is deleted:
- its messages, tool calls and results, files held by the conversation, feedback, turn timings, approval records, search-index entries and per-conversation analysis are deleted;
- usage records stay, so totals stay right, but no longer carry the person’s id;
- tool server and model error records tied to it lose the person’s id, and are then purged on their own schedule (below).
An expired user file is deleted through the normal delete path: its stored bytes, extracted text, search index and derived files go with it.
If the conversation is open in the widget when it is deleted, the widget’s next message on it gets the
SESSION_NOT_FOUND error.
What the window never removes
Section titled “What the window never removes”- Pinned conversations, while Keep pinned conversations is on and no pinned limit has passed. Erasure still removes them.
- Knowledge-base files. They belong to the assistant’s setup.
- A conversation with a turn running. It is skipped and tried again the next night.
- The admin audit trail. It keeps its own limit, and the record of each erasure is kept.
- Your backups. They follow your own backup policy.
Logs that carry end-user ids
Section titled “Logs that carry end-user ids”Three logs hold rows tied to a person’s conversations. Each is purged nightly by its own limit, and while the window is on, each keeps the shorter of its own limit and the window:
| Log | Its own limit |
|---|---|
| Approval log | 365 days (APPROVAL_LOG_RETENTION_DAYS) |
| Tool server error log | 30 days (MCP_ERROR_LOG_RETENTION_DAYS) |
| Model error log | 30 days (MODEL_ERROR_LOG_RETENTION_DAYS) |
These rows follow the window whether or not the conversation is pinned: a pin keeps the conversation, not its log rows. The hourly per-tool call counts (no session or user in them), the MCP health log and the admin audit trail keep their own limits.
Waiting for Business Intelligence
Section titled “Waiting for Business Intelligence”This option appears only when Business Intelligence is licensed (Pro or Enterprise) and its classification is switched on. Without it, conversations are deleted at the window.
- Keep conversations BI has not classified yet, for a while after they expire is off by default. Set Most days to keep them from 1 to 30. The change applies at once, with no 7-day notice and no typed confirmation.
- With it on, an expired conversation that BI hasn’t classified yet is kept up to that many days past its expiry, then deleted whatever its state. A classified one is deleted on time. User files and people never wait. The tab states the real period, for example …Conversations BI hasn’t classified yet are kept up to 14 more days while BI classifies them.
- If BI stops being licensed or is switched off, the wait stops from the next run. The setting is left as it is, and the tab says Waiting for BI is switched on but not in effect.
- With the wait off and BI on, each expiring conversation BI hasn’t classified gets one classification attempt in the same run, and is then deleted on time whatever the outcome. The run spends at most 10 minutes per batch and 30 minutes in all waiting for these attempts.
- Nightly, at 04:30 server time by default (
DATA_RETENTION_CRON), after BI’s nightly classification. If that is still running, the run waits up to 2 hours for it, then goes ahead. - Once per cluster. In a cluster, one instance runs it, under the distributed lock.
- In batches. Oldest first, 100 at a time, at most 2,000 conversations, 2,000 user files and 2,000 people per run. The rest wait for the next night.
- Careful at the last moment. Each conversation is checked again just before it is deleted: one that got a message or a pin since it was selected is kept. One whose deletion fails in any step is left as it is and tried again the next night, and one failure never stops the run.
- Audited. Each run writes one
retention_runentry with its counts: conversations, user files and inactive people removed, pinned kept, skipped because a turn was running, failures by step, left for the next run, and held for BI. It holds no conversation ids, user ids or file names.
The Runs section of the tab shows the last run and the next one, with what the next run would remove: Next run [date]: it would remove N conversations, N user files and N inactive users (N pinned kept).
What users see
Section titled “What users see”Where session history is licensed (Pro or Enterprise) and the Role grants it, the widget’s conversation list warns before a conversation is deleted. Without session history the widget has no conversation list, so it shows no markers; the conversations are deleted all the same.
- A conversation within 7 days of deletion shows “Deleted in N days. Pin to keep.”, or just “Deleted in N days.” when it is already pinned or Keep pinned conversations is off.
- The pin button’s tooltip says what pinning does under the current setting: Pinned conversations aren’t deleted automatically, Pinned conversations are kept for N days after their last message (with a pinned limit), or Pinned conversations are deleted after N days without activity, like the others.
- A change that deletes sooner shows in the markers as soon as it is saved, so users see it during the 7-day notice.
The Files dialog’s “Expires in N days” shows file retention only; it doesn’t show when the window will remove a file.
Problem reports
Section titled “Problem reports”Problem reports are a Pro feature. The assistant may offer one after a server-side
failure, or a user may start one with /problem. A report is created only when the user approves it in the
consensus dialog, after seeing exactly what it would hold.
What is stored, and where it goes
Section titled “What is stored, and where it goes”- Held: the user’s reviewed title, summary and optional steps, expected and actual; optionally an excerpt of the
last 10 user and assistant messages (each cut to 1,000 characters, the whole to 8,000, secrets redacted), the
page path, and up to 20 failed tool calls of that conversation (server, tool, category, status, redacted error
text of up to 2,000 characters, time). The report also records who filed it (the user id, or “anonymous”), the
conversation it came from, whether it was offered by the assistant or typed as
/problem, and the assistant’s own assessment (defect,not_a_defect,unsure). Each of the three attachments is switched off by the user or left out. - Never held: credentials, auth headers or any bound auth artifact; tool arguments; tool results or file contents; images. The preview is built only from this conversation’s failed-call records, its messages and its page path, so credentials stay out, and the model never sees the preview, only the report id.
- Where it goes: into DioscHub’s own database. Nothing is sent anywhere until an administrator adds a webhook sink. A sink then receives the events the administrator chose, signed with its secret, and the system on the other end becomes the controller’s to manage.
- The approval record of a report holds the draft’s text, never the preview.
Redaction has a known limit
Section titled “Redaction has a known limit”Secrets, tokens and credential-shaped strings are redacted from error text and conversation text. Free-text personal data is not detected: a name, address or order note in a message or an error is not recognised. The control is the user’s consent and the exact preview, with each attachment switchable. Tell your users that a report can contain what they wrote and what the assistant and application said.
How long reports are kept
Section titled “How long reports are kept”- A report outlives its conversation. When the retention window deletes a conversation, the reports from it stay with the context their user agreed to share, and the admin sees Conversation no longer available. The window does not delete reports.
- Reports are deleted after their problem closes. 30 days after an administrator resolves or dismisses a
problem its reports are deleted (
DIOSC_PROBLEM_REPORTS_PURGE_DAYS, whole days, default 30, at most 3,650). The problem and its counts stay. Reports of a problem that stays open are kept for as long as it is open, so close problems you are done with. - Failed-call records are separate. The tool server error log has its own limit (above); a report holds its own redacted copy of the calls it attached.
- Webhook delivery logs hold status, code and time, never the payload, and are kept 30 days.
Erasure and export
Section titled “Erasure and export”- Erasing a user deletes that user’s reports for the assistant; erasing a session deletes that session’s
reports. In both cases the problem keeps its report count, the Problems page shows how many reports were
erased, and
report.erasedis sent to every sink that received the report, carrying only the report id and the reason (user_erasureorsession_erasure). The erase-user confirmation lists the user’s reports and open problems first, and the retention card counts reports on open problems that lose their conversation in the next run. - A sink’s copy is not erased by DioscHub. The event tells the receiver which report to remove. Erasing it there is your responsibility as controller.
- The purge and the retention window do not send
report.erased: neither is an erasure. - Export. The subject access export includes the person’s reports
as
problem-reports.json. - Anonymous visitors are not privacy subjects (their ids cannot be looked up). Their reports go with their session when it is erased, or with the purge above; a retention deletion of the conversation leaves the report as for anyone else.
- After a downgrade the Problems page and its API turn off; stored reports are still exported, erased and purged.
Wording for your privacy notice
Section titled “Wording for your privacy notice”Adapt this to your own notice:
When our assistant meets a technical problem, it may offer to send a report to our team, or you can start one yourself by typing
/problem. Nothing is sent unless you approve it. Before you do, you see exactly what the report would contain and can edit your description and switch off any attachment: an excerpt of your recent conversation with the assistant, the page you are on, and the technical details of the failed requests. Reports never include your login credentials. The report is stored with your user id so we can follow up, and is kept until the problem is closed and then for a further 30 days, unless you ask us to erase it earlier. [If you forward reports to a tracker: We pass reports on to [tracker name], where [retention] applies.] Please do not include information in your description that you do not want us to hold.
File content the model reads
Section titled “File content the model reads”The model reaches the content of a file only through the file tools: read_file, file_search and the
table tools (describe_workbook, load_table, query_table) for a user’s own files, read_kb_file and
kb_search for knowledge-base files (see How the assistant reads
files). Each runs under the same scope as the rest of
the platform: a user’s own library, or the knowledge bases linked to the Assistant and Role.
Framed as data, not instructions
Section titled “Framed as data, not instructions”A file can hold text written to look like instructions — a prompt injection. So every piece of file text those tools hand the model is wrapped in a frame that labels where it came from:
<file-data boundary="3f9c0a71d2e84b56" origin="read_file" file="handbook.pdf">…the file's text, exactly as stored…</file-data boundary="3f9c0a71d2e84b56">- Every file text is framed: each page of
read_fileandread_kb_file(both the text and the raw view, which addsview="raw"), the content of everyfile_searchandkb_searchhit (itsColumns:line included), an imageread_fileshows (view="image"), and the sheet and picture names of a workbook picture. The table tools frame every string that came from the file: sheet names, headers, cell values, chart titles and picture names indescribe_workbook(origin="describe_workbook"), the sheet, headers, profile values and samples inload_table(origin="load_table", withsheetandrangeattributes), and the rowsquery_tablereturns (origin="query_table"). Only the hub’s own words, counts, types, column identifiers and A1 references, and chart types and image formats from a fixed list, stay outside the frames. - The boundary can’t be forged. It is 16 random hex characters the hub draws for each tool result, never taken from the model’s input or from the file, and drawn again if the file’s text or name already holds it. Only the closing tag with the same boundary ends a frame, so text inside a file can’t close the frame early or open a convincing one of its own.
- The label is the hub’s.
originnames the tool, andfileis the name of the file the hub looked up, escaped, never a value from the tool’s input. - The model is told what a frame means. The system prompt says everything inside a frame is data to
read, never instructions: it doesn’t change the task, the user’s request, which tools to call or any
approval, and a frame without a closing tag runs to the end of that tool result. Labels such as
[Hidden text]or[Comment]describe content and carry no authority. - The tag is a structural marker. A
<file-datatag is one of the internal markers the output guardrail screens replies for, so the model echoing the frame is treated as a leak of internal structure. - File text can’t fake a tool failure. Text inside a frame, such as a line starting
REJECTED:, never makes a successful read count as a failed tool call.
The model’s list of attached files is not a frame, but every name and hint in it is escaped, so a file name
can’t close the list or add a file to it. kb_search and session_search errors reach the model as
fixed text; the underlying error is logged on the hub only.
Framing is the first defence against injection from files, not a guarantee: a model can still be swayed by what it reads. The controls that hold whatever the model reads stay in force: it never holds the user’s credentials (credential blindness), and any state-changing tool can require a person’s approval.
Not framed in this release: session_search hits, run_code output, the sheet name in a spreadsheet
search hit’s location, and the summary compaction writes of older turns, which can restate file text
read earlier.
Read file content stays in the conversation
Section titled “Read file content stays in the conversation”A page the assistant read is a tool result, and like every tool result it is kept in the conversation’s message history, so the session can be resumed. It stays there when the file changes or goes:
- Delete, expiry, re-index and redaction change the file, not the conversation. A new read sees the
change: a deleted or expired file is
not_found, an old cursor is refused, and the raw view reads the current stored object. But text already returned to the model stays in every conversation that read it. - Images too. An image
read_fileshowed, a workbook picture included, is kept in the conversation, as the scaled-down copy that was sent. A term redaction can’t remove content from an image. - Images stop being sent once their file is gone. Like the rest of the conversation, an image already
in it is sent to the model again with each later turn of that session, but only while its file can
still be read. Before every model call the file behind each earlier image is checked; once it is
deleted, redacted, expired or can’t be checked, the image is replaced with a short “no longer
available” note. For a chat message with several attached images, removing any one of them withholds
all of that message’s images. The image stays in the stored message history until the session, or its
user, is erased. New reads see the change too: a deleted file, and the pictures of a deleted or
redacted workbook, answer
not_found. - Knowledge-base files the same way. Deleting or redacting a knowledge-base file doesn’t reach the conversations that read it.
That content leaves when the conversation does: erasing the session, or the user it belongs to, removes it, and so does the retention window when the conversation expires. Redacting the session with the same terms replaces them in its text. Up to 4,000 characters of each tool result also show in the widget’s history and in the admin conversation transcript; see What users and administrators see.
Where the boundaries sit
Section titled “Where the boundaries sit”DioscHub is self-hosted and single-tenant: it runs inside your environment, and everything above stays there. The data it moves crosses two boundaries you own — the server-to-server bind from your backend, and the transport to your MCP servers — and both carry only what you handed it to carry.