Skip to content

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.

  1. The widget connects. The chat widget opens a connection and, until it is bound, has no identity.
  2. 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.
  3. 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.
  4. 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:

StoreWhat it holdsCarries user content or identifiers
Message historyThe conversation itself — the messages exchanged, and the tool calls and results, including file text the assistant read — so a session can be resumed and reviewedYes — message text and file content
Conversation analyticsAggregate signals about a conversation: topic, intent, counts, durationKeyed to the user; no message text
Session recordsThe identity snapshot for the session — user id, name, resolved Role, the pages visited, a first-message previewYes — identifiers and a preview
Chat filesFiles a user uploads inside a chat — private to that userYes — private user data
Knowledge-base filesShared reference documents an operator uploadsShared, not per-user
Approval recordsA record of each reviewed tool call — the tool, the operation, the decisionTool and decision; not the forwarded auth
Problem reportsWhat 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.

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 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.

ControlDefaultRange
Delete old conversations and user filesOff
Days after the last message (user files: last use)30 to 3650 days
Keep pinned conversationsOn
Delete pinned conversations after a limit, with Pinned limit in daysOff: pinned conversations are kept with no limit30 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_changed on 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).
  • 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.

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.

  • 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.

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:

LogIts own limit
Approval log365 days (APPROVAL_LOG_RETENTION_DAYS)
Tool server error log30 days (MCP_ERROR_LOG_RETENTION_DAYS)
Model error log30 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.

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_run entry 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).

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 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.

  • 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.

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.

  • 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.
  • 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.erased is sent to every sink that received the report, carrying only the report id and the reason (user_erasure or session_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.

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.

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.

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_file and read_kb_file (both the text and the raw view, which adds view="raw"), the content of every file_search and kb_search hit (its Columns: line included), an image read_file shows (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 in describe_workbook (origin="describe_workbook"), the sheet, headers, profile values and samples in load_table (origin="load_table", with sheet and range attributes), and the rows query_table returns (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. origin names the tool, and file is 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-data tag 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_file showed, 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.

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.


Next: The credential-blind guarantee.