# Quelvio: the whole site as Markdown

> Quelvio turns documents and agent sessions into facts, each tied to the sentence it came from, who it belongs to and when it was true. AI agents and people get answers that quote those facts, and a plain "not sure" when the sources don't settle the question.

Every public page of https://quelvio.com, in the order of https://quelvio.com/llms.txt. Each page starts with a comment naming its address and its Markdown copy.


<!-- Page: https://quelvio.com/ · Markdown: https://quelvio.com/index.md -->

# No confident lies.

Context for AI agents and the people who run them · Human page: https://quelvio.com/ · Machine view: https://quelvio.com/ai

Every answer quotes its source.

[Request early access](https://quelvio.com/early-access) · Connect your agent (MCP): `{"mcpServers":{"quelvio":{"url":"https://mcp.quelvio.com/http"}}}`

## Every answer shows its source.

Each answer is built from facts. Each fact keeps the sentence it came from, who said it, and when.

## Recall isn’t correctness.

Search and agent memory are built to find something relevant. They can’t tell which of three memos is current, who approved it, or that last week’s thread reversed it. A person fills that gap from experience. An agent can’t, so it acts on whatever it found first.

- **Relevant isn’t current.** Last year’s pricing policy still matches the question.
- **Newer isn’t approved.** A fresh Slack message isn’t a decision.
- **An answer isn’t always right.** When the sources disagree, the honest answer says so.

## Memory your agents can be held to.

At the start of a session, an agent asks Quelvio what it should know. At the end, Quelvio checks what’s worth keeping. Nothing is kept silently: stewards see, correct, share and erase what agents remember.

- **Session start**: the facts and earlier decisions that matter for the task, with sources.
- **Session end**: what the agent learned is checked before it is kept, never written in silently.
- **Stewards**: see what each agent remembers, share it between agents, correct, forget or erase it.
- **MCP server and hooks**: for Claude Code and other agents.

### The Truth API

- Connect repositories of facts to any agent.
- Cited answers, or a plain decline.
- “Am I allowed to do this?” checked before the agent acts.
- A trace for every answer, and usage per agent.

**Live pointers, never static exports.** Agents ask Quelvio at the moment they decide. They never carry a copy that goes stale.

[Quelvio for AI agents](https://quelvio.com/agents)

## Answers that quote, and know when to stop.

Ask a question and get an answer built from facts, each quoted with its source. When the sources disagree or say nothing, Quelvio says so instead of guessing.

- **Search and answers**: across your repositories.
- **Topics and entities**: everything known about a customer, a policy or a project, together.
- **Personal memory that’s yours**: your questions and preferences, seen only by you, yours to pause, export or erase.

## Stored in your own cloud.

On every plan, your content is stored only in your own storage. During setup, before you connect it, Quelvio keeps what it reads from your public website, your setup answers and corrections, and the first answer until you connect your storage, at most 14 days, then moves them there and deletes them here; backup copies are cleared within 7 more days. The application and sign-in run at enterprise.quelvio.com.

- **Your documents**: Your documents, and everything Quelvio draws from them, are stored only in your own cloud account, encrypted with your key. Apart from the setup hold described above, Quelvio keeps no copy, only metadata such as ids, statuses and counts.
- **Your tokens**: Connector tokens live only in your secret manager. Google and Microsoft connect through your own apps with no secret at all. You can cut Quelvio off at any time from your own console.
- **Processing**: Quelvio’s servers run the application and, by default, the processing. Content passes through them in memory while it is read and written to your storage, and is not kept there, apart from the setup hold described above.
- **Outside processors**: Content is processed by Typesafe (Jev) and, when models run through Quelvio, by Alibaba Cloud (Qwen). When models run in your own cloud, by the models you choose there.

[Read the trust center](https://quelvio.com/trust)

## Bring us the question your agents get wrong.

Early access is by invitation. Tell us what your agents need to know, and where they slip.

[Request early access](https://quelvio.com/early-access) · [Talk to us](mailto:q@quelvio.com)

## Connect your agent

- One-line install (Claude Code): `claude mcp add quelvio --transport http https://mcp.quelvio.com/http`
- MCP server: [https://mcp.quelvio.com/http](https://mcp.quelvio.com/http) (OAuth sign-in, no key to paste). [Install instructions](https://quelvio.com/docs/mcp#install)
- [llms.txt: every page, for agents](https://quelvio.com/llms.txt)
- [llms-full.txt: the whole site as Markdown](https://quelvio.com/llms-full.txt)

## Related

- [Human view of this page](https://quelvio.com/)
- [Everything for agents: llms.txt](https://quelvio.com/llms.txt)


<!-- Page: https://quelvio.com/agents · Markdown: https://quelvio.com/agents.md -->

# Agents that know what’s true, and say when they don’t.

For teams running AI agents · Human page: https://quelvio.com/agents · Machine view: https://quelvio.com/ai/agents

An agent can’t tell a current policy from last year’s draft. Quelvio gives it facts with their sources, a memory it can be held to, and a plain decline when the sources don’t settle the question.

[Request early access](https://quelvio.com/early-access) · [Read the MCP docs](https://quelvio.com/docs/mcp)

## Ask at the start. Check at the end.

Every session opens with what the agent should know, and closes with what is worth keeping. In between, the agent asks again whenever it needs more.

- **Session start**: the agent asks what it should know. Quelvio returns the facts and earlier decisions that matter for the task, each with its source sentence, owner and date.
- **During the session**: when the agent needs more, it asks again and gets the matching memories. Answers quote facts, or decline.
- **Session end**: Quelvio reads the session and checks what’s worth keeping. Nothing joins memory silently.

## Someone is accountable for what agents remember.

Every agent has stewards. They see what it remembers and where each memory came from, and they decide what happens to it.

- **Approve**: what an agent proposes to share, or to keep as a skill.
- **Share**: memory between agents.
- **Correct or forget**: a memory that is wrong or no longer needed.
- **Erase**: for good, when it must not be kept at all.

## Your memory is yours.

What Quelvio remembers about a person’s own use, their questions, preferences and follows, is seen by that person alone, and theirs to pause, export or erase. It is kept apart from agent memory.

## Where your agents already run.

- **MCP server and hooks**: for Claude Code and other agents.
- **The Quelvio MCP server**: connects any MCP client to Quelvio search. [MCP docs](https://quelvio.com/docs/mcp)
- **The CLI**: puts Quelvio behind one scriptable command for terminal agents and scripts. [CLI docs](https://quelvio.com/docs/cli)

## Facts your agents can act on.

Agents call Quelvio at the moment they decide, and get back what is true, where it came from, and whether they are allowed to act.

### The Truth API

- Connect repositories of facts to any agent.
- Get cited answers, or a typed decline.
- Ask “am I allowed to do this?” and have it checked against your rules before the agent acts.
- Every call leaves a trace. Usage is counted per agent.

**Live pointers, never static exports.** A Quelvio skill file carries the wiring: where to ask, and with what scope. It never carries a copy of your facts. A copy goes stale the moment it’s made, and it leaves your control when it travels.

## Three things Quelvio won’t do.

- **Ship your facts in a file.** Your agents ask Quelvio; they don’t carry a copy around.
- **Fill a gap with a guess.** When the sources don’t settle it, the answer says so.
- **Keep what an agent learned without a check.** Memory is checked, and seen by its stewards.

## Bring us the question your agents get wrong.

Early access is by invitation. Tell us what your agents need to know, and where they slip.

[Request early access](https://quelvio.com/early-access) · [Talk to us](mailto:q@quelvio.com)

## Related

- [Human view of this page](https://quelvio.com/agents)
- [Docs: Quelvio for AI agents](https://quelvio.com/docs/ai-agents.md)
- [Docs: MCP server](https://quelvio.com/docs/mcp.md)
- [Everything for agents: llms.txt](https://quelvio.com/llms.txt)


<!-- Page: https://quelvio.com/how-it-works · Markdown: https://quelvio.com/how-it-works.md -->

# From a sentence to a fact to an answer.

How it works · Human page: https://quelvio.com/how-it-works · Machine view: https://quelvio.com/ai/how-it-works

Search finds passages that look relevant. Quelvio writes down what your sources actually establish, and keeps track of who said it, and when.

[Request early access](https://quelvio.com/early-access) · [Quelvio for AI agents](https://quelvio.com/agents)

## Read, write, relate, answer, trace.

1. **Read**: Documents and agent sessions, one sentence at a time.
2. **Write facts**: Each fact keeps the sentence it came from, who it belongs to, and when it was stated and holds from.
3. **Relate**: Facts that agree or disagree are linked, and each keeps its history in time order. Facts are grouped by topic and entity.
4. **Answer**: Answers quote the facts they rest on, or decline when the sources don’t settle the question.
5. **Trace**: Every step is recorded. Open a reading or an answer and replay how it was built.

## Every fact keeps its source.

One sentence from an approved policy becomes one fact, with the four parts that make it checkable.

1. **The sentence**: quoted, with its document and line.
2. **Who it belongs to**: the person, team or party it comes from.
3. **When**: the date it was stated, and the date it holds from.
4. **How it relates**: the facts it agrees with, disagrees with, or came after.

## Every step can be replayed.

The trace of a decline: the question, the facts found, the sources checked, what the sources cover, and the decision.

## Watch it happen.

The Lab is where you see Quelvio work on your own repositories.

- **Repositories**: what each one holds, and who can read it.
- **A reading you can watch**: documents becoming facts, sentence by sentence.
- **The graph**: facts connecting as they agree, disagree or follow one another.
- **The trace viewer**: press play on any reading or answer.
- **Memory**: what each agent remembers, and its stewards’ decisions.
- **Topics and entities**: everything known about one thing, in one place.

## Retrieval finds text. Quelvio keeps facts.

- Retrieval: Returns passages that look relevant. **Quelvio: Returns facts, each with its source sentence.**
- Retrieval: The newest or most similar text wins. **Quelvio: Who said it, and when, is kept with each fact.**
- Retrieval: Always produces an answer. **Quelvio: Declines when the sources don’t settle it.**
- Retrieval: Hard to audit afterwards. **Quelvio: Every step can be replayed.**

## Bring us the question your agents get wrong.

Early access is by invitation. Tell us what your agents need to know, and where they slip.

[Request early access](https://quelvio.com/early-access) · [Talk to us](mailto:q@quelvio.com)

## Related

- [Human view of this page](https://quelvio.com/how-it-works)
- [Everything for agents: llms.txt](https://quelvio.com/llms.txt)


<!-- Page: https://quelvio.com/enterprise · Markdown: https://quelvio.com/enterprise.md -->

# Knowledge you can check.

For people who need to trust what they read · Human page: https://quelvio.com/enterprise · Machine view: https://quelvio.com/ai/enterprise

Every answer quotes the facts it rests on: the sentence, who it came from, and when. When the sources disagree, you see both. When they say nothing, Quelvio says so.

[Request early access](https://quelvio.com/early-access) · [See how it works](https://quelvio.com/how-it-works)

## Answers that quote, and know when to stop.

Each line of an answer points to a fact, and each fact points to the sentence it came from. Open any one and read it in its document.

- **Answers that quote**: every line of an answer is a fact you can open, with its source sentence, owner and date.
- **“Not sure” is a real answer**: when the sources don’t settle the question, Quelvio declines and says so.
- **Both sides, when sources disagree**: you see each source and how it stands, instead of an average of the two.

## Nothing is overwritten silently.

A fact’s history stays with it, in time order: what was said earlier, by whom, and when.

## Everything known about one thing, in one place.

- **Topics**: pricing, a product, a process: every fact on it, with its sources and history.
- **Entities**: a customer, a team, a policy: everything the sources say about it.
- **Follow**: the topics and entities you care about surface first in your own search.

## You decide who sees what.

- **Repositories you control**: you decide what each repository holds and who can read it. Access is checked on every fact, for people and agents alike.
- **Your memory is yours**: what Quelvio remembers about your own use, your questions, preferences and follows, is seen by you alone, and yours to pause, export or erase.

## Questions and answers.

- **What does Quelvio do with a document?** It reads the document sentence by sentence and writes down what it establishes as facts. Each fact keeps the sentence it came from, who it belongs to, and when it was stated and holds from. Facts that agree or disagree are linked, and facts are grouped by topic and entity.
- **What happens when two sources disagree?** Both stay visible, with how each one stands: who said it, when, and whether it is a decision. An answer shows the disagreement instead of picking a side silently, and declines when the sources don’t settle the question.
- **Does Quelvio ever guess?** No. When no source settles a question, the answer says “not sure” instead of producing something plausible.
- **Can I see how an answer was built?** Yes. Every step is recorded, from the source sentence to the fact to the answer. Open the trace and replay it, including the reason for a decline.
- **Who can see what?** You decide what each repository holds and who can read it. Access is checked on every fact, for people and agents alike.
- **Where is my data stored?** The trust center sets out where documents, tokens and processing live. [Read the trust center](https://quelvio.com/trust)
- **How is Quelvio priced?** Plans and prices are on the pricing page. [See pricing](https://quelvio.com/pricing)

## Bring us the question your people can’t answer.

Early access is by invitation. Tell us what your teams need to rely on, and where today’s answers fall short.

[Request early access](https://quelvio.com/early-access) · [Talk to us](mailto:q@quelvio.com)

## Related

- [Human view of this page](https://quelvio.com/enterprise)
- [Trust: where your data is stored](https://quelvio.com/trust.md)
- [Everything for agents: llms.txt](https://quelvio.com/llms.txt)


<!-- Page: https://quelvio.com/pricing · Markdown: https://quelvio.com/pricing.md -->

# Unlimited people and agents.

Human page: https://quelvio.com/pricing · Machine view: https://quelvio.com/ai/pricing

Plans differ in the pages Quelvio reads and the runs your agents make each month.

## Plans

|  | Team | Business | Enterprise |
| --- | --- | --- | --- |
| Base price, annual billing, per month | $490 | $1,900 | Custom |
| Base price, monthly billing, per month | $590 | $2,290 | Custom |
| Models run by Quelvio (base +5%), annual billing, per month | $515 | $1,995 | Custom |
| Models run by Quelvio (base +5%), monthly billing, per month | $620 | $2,405 | Custom |
| Models in your own cloud | Not offered | Not offered | Talk to us |
| People and agents | Unlimited | Unlimited | Unlimited |
| Pages read per month (new or changed text) | 5,000 | 25,000 | Sized |
| First import, annual billing | 100,000 pages | 500,000 pages | Sized |
| First import, monthly billing | 10,000 pages | 50,000 pages | — |
| Agent runs per month | 20,000 | 150,000 | Sized |

More pages or runs come from prepaid packs, never billed after use.

Prices in US dollars, excluding taxes.

### Team

[Get started](https://quelvio.com/early-access)

### Business

Everything in Team, plus:

- Rules
- SSO and SAML
- A one-year audit log
- Personal spaces

[Get started](https://quelvio.com/early-access)

### Enterprise

Everything in Business, plus:

- Deployment in your own cloud
- Models in your own cloud (Amazon Bedrock, Azure AI Foundry, Google Vertex AI): talk to us
- The managed service
- An SLA
- An optional fee linked to adoption

Contact sales (opens a contact form on the page)

## Prepaid packs

Used after the month's allowance, valid for 12 months from purchase, and never billed after use. The bigger the pack, the less each page or run costs.

### Page packs

| Pages | Price | Per page |
| --- | --- | --- |
| 5,000 | $250 | $0.050 |
| 25,000 | $1,125 (−10%) | $0.045 |
| 100,000 | $4,000 (−20%) | $0.040 |
| 500,000 | $17,500 (−30%) | $0.035 |

### Run packs

| Agent runs | Price | Per run |
| --- | --- | --- |
| 10,000 | $400 | $0.040 |
| 50,000 | $1,800 (−10%) | $0.036 |
| 250,000 | $8,000 (−20%) | $0.032 |
| 1,000,000 | $28,000 (−30%) | $0.028 |

- **At the limit:** When the allowance and every pack are used up, new reading waits, with nothing lost, and resumes when a pack is bought or the month renews. Agents get a plain "plan limit reached" reply.
- **Alerts:** At 80% and at 100% of what's available.
- **Auto top-up:** Off by default; an owner turns it on. At 90% it buys the smallest pack in advance, so it's still prepaid.

## How pages count

A page is 500 words of text read after cleanup, from any source. Only new or changed text counts, and unchanged content read again is free.

| Source | What counts | About |
| --- | --- | --- |
| Email | Each email's own new text. Quoted replies, signatures and legal footers are removed, attachments count as documents, and automated mail (no-reply senders, newsletters, notifications) is left out by default. | 3–5 emails make a page |
| Slack and Teams | Each message's words, and a thread reply once. Bot posts, join or leave notices and emoji-only reactions don't count, and an edit counts only its changed words. | About 25 messages make a page |
| Meetings | Transcript words, at about 150 words a minute. | An hour is about 18 pages |
| Documents | The text, including text recognised from scans. | 500 words make a page |
| Agent sessions | The session's words. | 500 words make a page |

Your company picks which channels, mailboxes and folders are read. The usage page shows pages per source. The first import is each source's first complete read, and uploads during the 14-day trial count toward it.

## What an agent run is

One call from an agent or a scheduled report, such as a Truth API or MCP call, that returns an answer, a memory, a rule check or source passages. Retries and errors don't count, and a brief sent to many recipients counts once. Listing sources and checking a citation are free, and people's questions are never metered.

## Where models run

Two routes, each with its own cost.

### Models run by Quelvio (Standard, on every plan)

The base price, plus 5%.

- Quelvio runs the language models (Qwen, in the EU or the US) that write readable sentences and word the answers.
- Team and Business always run this way.

### Models in your own cloud (Enterprise)

In your own Amazon Bedrock, Microsoft Azure AI Foundry or Google Cloud Vertex AI account.

- Part of an Enterprise plan: talk to us.
- You pay the model usage on your own cloud bill: an extra cost, billed by that provider.

Classification (Typesafe's Jev) and the search index always run through Quelvio, on both routes and inside the plan, so the page and run allowances stay the same.

## No free plan. Try it first.

- **A 14-day trial:** It starts with onboarding.
- **A free developer sandbox:** 1 agent, 1,000 agent runs and 100 documents.

[Request early access](https://quelvio.com/early-access) · Contact sales (opens a contact form on the page)

## Related

- [Human view of this page](https://quelvio.com/pricing)
- [Trust: where your data is stored](https://quelvio.com/trust.md)
- [Everything for agents: llms.txt](https://quelvio.com/llms.txt)


<!-- Page: https://quelvio.com/trust · Markdown: https://quelvio.com/trust.md -->

# Trust.

Trust · Human page: https://quelvio.com/trust · Machine view: https://quelvio.com/ai/trust

How Quelvio protects your knowledge.

Your knowledge is among the most sensitive corpus your company holds — every memo, every decision, every internal discussion. Quelvio is built so your data stays separated and yours, people see only what they're already allowed to see, everything is encrypted and audited, and you stay in control of access and removal. This page documents the protections in place today.

## Stored in your own cloud.

**Quelvio platform · storage in your own cloud**

Where your data is stored

On every plan, your content is stored only in your own storage. During setup, before you connect it, Quelvio keeps what it reads from your public website, your setup answers and corrections, and the first answer until you connect your storage, at most 14 days, then moves them there and deletes them here; backup copies are cleared within 7 more days. The application and sign-in run at enterprise.quelvio.com.

### Your documents

Your documents, and everything Quelvio draws from them, are stored only in your own cloud account, encrypted with your key. Apart from the setup hold described above, Quelvio keeps no copy, only metadata such as ids, statuses and counts.

### Connector tokens

Connector tokens live only in your secret manager. Google and Microsoft connect through your own apps with no secret at all. You can cut Quelvio off at any time from your own console.

### Processing

Quelvio’s servers run the application and, by default, the processing. Content passes through them in memory while it is read and written to your storage, and is not kept there, apart from the setup hold described above.

### Outside processors

Content is processed by Typesafe (Jev) and, when models run through Quelvio, by Alibaba Cloud (Qwen). When models run in your own cloud, by the models you choose there.

## 01 · Controls at a glance.

**Hosted platform · enterprise.quelvio.com today**

The controls and details below describe the hosted platform at enterprise.quelvio.com as it runs today, where Quelvio stores your content in its own infrastructure.

Its search sends document text and queries to Voyage AI for embeddings and ranking. The privacy policy lists the hosted platform’s sub-processors. [See the sub-processors](https://quelvio.com/privacy#6-subprocessors)

Eight headline controls that operate across every Quelvio tenant. Each links to the architectural detail below.

1. [Tenant isolation](https://quelvio.com/trust#isolation): Your knowledge is fully separated from every other customer's, at every layer — database row-level security on your data, per-customer retrieval, partitioned storage — and continuously verified.
2. [Authentication](https://quelvio.com/trust#auth): OAuth 2.1 for humans, Personal Access Tokens for headless, Service Accounts for CI — all hashed, never logged.
3. [Per-tenant policies](https://quelvio.com/trust#policies): Admin-configured session age, idle limits, IP allowlists, PAT and Service Account caps — fail-closed on violation.
4. [Atomic offboarding](https://quelvio.com/trust#offboarding): HRIS-driven revocation of every session and credential in a single transaction. Idempotent, rolled back on failure.
5. [Tamper-proof audit](https://quelvio.com/trust#audit): Every sign-in, change, and query captured in a hash-chained, exportable audit trail admins can review — and it can't be quietly altered.
6. [Encryption](https://quelvio.com/trust#encryption): TLS 1.2+ in transit. How content is encrypted at rest, and where its keys are kept, is set when Quelvio's service is hosted; it will be named here.
7. [Data residency](https://quelvio.com/trust#residency): Your content is stored only in your own storage, in the region you choose for it. Some processing happens in the United States, as the privacy policy's Section 6 lists.
8. [Data deletion & erasure](https://quelvio.com/trust#rtbf): Key-destruction erasure across all backup copies — when you erase, we destroy the key and every copy becomes permanently unreadable. Anyone can pause or erase what's remembered about them, anytime.

## 02 · Architecture in detail.

### 02·1 · Tenant isolation

Your knowledge is fully separated from every other customer's, at every layer. Each tenant has its own dedicated retrieval space, and your data carries database row-level security tied to your tenant identity — content is reachable only within your own tenant, by construction, not by a filter that could be left off.

Source-side access controls travel with your content: the permissions from Google Drive, Confluence, Slack, and every other connected tool are honored on every result, at the same layer as tenant identity.

That separation is continuously verified — the boundary between tenants is checked on an ongoing basis so it holds, always.

### 02·2 · Authentication and access

Sign in with your own identity provider over single sign-on (SAML or OIDC). People authenticate through the directory you already run, and sensitive administrative actions require step-up multi-factor protection. Administrative access uses per-operator identity — there is no shared admin key.

Every credential is stored only in hashed form, never in readable text. The plaintext is shown exactly once at issuance and is never written to logs or audit records. Programmatic access uses scoped tokens, each rate-limited and budget-capped.

People see only what they're already allowed to see, so two employees with different roles in the same company get results filtered to exactly the documents they have standing access to at the source.

### 02·3 · Tenant-configurable security policies

Administrators set access policies for their own company: maximum active and idle session age, IP allowlists, and caps on how many credentials each person and team can hold. Policies belong to your company alone — there is no cross-tenant inheritance or default fall-through.

Enforcement is fail-closed. An expired session, a request from outside the IP allowlist, or a credential request beyond the configured caps is denied — and every denial is paired with an audit entry the admin can inspect.

### 02·4 · Atomic offboarding

When a person leaves, offboarding is instant and complete: every session, token, and service account they hold is removed in one step. It's all-or-nothing — if anything can't complete, the whole operation rolls back so the admin can retry cleanly, never leaving access half-removed.

Offboarding can be triggered automatically from your HR system over a signed connection, or manually by an admin in the dashboard. Every removal is recorded in the audit trail, so the full record of who was offboarded and when is visible to admins and procurement reviewers.

### 02·5 · Tamper-proof audit

Every sign-in, configuration change, credential issued or revoked, query, and offboarding action is recorded in a complete audit trail. The trail is hash-chained, so any change to a past record is detectable — the record can't be quietly altered after the fact.

Each answer is traceable to the sources that informed it, so when a removal request lands, the team can confirm exactly what surfaced that content and where it was cited.

Admins review the audit trail directly from the dashboard and export it for procurement and compliance teams. Retention is configurable, with long-term retention for Enterprise, and the trail can stream to your own security tooling.

### 02·6 · Encryption

Encryption at rest. How each customer's content is encrypted at rest, and where its keys are kept, is set when Quelvio's service is hosted; it will be named here. Data in transit is protected with TLS 1.2+.

Bring your own key (Enterprise). How you bring your own key is set when Quelvio's service is hosted; it will be named here.

### 02·7 · Data residency

Your content, and the index built from it, are stored only in your own storage, in the region you choose for it.

Some processing happens in the United States: the privacy policy's Section 6 lists each provider and where it processes.

### 02·8 · Data deletion & erasure

Deletion that survives backups. How erasure reaches every copy of your content, backups included, is set when Quelvio's service is hosted; it will be named here.

What erasure keeps. Erasure destroys your content and its keys. We retain the minimal billing and audit records the law requires us to keep (invoicing, tax, and the security audit trail) — these contain no document content. This balances your right to erasure (GDPR Article 17) with our legal retention obligations.

Source-driven deletion. When a document is removed in Google Drive, Confluence, or another connected source, it disappears from results immediately, with a full permanent purge shortly after.

### 02·9 · Backups & resilience

How your data is backed up, and where the backups are kept, is set when Quelvio's service is hosted; it will be named here.

## 03 · Compliance posture.

Quelvio's security controls are aligned to leading frameworks — SOC 2 and ISO 27001 — and operate across every tenant today.

Detailed security documentation is available to enterprise customers under NDA, alongside a Vendor Security Questionnaire and customer information packet for procurement review.

**Also covered**

- **GDPR**: GDPR-compliant. Data Processing Agreement (DPA) available to customers on request.
- **HIPAA**: Business Associate Agreement (BAA) available on request for in-scope deployments.
- **ISO 27001**: Security controls aligned to the ISO 27001 framework.

## 04 · Reporting a security concern.

Email security@quelvio.com to report a vulnerability or suspected incident. We acknowledge reports within one business day and provide a triage assessment within five business days. For high-severity reports, on-call engineering responds the same day.

Researchers acting in good faith under the disclosure policy will not be pursued under the Computer Misuse Act or equivalent statutes. We ask for a private disclosure window before publication.

Email [security@quelvio.com](mailto:security@quelvio.com)

## 05 · Additional resources.

- [Privacy Policy](https://quelvio.com/privacy): Data we collect, how we use it, retention, your rights.
- [Terms of Service](https://quelvio.com/terms): The agreement that governs your use of Quelvio.
- [Data Processing Agreement (DPA)](mailto:security@quelvio.com?subject=DPA%20request): Article 28 DPA available on request to enterprise customers. (On request)
- [Sub-processors](https://quelvio.com/privacy#6-subprocessors): Current list of infrastructure, AI, and operations sub-processors.
- [Vendor Security Questionnaire](mailto:security@quelvio.com?subject=Security%20questionnaire%20request): Customer information packet (CAIQ-style) for procurement review. (On request)
- [Security documentation](mailto:security@quelvio.com?subject=Security%20documentation%20request): Detailed security documentation available under NDA. (On request)

## Procurement review? Talk to us.

Vendor security questionnaires, DPAs, and the customer information packet are available to enterprise prospects under NDA.

[Email security@quelvio.com](mailto:security@quelvio.com?subject=Security%20review) · [Start a trial](https://quelvio.com/early-access)

## Related

- [Human view of this page](https://quelvio.com/trust)
- [Everything for agents: llms.txt](https://quelvio.com/llms.txt)


<!-- Page: https://quelvio.com/early-access · Markdown: https://quelvio.com/early-access.md -->

# Bring us the question your agents get wrong.

Early access · Human page: https://quelvio.com/early-access · Machine view: https://quelvio.com/ai/early-access

Early access is by invitation. Tell us what your agents or your people need to rely on, and where today’s answers fall short.

## Form fields

- **Full name** (required)
- **Work email** (required)
- **Company** (required)
- **Company size (optional)**, one of: 1–50 · 51–200 · 201–1,000 · 1,000+
- **Which describes you?** (optional), one of: We run AI agents · We need trustworthy knowledge · Both
- **What should your agents, or your people, be able to rely on?** (optional)

The form is submitted on the page itself: [Request early access](https://quelvio.com/early-access)

## Related

- [Human view of this page](https://quelvio.com/early-access)
- [Everything for agents: llms.txt](https://quelvio.com/llms.txt)


<!-- Page: https://quelvio.com/contact-sales · Markdown: https://quelvio.com/contact-sales.md -->

# Let’s see if Quelvio is right for your team.

Human page: https://quelvio.com/contact-sales · Machine view: https://quelvio.com/ai/contact-sales

Tell us about your team and what you’re trying to solve.

## Form fields

- **Full name** (required)
- **Work email** (required)
- **Company name** (required)
- **Company size** (optional), one of: 1–50 · 51–200 · 201–1,000 · 1,000+
- **Which sources will you connect? (optional)**, any of: Google Workspace · Microsoft 365 · Slack · Notion · Confluence · Salesforce · GitHub · Other
- **What brings you to Quelvio? (optional)**

We respond within one business day. Your information stays with Quelvio — no third-party tracking.

The form is submitted on the page itself: [Contact sales](https://quelvio.com/contact-sales)

## Related

- [Human view of this page](https://quelvio.com/contact-sales)
- [Everything for agents: llms.txt](https://quelvio.com/llms.txt)


<!-- Page: https://quelvio.com/about · Markdown: https://quelvio.com/about.md -->

# Why we built Quelvio

ON CREATING THE ORGANIZATIONAL BRAIN · Human page: https://quelvio.com/about · Machine view: https://quelvio.com/ai/about

The next wave of work will be defined by what AI agents and humans can do together inside organizations. Agents will write code, draft contracts, run analyses, answer customer questions, and make recommendations at speeds and volumes that no human can manually supervise. Their value depends entirely on the context they have access to — what's current, what's authoritative, what your organization actually decided last quarter versus what someone wrote in a draft two years ago. Without that context, even the most capable agent is confidently wrong. With it, agents become as informed as your senior people.

But the reverse matters just as much. As agents act faster and more autonomously, humans lose visibility into what their organizations are doing — unless they can query the same knowledge their agents are working from. The brain has to be a shared substrate. One memory, two audiences. Agents drawing context to act; humans drawing context to stay synced with what's been done. The companies that get this right will compound an advantage. The ones that don't will be running two disconnected operating systems inside the same company.

This is the case for what we're building, why we think the architecture has to be a brain rather than a search index, and the window we're operating in.

## The case

1. Every organization is a knowledge system. What it knows, what it has forgotten, what it never quite figured out — these compound into how it operates, decides, and grows. The boundary between a company that scales and one that stalls usually runs through how well its knowledge survives time. AI agents make this boundary visible in ways it never was before: when an agent answers a customer with stale information, the dysfunction is no longer hidden in a Slack thread no one read. The cost of fragmented knowledge used to be paid quietly. It will be paid loudly from now on.
2. The knowledge of a 500-person company lives in fragments — across documents, threads, decks, recordings, code comments, and the heads of people who left two years ago. Storage and collaboration tools were built to hold these fragments. They were never built to reason over them. As long as the only consumer of this content was a human who knew which fragments to ignore, this worked. It does not work when agents are also consuming the same content at scale — and it does not work when humans need to keep pace with what those agents are doing.
3. An agent does not know that the runbook from 2024 was quietly replaced by a Slack decision in 2026. It cannot tell that a wiki page reflects the views of one team while a contradictory page reflects the views of another. It cannot weigh the CTO's architectural decision over a junior engineer's offhand comment unless the system tells it which is which. Without these signals, every retrieval is a coin flip dressed up as an answer. And without a shared brain, the human reviewing that agent's output has no way to know whether the coin landed right.
4. The number of agents inside organizations is going to grow by orders of magnitude. They will outnumber human employees inside a decade — first in customer support, then in operations, then in engineering, then in domains we have not imagined yet. Every one of them will need context. And every human working alongside them will need to draw context from the same place — to verify, to audit, to course-correct, to learn from what the agents have already figured out. The brain has to serve both sides of that relationship simultaneously.
5. This is the problem Quelvio exists to solve. Not search. Not another wrapper around an LLM. A continuously updated model of what an organization knows — with authority scored per contributor and per domain, with lifecycle awareness that distinguishes permanent from temporary from forgettable content, with explicit handling of contradiction and supersession across time. One brain, accessed by every person and every agent in your organization.
6. Authority is domain-conditional. The CEO has authority on strategy; the CTO has authority on architecture; the senior engineer who shipped the payment system has authority on payment edge cases. Treating every contribution as equally valid is the failure mode of every system that does not model this. Quelvio scores authority per contributor per domain, ranked by signal across documents, code, decisions, and threads — not by job title. The result is a system where the right voice wins on the right topic, automatically.
7. Knowledge has a lifecycle. Some content is permanent — canonical policies, foundational principles, code in production. Some is temporary — sprint plans, drafts, status updates. Some must be forgotten — deprecated workflows, right-to-be-forgotten requests, retention-policy expirations. A retrieval system that treats all content identically is structurally wrong. Quelvio classifies content by lifecycle and ranks accordingly. Stale content gets demoted. Current thinking surfaces. Forgotten content stays forgotten.
8. Contradiction is information. When two sources disagree, the right answer is not to average them or pick silently. It is to surface the disagreement, name what supersedes what, and let the reader see how the organization's thinking evolved. This is what an expert colleague does. A system that hides disagreement is a system that lies politely.
9. Refusal is a feature. When the corpus does not contain the answer, the system should say so — not invent one. Confidence calibrated to evidence is the difference between a knowledge system and a hallucination machine. An agent that refuses on weak context can be trusted with the queries it does answer. An agent that always answers cannot be trusted with anything.
10. This is not a faster version of what exists. It is a different category — knowledge infrastructure that compounds as a moat over time, priced so adoption reduces per-employee cost instead of multiplying it. Built for the organization where humans and AI agents work on the same problems, drawing from the same memory, in real time.
11. The shift in how organizations function is already happening — humans and agents working side by side, both needing the same context, both needing to trust the same answers. Someone has to build the brain that makes this possible. We are doing it.

— Quelvio

## Get started

[Request early access](https://quelvio.com/early-access)

## Related

- [Human view of this page](https://quelvio.com/about)
- [Everything for agents: llms.txt](https://quelvio.com/llms.txt)


<!-- Page: https://quelvio.com/blog · Markdown: https://quelvio.com/blog.md -->

# Engineering, retrieval, and the company we're building.

Human page: https://quelvio.com/blog · Machine view: https://quelvio.com/ai/blog

Field notes from the team building Quelvio.

## Categories

- Engineering — 2 posts
- Product — 2 posts
- Industry — 1 post
- Company — 1 post
- Research — 1 post

## Posts

Sorted newest first. Each entry links to its full machine-readable page; the canonical human view sits at the same path under /blog/\<slug>.

1. **Quelvio CLI: company knowledge in your terminal**  
   Company · May 22, 2026 · 6 min read  
   Completions, smart hints, progress indicators, update-check, and $EDITOR multiline. Why a CLI when Quelvio already speaks MCP — and what authority-scored, lifecycle-aware retrieval looks like at a shell prompt.  
   [Machine view](https://quelvio.com/ai/blog/quelvio-cli-launch) · [Human view](https://quelvio.com/blog/quelvio-cli-launch)
2. **How Quelvio ranks authority across your company's knowledge**  
   Engineering · May 18, 2026 · 8 min read  
   A look at the freshness × authorship × cross-reference graph that decides which Slack message wins over a year-old PDF — and why our retrieval pipeline routes by expertise, not by keywords.  
   [Machine view](https://quelvio.com/ai/blog/how-quelvio-ranks-authority) · [Human view](https://quelvio.com/blog/how-quelvio-ranks-authority)
3. **From scattered Drive to a single brain in 48 hours**  
   Product · May 12, 2026 · 6 min read  
   What the connector setup actually does in the background — and why most companies are surprised by the coverage map.  
   [Machine view](https://quelvio.com/ai/blog/scattered-drive-to-single-brain) · [Human view](https://quelvio.com/blog/scattered-drive-to-single-brain)
4. **Why MCP isn't enough on its own**  
   Industry · May 6, 2026 · 5 min read  
   Model Context Protocol gives agents a way to retrieve. It doesn't give them a context layer. We explain the gap.  
   [Machine view](https://quelvio.com/ai/blog/why-mcp-isnt-enough) · [Human view](https://quelvio.com/blog/why-mcp-isnt-enough)
5. **Cross-reference graphs and the supersession problem**  
   Engineering · April 28, 2026 · 7 min read  
   How we detect when a Notion page silently replaces a Confluence one — and which signal wins.  
   [Machine view](https://quelvio.com/ai/blog/cross-reference-graphs-supersession) · [Human view](https://quelvio.com/blog/cross-reference-graphs-supersession)
6. **Authority decay: how knowledge ages inside a company**  
   Research · April 21, 2026 · 9 min read  
   Patterns we see across the customer corpora Quelvio indexes — how engineering knowledge loses authority over 18 months, and what restores it.  
   [Machine view](https://quelvio.com/ai/blog/authority-decay) · [Human view](https://quelvio.com/blog/authority-decay)
7. **Permission-aware retrieval, explained**  
   Product · April 7, 2026 · 6 min read  
   Every employee only sees results from documents they already had access to. Here's the mechanics behind enforcing it at the vector level.  
   [Machine view](https://quelvio.com/ai/blog/permission-aware-retrieval) · [Human view](https://quelvio.com/blog/permission-aware-retrieval)

## Related

- [Human view of this page](https://quelvio.com/blog)
- [Quelvio for AI agents (machine view)](https://quelvio.com/ai/docs/ai-agents)
- [Everything for agents: llms.txt](https://quelvio.com/llms.txt)


<!-- Page: https://quelvio.com/docs/mcp · Markdown: https://quelvio.com/docs/mcp.md -->

# Your company's brain, exposed as a tool any AI agent can call.

Docs · MCP · Human page: https://quelvio.com/docs/mcp · Machine view: https://quelvio.com/ai/docs/mcp

The Quelvio MCP server lets Claude Desktop, Cursor, Claude Connectors, and any other Model Context Protocol client query your tenant's connected knowledge with synthesized, cited answers — under your employees' real identities, not a shared service account. Same retrieval and synthesis pipeline as the dashboard, exposed over standardized JSON-RPC.

[Install for Claude Desktop](https://quelvio.com/docs/mcp#install) · [View on GitHub](https://github.com/Quelvio/quelvio-mcp-server)

MCP server: `https://mcp.quelvio.com/http`

## Install

Three install paths — same server, different clients.

### Claude Desktop · Claude Connectors

Open Settings → Integrations → Add server. Paste the server URL below. Claude walks you through OAuth sign-in with your Quelvio workspace credentials. The integration auto-binds to your employee identity — the same one used for the dashboard.

```
https://mcp.quelvio.com/http
```

### Cursor

Paste into ~/.cursor/mcp.json (or via Cursor settings UI). Cursor's first call triggers the OAuth flow in a browser tab.

```json
{
  "mcpServers": {
    "quelvio": {
      "url": "https://mcp.quelvio.com/http"
    }
  }
}
```

### Any other MCP client

- Server URL: https://mcp.quelvio.com/http
- Authentication: OAuth 2.1 with PKCE; DCR-supported
- Registry entry: com.quelvio/mcp-server on registry.modelcontextprotocol.io

## Tools

Three tools. The first is the workhorse; the other two are zero-cost helpers.

### query_knowledge (Billable)

Search every connected source (Drive, SharePoint, Confluence, Slack, Notion, …) with a synthesized, cited answer.

| Parameter | Type | Default | Notes |
| --- | --- | --- | --- |
| query | string | required | Natural-language, 1–2000 chars |
| mode | enum | standard | fast · standard · deep (see Modes) |
| max_sources | int | 5 | 1–20; the 25K output-token cap may force fewer |
| domain | string | — | Optional taxonomy filter (e.g. engineering.platform) |

Returns: a synthesized answer with [n] citations, the ranked source chunks, and a structured metadata block (query_id, coverage level, retrieval mode, synthesis model, result count, sources kept, truncated flag, kT consumed, latency, risk flags).

Example query: What's our deployment process for the payments service?

```
We deploy the payments service via ECS rolling updates [1]. Releases
are cut by tagging the main branch — the backend-deploy workflow
applies migrations to RDS, registers a new task def, and rolls the
service [2]. Pre-deploy checklist lives at [3].

Sources:
  [1] runbooks/payments-service-deploy.md (Confluence) — Senior Platform Eng, 2 days ago
  [2] .github/workflows/backend-deploy.yml (GitHub) — Platform Team, 5 days ago
  [3] checklists/pre-deploy.md (Confluence) — Senior Platform Eng, 2 weeks ago

{
  "query_id": "<query-id>",
  "coverage": "expert",
  "retrieval_mode": "hybrid",
  "tokens_consumed": 12500,
  "latency_ms": 1180
}
```

### list_domains (Free · not an agent run)

Discover what's indexed.

Returns every taxonomy domain in your tenant with document count, expert count, coverage level (expert · partial · none), and top contributor by authority. Use it before issuing a billable query to confirm the brain has relevant knowledge.

### get_source_detail (Free · not an agent run)

Verify a citation.

Pass a query_id from an earlier query_knowledge response. Returns per-chunk provenance: document path, lifecycle state (live · stale · superseded · user_deleted), embedding timestamp + model, contributor + department, authority score, taxonomy domain. Scoped to your own queries by default — only Owner/Admin can inspect other members' queries.

## Modes

Each query_knowledge call counts as one agent run on your plan, whatever the mode.

| Mode | Cost | Synthesis | When |
| --- | --- | --- | --- |
| fast | 1 agent run | none — chunks only | Keyword-style retrieval. Names, IDs, 'find me the file that mentions X'. |
| standard (default) | 1 agent run | yes — built-in | Most questions. Returns the synthesized answer + cited sources. |
| deep | 1 agent run | yes — premium model + wider retrieval | Complex analytical questions; comparison across multiple sources; 'what's our position on…?' |

> Synthesis is bundled into standard and deep. fast is the only tier that returns chunks without a synthesized answer.

Agent runs come from your plan's monthly allowance, then from prepaid run packs. See /pricing. People's questions are never metered.

## Authentication & identity

Every query is scoped to your individual employee identity, not just your tenant. The MCP server records the per-employee identity on each call so cross-employee provenance inspection is automatic — Owner/Admin can audit, members can't snoop on each other.

OAuth 2.1 with PKCE is required (the MCP spec mandates it). The Quelvio MCP server also supports Dynamic Client Registration (RFC 7591), so MCP-aware clients like Claude Desktop register themselves on first connect — no operator pre-provisioning.

Sign-in uses your workspace's identity provider — the same one used for the dashboard at enterprise.quelvio.com. When configured, this federates to your SAML, Google Workspace, or Microsoft Entra provider. Access tokens are stored encrypted (AES-GCM) in Cloudflare KV on the MCP server — never on the client's filesystem. Token rotation and revocation happen server-side via the /oauth/revoke endpoint; admins can revoke active tokens from the dashboard.

## Permission model

Three layers, all enforced server-side:

1. **Tenant isolation.** Content is stored in per-tenant collections; cross-tenant content is structurally unreachable, not just policy-gated.
2. **Role-based feature access.** Owner / Admin / Member determines which calls succeed. get_source_detail is scoped to your own queries by default — only Owner/Admin can inspect another member's queries.
3. **Source permission filtering.** permission_emails on every chunk, resolved at ingest time from each source's ACLs (Drive shares, SharePoint groups, Confluence space restrictions). MCP queries see only what your individual account would see in the source system. There is no flag, env var, or dashboard toggle that disables this filter.

## Response caps & truncation

Per Claude Connectors policy, every tool response is capped at 25,000 output tokens. The MCP server enforces this deterministically:

1. Clamp excerpts to 200 chars
2. Drop lowest-rank sources (preserving ≥3)
3. Truncate the synthesis body

Truncation is signaled via truncated: true in the structured metadata block, alongside the query_id so the agent can call get_source_detail for full provenance on any source it wants to inspect deeper.

## Streaming

When a client sends Accept: text/event-stream and mode is standard or deep, the MCP server proxies Quelvio's SSE pipeline — the synthesized answer streams token-by-token from the model to the MCP server. The MCP response itself is still a single JSON body (most MCP clients today expect that); native per-token streaming to the client lands when the spec adds output deltas.

fast never streams — it has no synthesis body to incrementally produce.

## Cost transparency

Every query_knowledge response includes tokens_consumed in the structured metadata block. The usage page shows your plan's monthly allowance, the packs you have left and pages per source.

## Links & references

- [Quelvio for AI agents](https://quelvio.com/docs/ai-agents) (Use case): Per-agent quickstarts: Claude Desktop, Cursor, Claude Code, Codex
- [Quelvio/quelvio-mcp-server](https://github.com/Quelvio/quelvio-mcp-server) (GitHub): Source, README, CHANGELOG, issues
- [com.quelvio/mcp-server](https://registry.modelcontextprotocol.io/) (MCP Registry): Discovery + version metadata
- [mcp.quelvio.com](https://mcp.quelvio.com/) (Status): Server info + health
- [modelcontextprotocol.io](https://modelcontextprotocol.io) (Spec): The protocol itself

## Related

- [Human view of this page](https://quelvio.com/docs/mcp)
- [CLI docs](https://quelvio.com/docs/cli.md)
- [Everything for agents: llms.txt](https://quelvio.com/llms.txt)


<!-- Page: https://quelvio.com/docs/cli · Markdown: https://quelvio.com/docs/cli.md -->

# Your company's brain, scripted from the terminal.

Docs · CLI · Human page: https://quelvio.com/docs/cli · Machine view: https://quelvio.com/ai/docs/cli

`quelvio` is the official command-line client for the Quelvio Enterprise API. It puts every connected source — Drive, SharePoint, Confluence, Slack, Notion — behind a single, scriptable interface that returns cited, synthesized answers in human-readable or JSON form. Every request is attributed to the human running it via their Personal Access Token, so audits stay clean and per-employee permission filters apply automatically.

[Install](https://quelvio.com/docs/cli#install) · [View on GitHub](https://github.com/Quelvio/quelvio-cli)

Install: `npm i -g @quelvio/cli`

> **Prefer a GUI?** If you live in Claude Desktop, Cursor, or another Model Context Protocol client, install the Quelvio MCP server instead — same retrieval pipeline, same per-employee identity, no terminal required. [MCP server docs](https://quelvio.com/docs/mcp)

## Install

Install via npm. Node 20.10 or newer is required.

### npm (recommended)

Global install gives you the `quelvio` binary on your PATH.

```sh
npm i -g @quelvio/cli
quelvio --version
```

### From source

Useful when you want to track main or contribute. Requires pnpm.

```sh
git clone https://github.com/Quelvio/quelvio-cli
cd quelvio-cli
pnpm install
pnpm build
node dist/index.js --version
```

### Native binaries · Homebrew

Single-file binaries for macOS, Linux, Windows, and Homebrew are planned. Until then, install via npm.

## Quickstart

Three commands and you're querying production knowledge.

1. **Generate a Personal Access Token**: Sign in to the dashboard at enterprise.quelvio.com/account, open Personal API Keys, and click Create token. Tokens are scoped to your individual identity — every query you run is attributed to you and respects your per-source permissions. [enterprise.quelvio.com/account](https://enterprise.quelvio.com/account)
2. **Export it**

   ```sh
   export QUELVIO_TOKEN=qlv_pat_<your-key>
   ```
3. **Verify auth, then ask the brain a question**

   ```sh
   quelvio whoami
   quelvio query "what is our deployment process?"
   ```

## Authentication

`quelvio` resolves a token from the following sources, in order, and uses the first non-empty one. The token is never echoed to stdout, stderr, or logs — `--verbose` HTTP traces redact the `Authorization` header.

| Precedence | Source | Notes |
| --- | --- | --- |
| 1 | --token \<t> flag | Overrides everything; never persisted. |
| 2 | QUELVIO_TOKEN env var | Recommended for CI and ad-hoc shells. |
| 3 | OS keychain | Populated by quelvio login when browser-based login is available. |
| 4 | ~/.quelvio/config.json | Fallback when the OS keychain is unavailable (e.g. headless Linux). |

### Authentication methods

- **PAT** (available now): A long-lived bearer token tied to a human user. Every query is attributed to that user; permissions and rate limits apply per identity. Generate one at enterprise.quelvio.com/account.
- **OAuth login** (planned): quelvio login will perform a browser-based device-code flow and stash the resulting token in your OS keychain.
- **Service accounts** (planned): For headless agents and CI bots that need an identity distinct from a human's.

## Commands

Every command supports the global flags `--token <t>`, `--json`, `--no-color`, `--verbose`, and `--quiet`. Run `quelvio <command> --help` for the full flag list.

### `quelvio query <text>`

Ask the brain a natural-language question.

```sh
quelvio query "what is our incident response policy?"
quelvio query --mode deep --max-sources 8 "compare our Q3 vs Q4 deployment cadence"
quelvio query --domain engineering.platform "who owns the auth middleware?"
echo "draft a release note for v1.4" | quelvio query
quelvio query --json "what is our SLA?" | jq '.synthesis'
```

| Flag | Default | Notes |
| --- | --- | --- |
| `--mode <m>` | standard | fast (retrieval only, no synthesis), standard (default), or deep (wider retrieval + premium synthesis). |
| `--max-sources <n>` | 5 | Number of source chunks (1–10). |
| `--domain <d>` | — | Restrict to a taxonomy domain (e.g. engineering.platform). Discover values with quelvio domains. |
| `--stream` | off | Stream synthesis tokens as they arrive (SSE). Falls back to non-streaming if unsupported. |
| `--no-wait` | off | Return the query_id immediately for async polling. |
| `--json` | off | Emit the raw API response as JSON. |
| `--quiet` | off | Suppress the metadata footer (Query ID, kT, latency). |

If no positional text is given, piped stdin is read and used as the query; otherwise $EDITOR (or vi) opens for a multi-line prompt.

```
<synthesized answer with [1] [2] citation markers>

Sources:
  [1] runbooks/incident-response.md (confluence) — alice@acme.com, 3d ago
  [2] eng-week-2026-04-15.slack (slack) — bob@acme.com, 2w ago

Query ID: 9f3a-...  ·  Coverage: high  ·  kT: 12500  ·  1820ms
```

### `quelvio domains`

List the tenant's taxonomy domains, with coverage levels — useful before issuing a billable query.

```sh
quelvio domains
quelvio domains --json | jq '.domains[].taxonomy_domain'
```

### `quelvio source <query-id>`

Show per-chunk provenance for a previous query — document path, connector, lifecycle state, embedded timestamp, contributor, last source update.

```sh
quelvio source 9f3a4d8c-7b2e-4a3d-b1c5-1f2e3d4a5b6c
quelvio source 9f3a... --json
```

This call consumes zero Knowledge Tokens.

### `quelvio whoami`

Print the signed-in identity, tenant, auth method, and a redacted token prefix.

```sh
quelvio whoami
quelvio whoami --json
```

```
Signed in as: alice@acme.com
Tenant:       ACME Corp (aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee)
Auth method:  pat
Token prefix: qlv_pat_a1b2...
```

### `quelvio config <list|get|set|unset>`

Persist defaults in ~/.quelvio/config.json so you don't repeat flags.

```sh
quelvio config list
quelvio config get default_mode
quelvio config set default_mode deep
quelvio config set default_max_sources 8
quelvio config set api_base https://api.staging.quelvio.com
quelvio config unset api_base
```

| Key | Type | Default |
| --- | --- | --- |
| `api_base` | URL | https://api.quelvio.com |
| `default_mode` | enum | standard |
| `default_max_sources` | int 1–10 | 5 |

config list never prints the token — use the keychain or QUELVIO_TOKEN env var instead.

## Configuration

Environment variables and files that control CLI behavior.

| Name | Purpose |
| --- | --- |
| `QUELVIO_TOKEN` | Personal Access Token. Highest-precedence non-flag source. |
| `QUELVIO_API_BASE` | Override the API base URL (defaults to https://api.quelvio.com). Useful for staging. |
| `NO_COLOR` | Set to any non-empty value to suppress ANSI colors. Standard across CLIs; quelvio honors it. |
| `EDITOR / VISUAL` | Used by quelvio query when no positional text and stdin is a TTY. |
| `~/.quelvio/config.json` | Persisted defaults (mode 0600). Also holds the token when the OS keychain isn't available. |

## Exit codes

Stable exit codes so scripts can branch on outcome without parsing stderr.

| Code | Meaning |
| --- | --- |
| 0 | success |
| 1 | generic / unknown error |
| 2 | authentication problem — missing token, expired token, 401 from backend |
| 3 | resource not found (404) |
| 4 | rate limited (429) — see the Retry-After hint in stderr |
| 5 | response truncated (synthesis exceeded the 25k-token cap) |
| 6 | scope / permission error (403) |
| 7 | network error — DNS failure, connection refused, TLS error |

## Output formats

Humans. The default output is prose with ANSI color, citation bolding, and a metadata footer. Colors auto-disable when stdout is not a TTY or when NO_COLOR is set.

Agents and scripts. Add --json to any command for a machine-readable response. Pretty-printed when stdout is a TTY, compact when piped — always parseable by jq.

```sh
quelvio query "what is our SLA?" --json | jq -r '.synthesis'
quelvio domains --json | jq -r '.domains[] | "\(.taxonomy_domain)\t\(.document_count)"'
```

## Examples

Patterns we use ourselves.

### Bash one-liner

Pipe synthesized answers through jq into a Markdown file.

```sh
QUELVIO_TOKEN="qlv_pat_..." \
  quelvio query --json "summarize our security policies" \
  | jq -r '.synthesis' \
  | tee summary.md
```

### GitHub Actions

Store your PAT as a repository secret (QUELVIO_PAT) and generate a knowledge digest on a schedule.

```yaml
name: nightly-knowledge-digest
on:
  schedule:
    - cron: '0 13 * * *'
jobs:
  digest:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/setup-node@v4
        with:
          node-version: '20'
      - run: npm i -g @quelvio/cli
      - name: Generate digest
        env:
          QUELVIO_TOKEN: ${{ secrets.QUELVIO_PAT }}
        run: |
          quelvio query "what changed in eng this week?" --mode deep --json \
            | jq -r '.synthesis' > digest.md
      - uses: actions/upload-artifact@v4
        with:
          name: digest
          path: digest.md
```

### AI coding agents

AI coding agents like Claude Code, Cursor, and OpenAI Codex can invoke the Quelvio CLI natively. Drop the matching SKILL.md from the agent-skills repo into your agent's runtime and it will reach for `quelvio query` whenever a question lands on internal company knowledge.

```sh
quelvio query "what is the rollback procedure for production deploys?"
```

> **Agent skills** Per-agent skill files for Claude Code, Cursor, Codex, and any MCP-compatible runtime live at github.com/Quelvio/quelvio-agent-skills. [repo](https://github.com/Quelvio/quelvio-agent-skills)

## Troubleshooting

Most failures fall into a handful of buckets. `--verbose` adds HTTP trace lines to stderr — useful when reporting issues.

| Symptom | Fix |
| --- | --- |
| No authentication token found. (exit 2) | Export QUELVIO_TOKEN, or pass --token \<t>. |
| Authentication failed: Invalid enterprise API key. (exit 2) | Token revoked, expired, or copied incorrectly. Generate a new one at enterprise.quelvio.com/account. |
| Forbidden: ... (exit 6) | The token's identity lacks permission for that document/domain. Ask the tenant owner; permission filters apply per user. |
| Rate limited: ... (retry after Ns) (exit 4) | Back off N seconds; the CLI doesn't auto-retry 429. Your daily kT pool resets at 00:00 UTC. |
| Network error: ... (exit 7) | DNS or TLS failure. Check connectivity to api.quelvio.com; try curl -v https://api.quelvio.com/openapi.json. |
| OS keychain unavailable; using ~/.quelvio/config.json | Linux without libsecret. Install libsecret-1-0 (Debian/Ubuntu) or libsecret (Fedora/Arch) to use the OS keychain. |
| default_max_sources must be an integer 1-10 | The backend caps results at 10 chunks. Lower the value. |

## Links & references

- [Quelvio for AI agents](https://quelvio.com/docs/ai-agents) (Use case): Per-agent quickstarts: Claude Code, Cursor, Codex, MCP
- [Quelvio/quelvio-cli](https://github.com/Quelvio/quelvio-cli) (GitHub): Source, README, CHANGELOG, issues
- [enterprise.quelvio.com/account](https://enterprise.quelvio.com/account) (Dashboard): Generate Personal Access Tokens
- [Quelvio/quelvio-agent-skills](https://github.com/Quelvio/quelvio-agent-skills) (Agent skills): Skill files for Claude Code, Cursor, Codex, and MCP agents
- [Quelvio MCP server](https://quelvio.com/docs/mcp) (Also see): Same brain, exposed over Model Context Protocol

## Related

- [Human view of this page](https://quelvio.com/docs/cli)
- [MCP server docs](https://quelvio.com/docs/mcp.md)
- [Everything for agents: llms.txt](https://quelvio.com/llms.txt)


<!-- Page: https://quelvio.com/docs/ai-agents · Markdown: https://quelvio.com/docs/ai-agents.md -->

# Bring your company's brain to your AI coding agents.

Docs · For AI agents · Human page: https://quelvio.com/docs/ai-agents · Machine view: https://quelvio.com/ai/docs/ai-agents

AI coding agents like Claude Code, Cursor, and OpenAI Codex are great at general programming knowledge but blind to your company's internal context — past decisions, code conventions, team policies, deprecated approaches. Quelvio fills that gap with cited, lifecycle-aware answers under each employee's real identity.

[Quickstart by agent](https://quelvio.com/docs/ai-agents#agents) · [Agent skills repo](https://github.com/Quelvio/quelvio-agent-skills)

## Overview

General-purpose AI coding agents have read the internet — they know your framework, your language, your patterns. What they don't know is the past five years of your team's decisions: why the queue was replaced, which auth approach was deprecated, what the on-call rotation looks like, who owns the data plane. That context lives in your Drive, your SharePoint, your Confluence, your Slack, your Notion. Quelvio surfaces it with citations, lifecycle awareness, and per-employee permission filtering.

Connecting an agent to Quelvio takes minutes — the only choice is which protocol fits the agent's workflow.

## Two ways to connect

Two protocols, same brain. GUI-resident agents speak Model Context Protocol; terminal-resident agents shell out to a CLI. Some agents — Cursor is the clearest example — speak both, and you pick based on workflow.

- **MCP: Model Context Protocol.** For GUI-resident agents. Claude Desktop, Claude Connectors, Cursor, and any other MCP-compatible client connect to mcp.quelvio.com over OAuth 2.1. The agent calls three tools — query_knowledge, list_domains, get_source_detail — and gets cited, synthesized answers back. Single URL, no install on the developer's machine beyond the client itself. [MCP server reference](https://quelvio.com/docs/mcp)
- **CLI: Quelvio CLI.** For terminal-resident agents. Claude Code, OpenAI Codex CLI, custom shell-driven agents, and CI jobs invoke `quelvio query` as a shell command. The CLI is a single npm install with a PAT in your environment. Per-agent skill files in github.com/Quelvio/quelvio-agent-skills teach each agent when to reach for `quelvio query` and how to compose its output. [CLI reference](https://quelvio.com/docs/cli)

## Per-agent quickstart

Pick your agent. Each quickstart is four steps or fewer; full reference for the underlying protocol lives in /docs/mcp or /docs/cli.

### Claude Code (CLI)

Anthropic's terminal-resident coding agent. The Quelvio skill teaches Claude Code to reach for `quelvio query` whenever a question lands on internal company knowledge.

1. **Install the CLI**

   ```sh
   npm i -g @quelvio/cli
   quelvio --version
   ```
2. **Authenticate**: Generate a Personal Access Token at enterprise.quelvio.com/account → Personal API Keys → Create token. Export it (browser-based `quelvio login` ships in v0.2.0; PAT is the v0.1.0 path):

   ```sh
   export QUELVIO_TOKEN=qlv_pat_<your-token>
   quelvio whoami
   ```
3. **Install the skill**: Drop the skill file into Claude Code's user-scoped skills directory:

   ```sh
   mkdir -p ~/.claude/skills/quelvio
   curl -fsSL https://raw.githubusercontent.com/Quelvio/quelvio-agent-skills/main/claude-code/SKILL.md \
     -o ~/.claude/skills/quelvio/SKILL.md
   ```
4. **Verify**: Restart your Claude Code session and ask something that lands on internal knowledge — e.g. "what's our deployment runbook?" Claude Code should invoke `quelvio query` and relay the answer with citation markers.

[Skill file & install notes](https://github.com/Quelvio/quelvio-agent-skills/tree/main/claude-code)

### Claude Desktop (MCP)

Anthropic's desktop app. Quelvio installs as an MCP integration with OAuth sign-in — no token to copy, no config file to edit by hand.

1. **Open the integrations panel**: Claude Desktop → Settings → Integrations → Add server.
2. **Paste the server URL**

   ```sh
   https://mcp.quelvio.com/http
   ```
3. **Sign in**: Claude walks you through OAuth with your Quelvio workspace credentials — the same identity you use for the dashboard. The integration auto-binds to your employee identity.
4. **Verify**: Ask Claude a question about your company. It should call the `query_knowledge` tool and return a synthesized answer with sources.

[Skill file & install notes](https://quelvio.com/docs/mcp#install)

### Cursor (Both)

Cursor speaks both MCP and the CLI. Pick MCP if you want a native in-editor tool call; pick the CLI + skill if you prefer a shell tool the agent invokes via Cursor's terminal.

#### MCP path

1. **Add the server to ~/.cursor/mcp.json (or via Cursor settings UI)**

   ```json
   {
     "mcpServers": {
       "quelvio": {
         "url": "https://mcp.quelvio.com/http"
       }
     }
   }
   ```
2. **First call triggers OAuth in a browser tab**: Same workspace identity as Claude Desktop. The integration auto-binds to your employee identity.

#### CLI + skill path

1. **Install the CLI and authenticate**

   ```sh
   npm i -g @quelvio/cli
   export QUELVIO_TOKEN=qlv_pat_<your-token>
   ```
2. **Install the Cursor rule**

   ```sh
   mkdir -p .cursor/rules
   curl -fsSL https://raw.githubusercontent.com/Quelvio/quelvio-agent-skills/main/cursor/SKILL.md \
     -o .cursor/rules/quelvio.mdc
   ```
3. **Reload the workspace**: Cursor reloads rules on file save. If the rule isn't taking effect, restart the chat or workspace.

[Skill file & install notes](https://github.com/Quelvio/quelvio-agent-skills/tree/main/cursor)

### OpenAI Codex CLI (CLI)

OpenAI's terminal-resident coding agent reads AGENTS.md for tool guidance. The Quelvio skill ships as a portable Markdown file ready to drop in.

1. **Install the CLI**

   ```sh
   npm i -g @quelvio/cli
   quelvio --version
   ```
2. **Authenticate**

   ```sh
   export QUELVIO_TOKEN=qlv_pat_<your-token>
   quelvio whoami
   ```
3. **Install the skill**: Drop the skill as AGENTS.md at the repo root (project-scoped) or in ~/.codex/AGENTS.md (global). If you already have an AGENTS.md, append rather than overwrite.

   ```sh
   curl -fsSL https://raw.githubusercontent.com/Quelvio/quelvio-agent-skills/main/codex/SKILL.md \
     -o AGENTS.md
   ```
4. **Verify**: Restart your Codex session and ask a question about your company's internal knowledge. Codex should invoke `quelvio query` and surface citations in its response.

[Skill file & install notes](https://github.com/Quelvio/quelvio-agent-skills/tree/main/codex)

### Any MCP-compatible agent (MCP)

OpenClaw, custom MCP clients, in-house agent runtimes — anything that speaks MCP can connect to mcp.quelvio.com. If your runtime accepts a system-prompt addendum or instruction file, the generic skill in the agent-skills repo teaches it when and how to use the Quelvio tools.

1. **Point your client at mcp.quelvio.com/http**: Server URL: https://mcp.quelvio.com/http. Authentication: OAuth 2.1 with PKCE; DCR-supported. Registry entry: com.quelvio/mcp-server on registry.modelcontextprotocol.io.
2. **Inject the generic skill**: Include mcp-generic/SKILL.md from the agent-skills repo as a system-prompt addendum, tool-description string, or instruction file — whichever your runtime accepts.
3. **Verify**: Confirm the agent reaches for `query_knowledge` on internal-knowledge questions and relays the `[N]` citation markers verbatim.

[Skill file & install notes](https://github.com/Quelvio/quelvio-agent-skills/tree/main/mcp-generic)

### Other agents (Coming)

Continue, Aider, Windsurf, Cline, GitHub Copilot CLI, Pieces — new skill files land in the agent-skills repo as each runtime's tool-context conventions stabilize. Watch github.com/Quelvio/quelvio-agent-skills for updates, or open a PR to contribute one.

[Skill file & install notes](https://github.com/Quelvio/quelvio-agent-skills)

## Building your own AI app?

The paths above assume you're plugging an existing agent runtime — Claude Code, Cursor, Claude Desktop — into Quelvio. If instead you're building an AI product directly against OpenAI, Anthropic, or Mistral's APIs (with raw function-calling, not LangChain or LlamaIndex), there's a thinner integration path: register Quelvio as a tool the model can call, and dispatch its calls to `POST /v1/enterprise/query`.

The dedicated docs page ships copy-pasteable JSON specs for OpenAI, Anthropic, and Mistral, plus TypeScript and Python executor snippets — and a short rundown of when a framework SDK (LangChain, LlamaIndex, Vercel AI SDK, CrewAI) is the better fit.

[LLM tool definitions →](https://quelvio.com/docs/integrations/llm-tool-definitions)

## What becomes possible

Four concrete things that become possible once your agent can read the company brain.

1. **Onboarding a new engineer.** Their AI assistant answers "what's our deployment runbook?" or "where do we document architectural decisions?" with citations to internal docs. Senior engineers stop spending hours on tribal-knowledge transfer; the new hire ramps faster and audits their own answers against the cited sources.
2. **Cross-document synthesis during a refactor.** "How have we attempted REST → gRPC migrations before, and what went wrong?" — Quelvio surfaces past RFCs, postmortems, and decisions across years of corpus. The agent reads the lineage before recommending an approach, instead of confidently re-proposing something the team already tried and rolled back.
3. **Lifecycle-aware code review.** "Is this approach still our standard, or has it been superseded?" — Quelvio flags when a decision has been overridden by a more recent one. The agent doesn't accidentally restore a deprecated pattern, and the reviewer doesn't have to dig through Confluence history to spot it.
4. **Compliance-ready answers in regulated industries.** Every Quelvio answer ships with citations, source provenance, and the employee identity that made the query. Auditors can trace which documents informed any recommendation; security teams can revoke a user's access in one place and trust that every downstream agent inherits the change.

## Links & references

- [Quelvio/quelvio-agent-skills](https://github.com/Quelvio/quelvio-agent-skills) (GitHub): Per-agent SKILL.md files for Claude Code, Cursor, Codex, MCP
- [Quelvio CLI](https://quelvio.com/docs/cli) (Reference): Install, command reference, exit codes, JSON output
- [Quelvio MCP server](https://quelvio.com/docs/mcp) (Reference): Install, tools, modes, OAuth, permission model
- [LLM tool definitions](https://quelvio.com/docs/integrations/llm-tool-definitions) (Integration): OpenAI, Anthropic, Mistral function-calling JSON — for building from scratch
- [Account & API keys](https://enterprise.quelvio.com/account) (Dashboard): Generate Personal Access Tokens at enterprise.quelvio.com/account

## Related

- [Human view of this page](https://quelvio.com/docs/ai-agents)
- [Everything for agents: llms.txt](https://quelvio.com/llms.txt)


<!-- Page: https://quelvio.com/docs/integrations/llm-tool-definitions · Markdown: https://quelvio.com/docs/integrations/llm-tool-definitions.md -->

# LLM tool definitions.

Docs · Integrations · Human page: https://quelvio.com/docs/integrations/llm-tool-definitions · Machine view: https://quelvio.com/ai/docs/integrations/llm-tool-definitions

Direct integration patterns for OpenAI, Anthropic, and Mistral function-calling — no framework required.

[Start with the endpoint](https://quelvio.com/docs/integrations/llm-tool-definitions#endpoint) · [REST API reference](https://api.quelvio.com/openapi.json)

## Overview

If you're building an AI product directly against an LLM provider's API — OpenAI function calling, Anthropic tool use, Mistral function calling — and you don't want a framework layer like LangChain or LlamaIndex sitting between your code and the model, this page gives you the JSON specs you need to wire Quelvio in as a tool the model can call.

Each provider's spec maps the same Quelvio endpoint — `POST /v1/enterprise/query` — into that provider's expected schema. The model picks when to call `quelvio_query`; your executor posts to Quelvio's REST API and feeds the cited answer back to the model. One endpoint, three thin wrappers.

If you ARE using a framework, jump to the [framework SDKs](#frameworks) section — the dedicated packages handle retries, citation parsing, and conversation memory for you.

## Query endpoint

`POST /v1/enterprise/query` takes a natural-language `query`, an optional retrieval `mode`, a result `limit`, and an optional `domain_filter`. It returns a synthesized answer with `[N]` citation markers and a `sources` array carrying provenance for each citation. Every request is attributed to the human user via their Personal Access Token — per-employee permissions and audit trails apply automatically.

### Request body

```json
{
  "query": "what is our deployment runbook?",
  "mode": "standard",
  "limit": 5,
  "domain_filter": "engineering"
}
```

### Response body

```json
{
  "query_id": "9f3a4d8c-7b2e-4a3d-b1c5-1f2e3d4a5b6c",
  "synthesis": "Production deploys go through GitHub Actions [1]. The rollback runbook lives in Confluence [2]...",
  "sources": [
    {
      "n": 1,
      "title": ".github/workflows/deploy.yml",
      "connector": "github",
      "contributor": "alice@acme.com",
      "updated_at": "2026-04-12T10:14:00Z"
    },
    {
      "n": 2,
      "title": "Runbooks / Rollback",
      "connector": "confluence",
      "contributor": "bob@acme.com",
      "updated_at": "2026-03-28T09:02:00Z"
    }
  ],
  "meta": { "kT": 12500, "latency_ms": 1820, "coverage": "high" }
}
```

Full schema, error codes, and rate-limit headers live in the OpenAPI document at api.quelvio.com/openapi.json.

## OpenAI function calling

OpenAI's function-calling API expects each tool as a `{ type: "function", function: { name, description, parameters } }` object inside the `tools` array on `chat.completions.create`. The `parameters` field is a JSON Schema describing the arguments the model is allowed to pass.

### Tool definition

```json
{
  "type": "function",
  "function": {
    "name": "quelvio_query",
    "description": "Query the company's authority-scored, lifecycle-aware knowledge brain. Returns cited answers with provenance. Use when the user asks about internal company knowledge (policies, runbooks, decisions, documentation, project status).",
    "parameters": {
      "type": "object",
      "properties": {
        "question": {
          "type": "string",
          "description": "The question to answer using company knowledge."
        },
        "mode": {
          "type": "string",
          "enum": ["fast", "standard", "deep"],
          "description": "Retrieval depth. 'fast' for quick lookups, 'standard' for most queries, 'deep' for cross-document synthesis. Defaults to 'standard'."
        },
        "max_sources": {
          "type": "integer",
          "minimum": 1,
          "maximum": 50,
          "description": "Maximum number of source chunks to retrieve. Defaults to 5."
        },
        "domain": {
          "type": "string",
          "description": "Optional taxonomy domain to filter (e.g., 'engineering', 'finance')."
        }
      },
      "required": ["question"]
    }
  }
}
```

### Executor (TypeScript)

```typescript
// When the LLM calls the tool, execute it against Quelvio's REST API.
// The same handler works for OpenAI, Anthropic, and Mistral — only the
// tool-definition wrapper differs between providers.
async function executeQuelvioTool(args: {
  question: string;
  mode?: "fast" | "standard" | "deep";
  max_sources?: number;
  domain?: string;
}) {
  const response = await fetch("https://api.quelvio.com/v1/enterprise/query", {
    method: "POST",
    headers: {
      Authorization: `Bearer ${process.env.QUELVIO_API_KEY}`,
      "Content-Type": "application/json",
    },
    body: JSON.stringify({
      query: args.question,
      mode: args.mode ?? "standard",
      limit: args.max_sources ?? 5,
      domain_filter: args.domain,
    }),
  });

  if (!response.ok) {
    throw new Error(`Quelvio query failed: ${response.status} ${response.statusText}`);
  }

  const data = await response.json();
  return formatAnswerWithCitations(data);
}
```

### Executor (Python)

```python
# When the LLM calls the tool, execute it against Quelvio's REST API.
# The same handler works for OpenAI, Anthropic, and Mistral — only the
# tool-definition wrapper differs between providers.
import os
import httpx

def execute_quelvio_tool(args: dict) -> dict:
    response = httpx.post(
        "https://api.quelvio.com/v1/enterprise/query",
        headers={
            "Authorization": f"Bearer {os.environ['QUELVIO_API_KEY']}",
            "Content-Type": "application/json",
        },
        json={
            "query": args["question"],
            "mode": args.get("mode", "standard"),
            "limit": args.get("max_sources", 5),
            "domain_filter": args.get("domain"),
        },
        timeout=30.0,
    )
    response.raise_for_status()
    return format_answer_with_citations(response.json())
```

Wire `executeQuelvioTool` into your `tool_calls` handler — when the model returns a `tool_calls` array, route entries with `function.name === "quelvio_query"` to it, feed the result back as a `role: "tool"` message, and re-call `chat.completions.create`.

## Anthropic tool use

Anthropic's tool-use API expects each tool as a `{ name, description, input_schema }` object passed to `messages.create` via the `tools` parameter. The `input_schema` is a JSON Schema — the shape mirrors OpenAI's `parameters`, but the wrapper field names differ.

### Tool definition

```json
{
  "name": "quelvio_query",
  "description": "Query the company's authority-scored, lifecycle-aware knowledge brain. Returns cited answers with provenance. Use when the user asks about internal company knowledge.",
  "input_schema": {
    "type": "object",
    "properties": {
      "question": {
        "type": "string",
        "description": "The question to answer using company knowledge."
      },
      "mode": {
        "type": "string",
        "enum": ["fast", "standard", "deep"]
      },
      "max_sources": {
        "type": "integer",
        "minimum": 1,
        "maximum": 50
      },
      "domain": {
        "type": "string"
      }
    },
    "required": ["question"]
  }
}
```

The execution code is identical to the OpenAI snippet above — only the tool-definition wrapper changes between providers. When Claude returns a `tool_use` content block, dispatch its `input` to the same `executeQuelvioTool` function and reply with a `tool_result` block carrying the formatted answer.

## Mistral function calling

Mistral's function-calling API is OpenAI-compatible — the same `{ type: "function", function: { name, description, parameters } }` wrapper, the same `tool_calls` response shape on `client.chat.complete`. The OpenAI spec above can be reused verbatim.

### Tool definition

```json
{
  "type": "function",
  "function": {
    "name": "quelvio_query",
    "description": "Query the company's authority-scored, lifecycle-aware knowledge brain. Returns cited answers with provenance. Use when the user asks about internal company knowledge (policies, runbooks, decisions, documentation, project status).",
    "parameters": {
      "type": "object",
      "properties": {
        "question": {
          "type": "string",
          "description": "The question to answer using company knowledge."
        },
        "mode": {
          "type": "string",
          "enum": ["fast", "standard", "deep"],
          "description": "Retrieval depth. 'fast' for quick lookups, 'standard' for most queries, 'deep' for cross-document synthesis. Defaults to 'standard'."
        },
        "max_sources": {
          "type": "integer",
          "minimum": 1,
          "maximum": 50,
          "description": "Maximum number of source chunks to retrieve. Defaults to 5."
        },
        "domain": {
          "type": "string",
          "description": "Optional taxonomy domain to filter (e.g., 'engineering', 'finance')."
        }
      },
      "required": ["question"]
    }
  }
}
```

Quirk to watch for: Mistral expects each tool call's result to come back as a message with `role: "tool"` and a stringified JSON `content`. If you JSON-stringify Quelvio's response before feeding it back, you're fine; if you pass an object, Mistral will reject the request.

## Raw vs framework SDK

Raw function-calling and a framework SDK are different trade-offs, not different paths to the same outcome. Pick by which set of concerns you'd rather own yourself.

| When | What wins |
| --- | --- |
| Raw function-calling | Tight bundle size, full control over the agent loop, no framework dependency to track, custom orchestration patterns, single-provider apps where you don't need provider abstraction. |
| Framework SDK | Built-in retry and error handling, conversation memory and message-history management, multi-tool composition, less boilerplate, easier to swap providers, ecosystem of pre-built integrations. |

### Framework SDKs

- [LangChain Python](https://pypi.org/project/quelvio-langchain): `pip install quelvio-langchain`
- [LangChain JS](https://www.npmjs.com/package/@quelvio/langchain): `npm install @quelvio/langchain`
- [LlamaIndex](https://pypi.org/project/llama-index-retrievers-quelvio): `pip install llama-index-retrievers-quelvio`
- [Vercel AI SDK](https://www.npmjs.com/package/@quelvio/vercel-ai-sdk): `npm install @quelvio/vercel-ai-sdk`
- [CrewAI](https://pypi.org/project/quelvio-crewai): `pip install quelvio-crewai`

LlamaIndex, Vercel AI SDK, and CrewAI packages are forthcoming — links will resolve once they publish. LangChain Python and LangChain JS are live today.

## Links & references

- [Quelvio for AI agents](https://quelvio.com/docs/ai-agents) (Use case): Per-agent quickstarts: Claude Code, Cursor, Codex, MCP
- [Quelvio MCP server](https://quelvio.com/docs/mcp) (Reference): Same brain over Model Context Protocol — for GUI-resident agents
- [Quelvio CLI](https://quelvio.com/docs/cli) (Reference): Same brain from the terminal — for shell-driven agents and CI
- [OpenAPI specification](https://api.quelvio.com/openapi.json) (REST API): Full schema for /v1/enterprise/query, including error codes and rate-limit headers
- [Account & API keys](https://enterprise.quelvio.com/account) (Dashboard): Generate Personal Access Tokens for QUELVIO_API_KEY at enterprise.quelvio.com/account

## Related

- [Human view of this page](https://quelvio.com/docs/integrations/llm-tool-definitions)
- [Everything for agents: llms.txt](https://quelvio.com/llms.txt)


<!-- Page: https://quelvio.com/blog/quelvio-cli-launch · Markdown: https://quelvio.com/blog/quelvio-cli-launch.md -->

# Quelvio CLI: company knowledge in your terminal

Blog · Human page: https://quelvio.com/blog/quelvio-cli-launch · Machine view: https://quelvio.com/ai/blog/quelvio-cli-launch

May 22, 2026 · Company · 6 min read

Completions, smart hints, progress indicators, update-check, and $EDITOR multiline. Why a CLI when Quelvio already speaks MCP — and what authority-scored, lifecycle-aware retrieval looks like at a shell prompt.

The Quelvio CLI is a single npm binary — `@quelvio/cli` — that takes a natural-language question, hits Quelvio Brain, and returns a cited answer in your terminal. It is the same retrieval pipeline that powers our MCP server, our REST API, our Slack and Teams bots, and the dashboard — exposed in the shape a terminal-resident agent or a human at a prompt actually wants.

A reasonable question is: why a CLI when we already ship MCP? Because agents come in different shapes. Claude Desktop, Cursor, and ChatGPT custom connectors speak MCP, and Quelvio meets them there. But Claude Code, OpenAI's Codex CLI, GitHub Actions runners, and the engineer typing into a tmux pane all live in the terminal. MCP is the wrong shape for them. Same brain, different surface.

## The shape of the integration problem

MCP solved one specific problem well — it gave agents a uniform way to discover and call tools across servers, with the runtime handling auth, transport, and capability negotiation. If you run inside a host that already speaks MCP, plugging Quelvio in is a configuration change. We have docs for that.

But MCP assumes a host. A Claude Code session, or an Anthropic SDK script running inside `bash`, *is* the host; there is no MCP runtime layered above it. Forcing one in is heavy — another process to manage, another connection lifecycle, another set of credentials in another place. The right shape for that environment is the shape every other piece of dev tooling already takes: a binary on `PATH` that reads stdin, writes stdout, and obeys exit codes.

That is what `quelvio` is. One binary, every connector behind it. Pipe to `jq`. Exit on non-zero. Drop it into a `Makefile`. The CLI doesn't compete with the MCP server; it covers the half of the integration surface MCP doesn't reach.

The companion piece is the [agent-skills repo](https://github.com/Quelvio/quelvio-agent-skills). Per-runtime skill files — Claude Code, Cursor, Codex CLI, MCP — that teach the host agent when to reach for `quelvio query`. The skill turns the CLI into native vocabulary: the agent sees a question about internal company knowledge and knows there is a command that can answer it, not just "the web."

## What the CLI actually does

The surface area is small on purpose. Five primary commands and the polish that makes them feel native.

```sh
quelvio login                            # device-flow OAuth, token in OS keychain
quelvio query "what is our SLA?"         # synthesized, cited answer
quelvio domains                          # taxonomy domains + coverage levels
quelvio source <query-id>                # per-chunk provenance, zero cost
quelvio whoami                           # signed-in identity + tenant
```

Two flags carry most of the weight. `--mode deep` widens retrieval and runs premium synthesis when the question is worth it; `--json` swaps the prose output for a machine-readable response that any downstream agent can parse.

Underneath the commands sits the polish that makes the CLI stop feeling like a wrapper and start feeling like a tool. Five things make that real.

**Shell completions across bash, zsh, and fish.** Run `quelvio completion zsh` and pipe the output where your shell expects it. Tab-complete commands, flags, and the values for `--mode`. The most common path to "this works the way I expect" in a CLI is making it answer to muscle memory.

```sh
# zsh: drop completions into a fpath directory
quelvio completion zsh > "${fpath[1]}/_quelvio"

# bash: append to ~/.bashrc once
echo 'source <(quelvio completion bash)' >> ~/.bashrc

# fish: standard completions dir
quelvio completion fish > ~/.config/fish/completions/quelvio.fish
```

**Smart error hints.** Every stratified exit code now carries a one-line suggestion in stderr. Exit 2 ("no token") tells you to `export QUELVIO_TOKEN` or run `quelvio login`. Exit 4 ("rate limited") quotes the `Retry-After` and reminds you the daily kT pool resets at 00:00 UTC. The CLI knows what to try next; it should say so.

**Progress indicators on `--mode deep`.** Deep mode takes a few seconds — wider retrieval, premium synthesis. The CLI now streams the pipeline transitions so you see where time is going: `connecting → retrieving → re-ranking → synthesizing`. Spinners auto-disable when stdout isn't a TTY, so piped scripts stay clean.

**Daily update-check probe.** The CLI quietly checks npm for new releases, at most once a day, and prints a one-line notice when a newer version is available. Set `QUELVIO_UPDATE_CHECK=0` to turn it off — we honor that variable everywhere it could surprise you.

**`$EDITOR` multiline query.** Run `quelvio query` with no positional argument and no piped stdin; the CLI opens `$EDITOR` (or `vi`) on a scratch file, strips lines starting with `#`, and sends the rest. Drafting a real question in `vim` beats wrestling it into a single quoted string every time.

## Authority, lifecycle, supersession — in the terminal

What ships in the terminal is what ships everywhere — the same brain, with the same posture.

Quelvio ranks sources by **authority**, scored per contributor per domain. The CTO's note on the auth rewrite outweighs a junior engineer's hot take in a side channel; the engineer who actually wrote the payment system outweighs the CTO when the question is about payment edge cases. Authority is conditional.

Results are **lifecycle-aware**. Drafts, current canonical documents, superseded memos, and deprecated runbooks all get labeled distinctly. Stale content is demoted. Where one document supersedes another, the answer says so.

When the corpus does not contain enough signal, the CLI **refuses**. Confidently-wrong is the failure mode of every system that grounds answers in retrieved fragments; we treat it as a bug.

Every claim cites the chunk it came from. Run `quelvio source <query-id>` to see the document path, connector, lifecycle state, contributor, and last-update time for each citation. That call consumes zero Knowledge Tokens.

> **Concrete shape** Ask a naive RAG-over-an-index system *"what's our rollback procedure for the payments service?"* and it hands you the highest-cosine-similarity match — which may well be a 2024 wiki page nobody has updated since the cutover. Ask the same of `quelvio query` and you get either the post-cutover procedure with the older one labeled as superseded, or — if the corpus genuinely doesn't carry a current answer — a refusal with the gap surfaced. Either is a better answer than the confident-wrong one.

## Install and try

One command:

```sh
npm install -g @quelvio/cli
```

Node 20.10 or newer. Then:

```sh
quelvio login
quelvio query "what does our team know about kT pricing?"
```

`quelvio login` runs the OAuth device-code flow against the dashboard at `enterprise.quelvio.com/device`. The resulting token lands in your OS keychain — Keychain on macOS, the appropriate native store on Windows and Linux. If you'd rather use a Personal Access Token in CI, set `QUELVIO_TOKEN`; the flag → env → keychain → config precedence is documented in full on the [CLI reference page](https://quelvio.com/docs/cli).

Roadmap: single-file native binaries and a Homebrew formula are next. For now, install via npm. If you're outside the terminal — Claude Desktop, Cursor, Claude.ai, ChatGPT — the [MCP server](https://quelvio.com/docs/mcp) is the right entry point. Same brain, OAuth-protected, no Node required.

## What's next

The CLI is one move in a longer integration plan. The [agent-skills repo](https://github.com/Quelvio/quelvio-agent-skills) gives each runtime — Claude Code, Cursor, Codex, MCP — a per-agent skill file that turns `quelvio query` into native vocabulary. The MCP server is live today and covers everything that isn't terminal-resident. Native binaries and a Homebrew formula come next, followed by first-class adapters for LangChain, LlamaIndex, and the Vercel AI SDK.

The thesis underneath all of it is the same: agents come in many shapes. The knowledge brain has to meet each one in the shape it already takes.

Tags: CLI, MCP, Agents

## Related

- [Human view of this page](https://quelvio.com/blog/quelvio-cli-launch)
- [All posts (machine view)](https://quelvio.com/ai/blog)
- [Everything for agents: llms.txt](https://quelvio.com/llms.txt)


<!-- Page: https://quelvio.com/blog/how-quelvio-ranks-authority · Markdown: https://quelvio.com/blog/how-quelvio-ranks-authority.md -->

# How Quelvio ranks authority across your company's knowledge

Blog · Human page: https://quelvio.com/blog/how-quelvio-ranks-authority · Machine view: https://quelvio.com/ai/blog/how-quelvio-ranks-authority

May 18, 2026 · Engineering · 8 min read

A look at the freshness × authorship × cross-reference graph that decides which Slack message wins over a year-old PDF — and why our retrieval pipeline routes by expertise, not by keywords.

Two documents in a company's corpus claim the answer to the same question. One is a polished PDF from 2024 describing how the payments service handles refunds. The other is a four-message Slack thread from last week between the engineer who shipped the rewrite and the CTO, agreeing on the new behavior. A keyword-matched search returns the PDF first, because PDFs are dense, well-formatted, and rank well by every traditional retrieval signal. The Slack thread loses, because Slack threads always lose to PDFs in keyword search. The agent quoting that answer is now wrong in production.

This is the failure mode our authority graph was built to fix. The pipeline does not ask *"which document best matches the words in the query?"* — it asks *"which contributor, on this topic, in this lifecycle window, carries the most signal?"* Keywords are a starting filter. Authority is the actual ranker.

## Three signals, multiplied

The authority score for a candidate chunk is a product of three independent signals — multiplied, not summed, so that any one of them dropping toward zero collapses the score regardless of the others. The signals are **freshness**, **authorship**, and **cross-reference position**.

**Freshness** is not just "how old is the document." It is a per-domain decay curve. Architectural decisions in a stable area age slowly; a sprint plan ages in days. Quelvio learns the half-life per taxonomy domain from how often other documents in the same domain supersede or reference back to the source — domains with high churn have shorter half-lives, domains with stable canonical content have longer ones. A 2024 PDF in `engineering.payments` is treated very differently from a 2024 PDF in `legal.privacy-policy`.

**Authorship** is domain-conditional. The engineer who shipped the payments rewrite has very high authority in `engineering.payments` and approximately zero in `marketing.brand`. Their Slack message in the payments domain outweighs a CTO's offhand comment in the same domain; the same engineer's casual aside about marketing copy carries no weight. Authority is built up from contribution history — who wrote, who reviewed, who reacted, who linked to what — and the graph updates as contributors' actual ownership patterns evolve.

**Cross-reference position** is where the document sits in the graph of agreement, disagreement, and supersession. A document that is referenced approvingly by ten subsequent documents in the same domain accumulates positive position; one that has been explicitly contradicted or replaced by a newer source loses position fast. This is the signal that lets us notice that the 2024 PDF was quietly superseded by a Slack thread — even though the PDF itself was never edited.

## What this looks like at query time

When `quelvio query "how do refunds work in payments?"` arrives, the pipeline runs in four stages. First, taxonomy routing: which domains does this question touch? (Here: `engineering.payments`, possibly `customer-support.refunds`.) Second, candidate retrieval inside those domains by vector similarity. Third, authority re-ranking of the candidate set using the three signals above. Fourth, refusal-check and synthesis over whatever survives the re-rank.

```sh
quelvio query --mode deep "how do refunds work in payments?"

⠋ connecting...
⠙ retrieving (engineering.payments, customer-support.refunds)...
⠹ re-ranking by authority...
⠸ synthesizing...

Refunds in the payments service are issued through the new
/v2/refund endpoint, introduced in the April rewrite [1]. The
previous /v1/refund flow described in the 2024 architecture
document is no longer in use and has been marked superseded [2].
...

Sources:
  [1] eng-week-2026-04-22.slack — finn@acme.com, 4w ago
  [2] payments-architecture-2024.pdf — alice@acme.com, 18mo ago (SUPERSEDED)
```

Notice the lifecycle label on the older PDF. The cross-reference graph caught that a more recent, higher-authorship-weighted source in the same domain described different behavior, and that the engineer named on the older document had implicitly handed off — Quelvio sees that explicit transfer of authority in commit history, in Slack mentions, in document edit chains. We label the older source `SUPERSEDED` and demote it. We do not delete it; sometimes the historical view is what the reader actually wants, and `--include-superseded` brings it back.

## Why this isn't just "recency"

A common shortcut in retrieval systems is to bias toward recency — newer documents rank higher. This breaks on every kind of canonical content. Your security policy from two years ago is *more* authoritative than the draft a junior engineer wrote yesterday. Your architectural decision log from 2023 is the canonical version, not the speculation thread from this morning. Treating freshness as a blunt scalar fails in both directions: it boosts noise and demotes truth.

Authority ranking dissolves this. Freshness is one of three multiplicative signals, and its weight is itself learned per domain. In high-churn engineering domains, fresh content tends to also carry high authorship and high cross-reference position — the team is iterating, the canonical view is moving, and recency tracks truth. In low-churn policy or compliance domains, fresh content is usually drafts or commentary, and authorship + cross-reference graph keep the canonical document in the top rank. The system gets recency *for free*, in the places where recency is actually a signal.

## Routing by expertise, not by keywords

The other consequence of an authority graph is that the retrieval pipeline can route a question to the right *expertise* without depending on keyword overlap with the source content. Ask "who should I escalate a P0 in payments to?" and the pipeline doesn't need the words "escalate" or "P0" to appear in any document — it needs to know who has authoritative ownership in `engineering.payments` and `oncall.incident-management`, and surface their recent guidance.

This is what the homepage means when it says Quelvio routes by expertise. The taxonomy graph tells the pipeline which domains a question lives in; the authorship graph tells it whose voice carries in those domains; the cross-reference graph tells it which of that voice's contributions are currently canonical. Three graphs, one ranker, every query.

> **What's next** The authority scoring service is one of the load-bearing pieces of Quelvio Brain — there is a longer technical note on the supersession detection layer coming separately. If you want to see the score for an individual chunk on a query you already ran, `quelvio source <query-id>` now prints the per-chunk authority value in v0.3.0.

Tags: Retrieval, Authority ranking, Engineering

## Related

- [Human view of this page](https://quelvio.com/blog/how-quelvio-ranks-authority)
- [All posts (machine view)](https://quelvio.com/ai/blog)
- [Everything for agents: llms.txt](https://quelvio.com/llms.txt)


<!-- Page: https://quelvio.com/blog/scattered-drive-to-single-brain · Markdown: https://quelvio.com/blog/scattered-drive-to-single-brain.md -->

# From scattered Drive to a single brain in 48 hours

Blog · Human page: https://quelvio.com/blog/scattered-drive-to-single-brain · Machine view: https://quelvio.com/ai/blog/scattered-drive-to-single-brain

May 12, 2026 · Product · 6 min read

What the connector setup actually does in the background — and why most companies are surprised by the coverage map.

A 500-person company we onboarded last quarter expected the same thing every customer expects on day one — connect Google Drive, connect Notion, connect Slack, and the system starts answering questions. They were not wrong. What surprised them was what showed up on the coverage map 48 hours later.

Their `engineering.platform` domain showed strong coverage. Their `customer-support.refunds` domain showed strong coverage. Their `legal.contracts` domain showed almost nothing, despite a Drive folder with 1,400 contracts in it. Their `product.roadmap` domain showed a fractured shape — half the canonical content was in Notion, half had migrated to a Confluence space someone had set up six months ago and never told anyone about. A senior product lead saw the coverage map and said *"I knew that, but I forgot I knew."*

This is what the 48-hour setup actually delivers. The connectors are the easy part. The coverage map is the part that changes the conversation.

## What happens during the 48 hours

Once a connector is authorized, Quelvio runs through five passes on the source corpus, each one writing into the same brain but solving a different problem.

**Ingestion.** Documents are pulled with permissions intact. Every document carries its source ACL, the contributor identity, and the lifecycle metadata the source provides — last edit, last comment, retention policy if any. The ingestion layer never strips permissions; downstream retrieval inherits them.

**Extraction.** Each document is parsed by format-aware extractors. PDFs go through layout-aware OCR. Slides extract title, body, and notes separately. Meetings come in as the transcripts that Teams, Zoom or Meet already produce; Quelvio reads them and doesn't transcribe audio itself. Spreadsheets extract sheet-level structure, not just cell text. The output is a normalized, semantically structured representation of the document — not just a text blob.

**Embedding.** Each document is split into meaning-based passages, not fixed-size chunks. Section boundaries, semantic shifts, and natural paragraph breaks drive the chunking. Each passage gets a vector that captures *what it means*, not the words it contains. This is why a question phrased with completely different vocabulary can still find the right passage.

**Classification.** Every passage is routed into the taxonomy — the per-tenant domain graph that organizes content by what it's about. Classification draws on the passage content, the document's location in the source, the contributor's domain history, and cross-references to other documents already classified. The output is a per-passage taxonomy assignment with a confidence score.

**Cross-reference resolution.** This is the slowest of the five passes and the one that produces the surprising coverage map. The graph builder walks every passage and looks for relationships — does this passage agree with, disagree with, supersede, or reference another passage in the corpus? Supersession is detected by comparing claims in the same domain across time, with the authorship graph weighing in. Disagreement gets surfaced rather than averaged away.

## Why the coverage map is the surprising part

Every company we have onboarded sees three predictable patterns on the coverage map in the first week.

The first is **ghost domains**: areas of the business where the team knows knowledge exists but the corpus carries almost nothing. Sometimes this is because the knowledge lives in heads, sometimes it lives in Loom recordings that nobody connected, sometimes it lives in a private channel that the integration wasn't authorized for. The coverage map makes the gap visible.

The second is **fractured canon**: two or more sources both treated as authoritative, with content that contradicts each other. The classic case is a Confluence space and a Notion workspace that both claim to be the current architecture reference. Quelvio detects the contradiction during cross-reference resolution and flags it; humans then decide which one is canonical.

The third is **silent supersession**: a Slack decision, an updated runbook, or a new spec quietly replaced what was previously canonical, but the old document was never marked stale. The graph picks this up and updates the authority ranking — the old document still exists, it just no longer ranks first. Engineers seeing this for the first time usually identify three or four documents they didn't realize were dead.

## Why this matters more than connector count

Most knowledge-tools onboarding stories optimize for breadth — how many connectors did you add, how many documents indexed, how much storage. The coverage map reframes the question. Indexing 10 million documents is not the goal; understanding which of them are still load-bearing on which topics is. A corpus where 2,000 documents carry 80% of the answers for 80% of real queries is in better shape than one where 10 million documents are indexed but the authority signals haven't been built yet.

The 48-hour setup is when the brain becomes useful, not just connected. The connectors get you to the raw material; the five passes turn it into something an agent can reason over.

> **If you've already connected** The coverage map lives at `enterprise.quelvio.com/coverage` — open it and look for the three patterns above. Most teams find at least one fractured-canon case in the first session, and addressing it is usually the highest-leverage move available on day one.

Tags: Onboarding, Connectors, Coverage

## Related

- [Human view of this page](https://quelvio.com/blog/scattered-drive-to-single-brain)
- [All posts (machine view)](https://quelvio.com/ai/blog)
- [Everything for agents: llms.txt](https://quelvio.com/llms.txt)


<!-- Page: https://quelvio.com/blog/why-mcp-isnt-enough · Markdown: https://quelvio.com/blog/why-mcp-isnt-enough.md -->

# Why MCP isn't enough on its own

Blog · Human page: https://quelvio.com/blog/why-mcp-isnt-enough · Machine view: https://quelvio.com/ai/blog/why-mcp-isnt-enough

May 6, 2026 · Industry · 5 min read

Model Context Protocol gives agents a way to retrieve. It doesn't give them a context layer. We explain the gap.

Model Context Protocol is the right answer to a real problem. Before MCP, every AI agent had a bespoke integration story — a different way to discover tools, a different way to handle auth, a different way to format the tool result. MCP gave the ecosystem a uniform contract. Hosts that speak MCP can plug into any server that speaks MCP. That is genuinely useful, and it is why we ship an MCP server alongside everything else.

MCP is not a context layer, though. It is a *retrieval interface*. The difference is the part the industry is still working out.

## What MCP solves

MCP standardizes three things: how an agent discovers what tools are available on a server, how it calls them with structured arguments, and how results come back. The server runtime handles transport, auth, and capability negotiation. The agent doesn't need to know that the server is implemented in Python or Rust, doesn't need to know that the underlying data store is Postgres or a vector DB, doesn't need a bespoke client library. That uniformity is what makes Claude Desktop, Cursor, and a dozen other clients able to plug into the same MCP server without writing custom integrations.

When an agent talks to a Quelvio MCP server, it gets the same retrieval pipeline that the CLI, the REST API, the Slack bot, and the dashboard talk to. The agent calls `query`, the server returns a synthesized, cited answer, and the agent presents it. From the agent's side, the integration is genuinely a configuration change.

## What MCP doesn't solve

MCP says nothing about what comes back. *Whether* the result is authoritative, *whether* the source is current, *whether* the corpus carried enough signal to answer at all — these are problems the server has to solve before MCP can carry the response. A bad context layer behind a perfectly compliant MCP server still produces bad answers, with a clean transport.

Consider what "retrieval" means by default on top of a vector database. The agent asks a question; the server embeds the question; the database returns the top-k closest vectors; the agent quotes them. There is no concept of authorship — every document is treated as an equally valid source. There is no concept of lifecycle — a 2024 draft has the same retrieval score as the 2026 canonical version, provided their embeddings are equally close to the query. There is no concept of supersession — when one document quietly replaces another, the system has no signal that anything changed. There is no concept of refusal — when the corpus carries weak signal, the system synthesizes a plausible-sounding answer anyway.

None of these are MCP's problem to solve. MCP carried the request and the response faithfully. The server just didn't have the architecture to give the response any of the properties that would make it trustworthy.

## What a context layer adds

What we mean by a *context layer* is the set of architectural commitments a knowledge system makes before MCP ever enters the picture. The minimum credible list is roughly four items.

**Authority modeled per contributor per domain.** Not every source is equally credible on every topic. The engineer who shipped the payment system outweighs the CTO on payment edge cases; the CEO outweighs both on strategy. The system has to know whose voice carries on which domain, learned from contribution history rather than assigned by job title.

**Lifecycle states modeled as first-class.** Drafts, canonical documents, superseded memos, and deprecated runbooks are different categories. Stale content gets demoted; supersession is surfaced rather than averaged away. The retrieval result includes the lifecycle label, not just the text.

**Cross-reference resolution.** When one document quietly replaces another, the system detects that and updates the rank. When two sources contradict, the system surfaces the disagreement rather than picking silently. The corpus has structure beyond "a pile of vectors."

**Refusal on weak context.** When the corpus genuinely does not carry the answer, the system says so. Confidently-wrong is a bug we treat as a bug, not a UX edge case to paper over.

## MCP for access; context for reasoning

The right way to think about MCP is that it is the access layer — uniform, well-specified, ecosystem-wide. The context layer sits underneath and decides what the access layer is allowed to return. Quelvio ships both: the MCP server gives any compliant host a way in, and the brain behind it makes sure what comes out has been ranked, lifecycle-labeled, cross-referenced, and refused-when-weak before MCP carries it back to the agent.

MCP without a context layer is a faster, cleaner way to ship the same problems a vector database alone shipped two years ago. Context layer without MCP is a knowledge system that's hard to integrate. The combination is what an agent actually needs.

Tags: MCP, Context, Agents

## Related

- [Human view of this page](https://quelvio.com/blog/why-mcp-isnt-enough)
- [All posts (machine view)](https://quelvio.com/ai/blog)
- [Everything for agents: llms.txt](https://quelvio.com/llms.txt)


<!-- Page: https://quelvio.com/blog/cross-reference-graphs-supersession · Markdown: https://quelvio.com/blog/cross-reference-graphs-supersession.md -->

# Cross-reference graphs and the supersession problem

Blog · Human page: https://quelvio.com/blog/cross-reference-graphs-supersession · Machine view: https://quelvio.com/ai/blog/cross-reference-graphs-supersession

April 28, 2026 · Engineering · 7 min read

How we detect when a Notion page silently replaces a Confluence one — and which signal wins.

The hardest version of the retrieval problem is not what to return — it is what to demote without anyone telling you to demote it. A Confluence page describing the company's deployment process was written in 2023. In late 2025, someone wrote a Notion doc that quietly replaced it. Nobody marked the Confluence page deprecated. Nobody emailed the team. The new doc just started getting linked from runbooks, referenced in Slack threads, and updated as the actual canonical source. Six months later, an agent retrieving the old Confluence page is confidently wrong about how the company deploys.

This is the supersession problem, and it is everywhere. Most large companies' canonical knowledge is shaped by silent supersession events that the source systems do not record. Solving it is what the cross-reference graph layer of Quelvio Brain exists to do.

## What the graph stores

Each passage in the corpus — the meaning-based chunk unit, not the document — is a node in the cross-reference graph. Edges between nodes are typed. The four types we care about are *agreement*, *disagreement*, *reference*, and *supersession*.

An **agreement** edge says two passages make claims that are consistent. A **disagreement** edge says two passages make claims that conflict. A **reference** edge says one passage explicitly cites another — by URL, by document name, or by canonical identifier inside the source system. A **supersession** edge is the strongest: passage B replaces passage A in the role of canonical claim on a topic.

The first three edges are relatively easy to identify. Agreement and disagreement fall out of a classifier comparing claims in matched domains. References are surfaced by parsing URLs, link blocks, and source-system identifiers — every wiki has its own link syntax, and the ingestion layer normalizes them. Supersession is the one that takes work.

## How supersession is detected

Supersession is rarely declared. The original document is not edited. The new document does not announce itself as the replacement. The system has to infer the edge from three independent signals.

**Signal one — claim divergence in the same domain.** Two passages in the same taxonomy domain make contradictory claims about the same underlying behavior. The newer one is a supersession candidate. Just being newer is not enough — drafts, opinions, and side experiments are also newer. Claim divergence is necessary but not sufficient.

**Signal two — authority concentration on the newer source.** The contributors to the newer passage, weighted by their domain authority, are the ones with current ownership of the topic. The contributors to the older passage may have moved on, or may be reviewers rather than owners. When the authorship graph for the topic has shifted toward the newer source, that's a supersession signal.

**Signal three — link decay around the older source.** The number of inbound references to the older passage from other passages in the corpus is decreasing over time; the number of inbound references to the newer passage is increasing. Other authors in the corpus are voting with their links. This is the slowest signal to develop but the most reliable one when it does.

When all three signals point the same direction with high enough confidence, the graph builder writes a supersession edge from old → new. The older passage's authority score drops sharply; the newer one accumulates the canonical role. Retrieval results from that point forward return the newer source first, with the older one labeled `SUPERSEDED` and accessible via `--include-superseded`.

## What this looks like in practice

Take the Confluence-to-Notion case. Around the time the Notion page was written, all three signals start moving. Claim divergence appears — the deployment steps in the Notion page differ in material ways from the Confluence page. The engineer who wrote the Notion page has higher current authority in `engineering.deploys` than the original Confluence author, who shipped that document and moved to a different team. And over six months, the number of Slack messages and code-comment links pointing to the new Notion doc steadily climbs while inbound references to the Confluence page flatten.

By the time anyone explicitly asks the brain *"what's our deployment process?"*, the graph has already written the supersession edge. The retrieval result returns the Notion content first. The Confluence page is still in the corpus — sometimes the historical view matters — but it ranks below the canonical version and carries the lifecycle label that says so.

## Why this can't be solved at the source level

The natural objection is *"shouldn't this be solved by the source systems themselves?"* The honest answer is that source systems have never been able to solve it, and probably never will. Confluence does not know about your Notion. Notion does not know about your Drive. Your wiki cannot mark itself superseded by content in a different tool. The act of supersession crosses the source boundary, which is exactly why it is invisible to any one source's UI.

Cross-source supersession is a property of the *combined* corpus, not of any individual document. It can only be solved at the layer that sees the whole corpus at once. That layer is the brain.

> **Inspecting the graph** If you want to see which supersession edges have been written for a recent query, `quelvio source <query-id>` prints lifecycle labels in v0.3.0. The full per-passage graph view ships in the next Brain release — it's the most-requested thing on the dashboard roadmap right now.

Tags: Retrieval, Supersession, Graphs

## Related

- [Human view of this page](https://quelvio.com/blog/cross-reference-graphs-supersession)
- [All posts (machine view)](https://quelvio.com/ai/blog)
- [Everything for agents: llms.txt](https://quelvio.com/llms.txt)


<!-- Page: https://quelvio.com/blog/authority-decay · Markdown: https://quelvio.com/blog/authority-decay.md -->

# Authority decay: how knowledge ages inside a company

Blog · Human page: https://quelvio.com/blog/authority-decay · Machine view: https://quelvio.com/ai/blog/authority-decay

April 21, 2026 · Research · 9 min read

Patterns we see across the customer corpora Quelvio indexes — how engineering knowledge loses authority over 18 months, and what restores it.

When a document is written and shipped as the canonical reference on a topic, its authority score peaks in roughly the first month. After that, what happens to it depends almost entirely on what the rest of the corpus does, not on the document itself. Most documents stay untouched after publish — that's the baseline. The question we keep asking, looking at indexed customer corpora over time, is: what does an untouched canonical document's authority look like 6, 12, and 18 months later?

What we see in the data is a consistent shape across engineering and product corpora, with one important variable — what happens *around* the document. The decay curve isn't a property of the document. It's a property of the corpus.

## The shape of the curve

An untouched engineering document with reasonable initial authority shows three distinct phases as it ages.

**Months 0–3 — peak.** Authority is at its highest. Recent claims tend to be referenced often, the contributors are still active in the domain, and competing documents haven't accumulated. The decay rate during this window is essentially flat.

**Months 3–9 — slow drift.** Authority erodes at a measurable but moderate rate. The domain has moved on slightly; some claims in the document are no longer the team's current view. Inbound references plateau. New documents in the same domain start to appear, but no individual one has yet displaced the original.

**Months 9–18 — the cliff.** This is the phase that surprises most customers when we show it to them. Authority falls off sharply, not gradually. Almost always, this cliff coincides with a specific event in the corpus — a new document was written by an active owner, a claim divergence was detected, or a Slack thread quietly took on the canonical role. The cliff is not the document aging; it is the corpus electing a different authority in the same domain.

## What accelerates decay

Three patterns in the surrounding corpus reliably accelerate authority decay for an unrelated, untouched document.

**Owner turnover.** When the contributor who shipped a document leaves the company or moves out of the domain, the document's authority starts compounding downward over the next two quarters even if nothing else changes. The system is correct to do this — company knowledge attached to a person who is no longer accountable for the topic is genuinely lower-confidence than knowledge attached to a current owner. The decay rate roughly doubles in the six months following a clear ownership handoff.

**Domain churn.** Some domains move faster than others. In engineering corpora, infrastructure and platform domains tend to be high-churn — new tools, new providers, new architectural decisions every quarter. Authority decays roughly 2–3× faster in high-churn domains than in stable ones. This is why two documents shipped on the same day can have very different authority profiles a year later, depending on which domain they live in.

**Silent supersession.** A new document writing about the same topic with current ownership and divergent claims drives the steepest decay. This is the *cliff* event in the curve above. When it happens, the older document's authority can drop by half within a month. The corpus has elected a new authority on the topic, and the cross-reference graph picks it up almost immediately.

## What restores authority

Authority decay is not one-way. Three actions reliably restore authority on a document that has fallen behind.

**Re-attribution by an active owner.** When a current domain owner edits, comments on, or explicitly endorses an older document, authority recovers measurably. The amount of recovery is roughly proportional to the editor's current domain authority. This is what makes the system stable rather than ratcheting downward — a senior owner stepping in and saying *"this is still right"* restores canonical status.

**Inbound reference activity.** When other documents in the corpus start linking back to an older document — especially documents written by active domain owners — authority recovers. The system reads inbound references as votes, weighted by the author's current authority.

**Explicit lifecycle marking.** When a tenant administrator marks a document as canonical in the dashboard, the lifecycle label overrides the natural decay. We expose this in the dashboard precisely because there are documents — security policies, retention rules, compliance baselines — whose authority should not be subject to the corpus's churn. The system respects the explicit marking but still records the implicit signals in the background, so the administrator can see when the corpus is starting to disagree with the override.

## Why this matters for retrieval

Authority decay is not just an interesting curve. It is the load-bearing reason a retrieval system can return *the current view* rather than *whatever was indexed first*. Without modeling decay, every retrieval pipeline gradually drifts toward returning the documents that ranked highly when they were first added — even after the corpus around them has moved on.

The version of the cliff event that hurts most in production is the slow-deploy case. A 2024 deployment runbook had high authority for nine months and then quietly lost it to a Slack thread in early 2026. The runbook is still in the corpus, still indexed, still ranks well on keyword overlap. An agent retrieving "deployment process" without authority decay returns the 2024 runbook, confidently. An agent with authority decay returns the Slack thread, with the runbook labeled `SUPERSEDED` and one-click-away for the reader who wants the historical view.

Modeling decay is what lets the system maintain *what's currently true* over the long arc of a company's evolution, not just *what was true when we indexed it.*

> **Looking at your own curves** The authority-decay view is on the dashboard roadmap for the next Brain release. Until then, customers can see per-document authority by running `quelvio source <query-id>` in v0.3.0 — every chunk in the result prints its current authority value alongside its lifecycle label.

Tags: Authority, Decay, Research

## Related

- [Human view of this page](https://quelvio.com/blog/authority-decay)
- [All posts (machine view)](https://quelvio.com/ai/blog)
- [Everything for agents: llms.txt](https://quelvio.com/llms.txt)


<!-- Page: https://quelvio.com/blog/permission-aware-retrieval · Markdown: https://quelvio.com/blog/permission-aware-retrieval.md -->

# Permission-aware retrieval, explained

Blog · Human page: https://quelvio.com/blog/permission-aware-retrieval · Machine view: https://quelvio.com/ai/blog/permission-aware-retrieval

April 7, 2026 · Product · 6 min read

Every employee only sees results from documents they already had access to. Here's the mechanics behind enforcing it at the vector level.

There is a category of knowledge-tool bug that nobody catches in the demo and everybody catches in the third week of production. An engineer asks the assistant for a summary of last quarter's compensation review. The assistant happily produces it, citing a Google Drive document the engineer was never given access to in the source system. The assistant did not steal anything; it just retrieved the document and synthesized over it because, from the retrieval pipeline's point of view, all documents in the index are equally retrievable. Permissions were a problem the source system enforced. Once the document landed in the index, that enforcement was gone.

Permission-aware retrieval is the architectural commitment that this cannot happen — that every query in the system is filtered against the requesting user's actual permissions in the source systems, at retrieval time, before any chunks reach the synthesis layer. We enforce it at the vector level. This post is what that means and how it works.

## What "at the vector level" means

Most retrieval pipelines treat permissions as a post-processing filter. Retrieve top-k vectors first; then check whether the user has access to each one; then drop the disallowed ones. This is fast and almost always wrong. If the user has access to 1% of the corpus, top-k retrieval will overwhelmingly return chunks the user can't see — and the filter discards them — leaving the result thin or empty. Worse, the filter can leak metadata: an empty result tells the attacker that *some* chunk near their query exists, just not one they can see.

Enforcing permissions at the vector level means the access predicate is pushed into the retrieval query itself. The vector database executes a search constrained to the subset of vectors the requesting user has access to. The top-k operates over the *allowed* subset, not over the whole corpus. The chunks that come back are guaranteed to be retrievable by this user; the result is not thin, and no metadata leaks about chunks the user couldn't see.

## Where the access predicate comes from

Every chunk in the index carries an ACL inherited from the source document. When Quelvio ingests a Drive document, it reads Drive's permission state — which users and groups have view access, which are explicitly denied, which inherit from the parent folder — and stores that ACL alongside the vector. Same for SharePoint, Confluence, Notion, Slack channels, and every other connector. The ACLs are stored in normalized form so the retrieval query can join against them efficiently.

When a user authenticates with their Personal Access Token (or via OAuth), the request carries their identity. The retrieval pipeline resolves that identity against the tenant's identity graph — which groups they belong to, which roles they hold — and assembles a *current* permission set for the query. This is not cached aggressively; permission changes in the source systems propagate within minutes, because a stale permission set is exactly the failure mode this whole layer exists to prevent.

The vector search is then constrained: return the top-k chunks where the chunk ACL intersects the user's current permission set. The database does this in a single pass.

## What this rules out

**Cross-employee leakage.** An employee querying the brain cannot, by construction, retrieve a chunk from a document they were not allowed to see in the source system. The permission enforcement is the same enforcement Drive or Confluence would apply — just executed at the moment of retrieval rather than at the moment of source-system access.

**Stale-permission leakage.** When access is revoked in the source system, the change propagates to Quelvio's permission cache within minutes. A document the user could see yesterday but cannot see today will not appear in today's retrieval. The propagation lag is bounded and measurable, and we expose the lag on the dashboard so administrators can confirm the layer is current.

**Inference leaks.** Because the vector search runs only over the user's allowed subset, an empty result is genuinely an empty result. It does not tell the user that a near-match exists in some restricted corner they can't see. Permission enforcement happens before any signal leaves the database.

## What this means in practice

Two queries, two users, the same brain. The CFO asking *"what are the company's largest contracts this quarter?"* gets answers grounded in actual contract documents and the Q4 finance review. The engineer asking the same question gets a refusal — the corpus does have the answer, but not in any chunks this engineer has access to. The refusal is honest: it does not say *"the corpus does not contain this"*, which would be a lie; it says *"the corpus does not contain this for you"*, which is the truth.

Permission-aware retrieval is not a feature the user sees, unless they go looking. It is a load-bearing property of the system that you would notice immediately if it ever failed — the system would start leaking, and trust would not recover. Building it at the vector level rather than as a filter is the difference between a property the system can guarantee and a behavior it tries to remember.

> **Auditing your tenant** Every retrieval is logged with the requesting identity, the ACL set used, and the chunks returned. Administrators can audit the trail at `enterprise.quelvio.com/audit`. If you suspect a stale-permission event, the audit log will show the ACL the retrieval used and when it was last refreshed from the source system.

Tags: Permissions, Security, Retrieval

## Related

- [Human view of this page](https://quelvio.com/blog/permission-aware-retrieval)
- [All posts (machine view)](https://quelvio.com/ai/blog)
- [Everything for agents: llms.txt](https://quelvio.com/llms.txt)


<!-- Page: https://quelvio.com/privacy · Markdown: https://quelvio.com/privacy.md -->

# Privacy Policy

Human page: https://quelvio.com/privacy · Machine view: https://quelvio.com/ai/privacy

Last updated: 2 November 2026

Quelvio is an enterprise knowledge platform that lets organisations search and synthesise answers across their connected work systems — Google Drive, SharePoint, Confluence, Slack, Notion, and others — with cited responses, lifecycle awareness, and refusal-on-weak-context.

Quelvio is operated by Rolle Ltd, a company registered in England and Wales.

This Privacy Policy describes how we collect, use, store, and protect personal data when you and your organisation use the Quelvio service ("Service") at quelvio.com and connected interfaces. We are the data controller for personal data we collect from website visitors and account holders, and the data processor for content your organisation chooses to connect to the Service.

If you have questions about this policy or your data, contact [q@quelvio.com](mailto:q@quelvio.com).

## 1. Who we are

Rolle Ltd, operating the Quelvio service  
Company Number: 14560691 (registered in England and Wales)  
Registered office: 71–75 Shelton Street, Covent Garden, London WC2H 9JQ, United Kingdom

Data Protection Contact: Antonis Papathanasopoulos  
Email: [q@quelvio.com](mailto:q@quelvio.com)

## 2. Scope of this policy

This policy applies to:

- Visitors to quelvio.com and our marketing pages
- Account holders authenticating through Quelvio
- Employees of customer organisations using Quelvio through any interface — web dashboard, MCP server, browser extension, or future integrations
- Third parties whose personal data appears in content your organisation connects to Quelvio

It does not apply to data your organisation processes within its own connected sources (Google Drive, SharePoint, Confluence, Slack, Notion, etc.). For that data, your organisation is the controller and Quelvio is the processor — terms governed by your subscription agreement and any Data Processing Agreement.

## 3. Data we collect

We collect three categories of data.

### 3.1 Account data

Provided when you sign up or log in:

- Email address, name, and (where applicable) profile information from your single sign-on provider
- Organisation name and your role within it
- Authentication tokens and session metadata

### 3.2 Content data

Submitted by your organisation when connecting knowledge sources:

- Document text, attachments, embedded images, and meeting transcripts
- Source metadata (file paths, authorship, timestamps, permission lists)
- Derived representations: extracted text, semantic chunks, vector embeddings, classification labels, cross-reference relationships

We do not browse, index, or store content from sources your organisation has not explicitly connected.

### 3.3 Usage data

Generated when you interact with the Service:

- Queries you submit and responses returned, including cited sources
- Usage counted against your plan: pages read, by source, and agent runs
- Audit log entries (who queried what, when, from which interface)
- Telemetry: page views, feature usage, error reports, performance metrics
- IP address, browser type, device type, approximate location (country level)

## 4. How we use your data

We process personal data on the following legal bases under UK GDPR Article 6:

| Purpose | Legal basis |
| --- | --- |
| Operating the Service (authentication, query processing, billing) | Contract performance |
| Securing the Service against fraud, abuse, and unauthorised access | Legitimate interests |
| Improving the Service through aggregated analytics | Legitimate interests |
| Communicating with account holders about service updates and incidents | Legitimate interests |
| Complying with legal obligations (tax, audit, lawful requests) | Legal obligation |
| Marketing communications to existing customers about related products | Legitimate interests (you may opt out at any time) |

We do not use customer content to train AI models. We do not sell, rent, or share customer data with third parties for marketing.

## 5. Third-party content sources (connectors)

When you authorise Quelvio to connect to a third-party platform such as Google Drive, SharePoint, Box, Dropbox, Notion, Confluence, Slack, Microsoft Teams, or an AWS S3 bucket you control, you grant Quelvio permission to read content from that platform via its OAuth, API, or — in the case of S3 — a customer-controlled IAM role. Our access follows three principles:

**Read-only.** Every connector requests read-only OAuth scopes (or, for S3, a read-only IAM role). Quelvio cannot create, modify, or delete content in your connected source systems.

**Least privilege.** We request only the scopes necessary to index content. We do not request access to user profile data, calendar events, messages outside indexed channels, or administrative functions we do not use.

**Revocable by you.** You can revoke Quelvio's access at any time from the source platform's administrative settings (or by removing the IAM role, in the case of S3). Upon revocation or disconnection, we stop syncing new content and delete the indexed content from our systems within 30 days.

For S3 connections, the customer controls the IAM trust policy that grants Quelvio cross-account access. Quelvio does not have standing access to any S3 bucket without an explicit IAM trust relationship configured by the customer.

Use of information retrieved from Google APIs by Quelvio adheres to the Google API Services User Data Policy, including the Limited Use requirements.

## 6. Subprocessors

We use the following third-party processors to operate the Service. Each is bound by a data processing agreement and contractually committed to security standards equivalent to those described in this policy.

### 6.1 Infrastructure

| Subprocessor | Purpose | Region |
| --- | --- | --- |
| Cloudflare | Edge hosting for the MCP server, CDN, DDoS protection | Global edge network |

Where Quelvio's servers process your documents is set when Quelvio's service is hosted; it will be named here.

### 6.2 AI and machine learning

| Subprocessor | Purpose | Region |
| --- | --- | --- |
| Voyage AI | Search and ranking: text and multimodal embeddings, and reranking | United States |
| Alibaba Cloud (Model Studio, International site) | Text proposals by Qwen models | EU scope (Frankfurt) or US scope (Virginia) |
| Typesafe (Jev) | Classifies text: chooses among fixed options to check and organise what Quelvio reads | United States |

Typesafe (Jev) classifies the text sent to it, in the United States, as our processor under its data processing agreement. Its terms set no fixed retention period. It does not use that text to train its models without consent, but may use statistics and learnings derived from it to improve its service.

**Models run through Quelvio:** text proposals are made by Qwen models on Alibaba Cloud Model Studio, in Alibaba Cloud's EU deployment scope (Frankfurt) for organisations in the European Union, its US deployment scope (Virginia) for those in the United States, and, for organisations elsewhere, whichever of the two they choose (EU unless they choose otherwise). Alibaba Cloud keeps prompts and responses for no longer than 30 days, unless the law or the service's security requires longer, and may keep content flagged by its safety filters for up to 2 years. Under its terms, it does not use prompts and responses to develop or improve its models without separate consent, which Quelvio does not give.

**Models run in your own cloud:** if your organisation chooses to run models in its own Amazon Bedrock, Microsoft Azure AI Foundry or Google Cloud Vertex AI account, text proposals are made by the models you select there, inside your account and under your agreement with that provider. Quelvio calls them on your behalf and keeps no separate copy.

### 6.3 Authentication, billing, and operations

| Subprocessor | Purpose | Region |
| --- | --- | --- |
| Clerk | User authentication and single sign-on | United States |
| Stripe | Subscription billing and payments | Global |
| SendGrid | Transactional and notification email | United States |
| Supabase | Marketing waitlist and newsletter sign-ups | United States |

We update this list when we add or remove subprocessors. Material changes are announced to active customers at least 30 days before they take effect, where feasible.

## 7. International data transfers

On every plan, your content is stored only in your own storage. During setup, before you connect it, Quelvio keeps what it reads from your public website, your setup answers and corrections, and the first answer until you connect your storage, at most 14 days, then moves them there and deletes them here; backup copies are cleared within 7 more days. However, some processing — specifically embedding generation, large language model inference, authentication, billing, and email delivery — may occur outside the European Economic Area, including in the United States.

For any transfer of personal data outside the United Kingdom or European Economic Area, we rely on:

- The European Commission's Standard Contractual Clauses (SCCs) and the United Kingdom's International Data Transfer Addendum where applicable
- Each subprocessor's documented technical and organisational safeguards
- Adequacy decisions where they apply

You can request copies of our transfer mechanisms by emailing [q@quelvio.com](mailto:q@quelvio.com).

## 8. Data residency

- **Storage:** On every plan, your content is stored only in your own storage. During setup, before you connect it, Quelvio keeps what it reads from your public website, your setup answers and corrections, and the first answer until you connect your storage, at most 14 days, then moves them there and deletes them here; backup copies are cleared within 7 more days.
- **Processing:** queries may be routed to AI model providers in other jurisdictions for embedding generation and language model inference (see Section 6). The query content travels to those providers under SCCs.

## 9. Data retention

We retain personal data only as long as needed to operate the Service or comply with legal obligations.

| Data category | Retention period |
| --- | --- |
| Account data | Duration of the account; deleted within 30 days of account deletion |
| Content data (raw documents, chunks, embeddings) | Stored in your own storage, not kept by Quelvio |
| Content held during setup (what Quelvio reads from your public website, your setup answers and corrections, the first answer) | Until you connect your storage, at most 14 days; then moved there and deleted here. Backup copies are cleared within 7 more days |
| Audit logs and query logs | Up to 365 days |
| Billing records | Never-paid trials: only the email domain and trial dates, kept 2 years, so a domain gets one trial; everything else deleted. Paying customers: invoices and their billing records for the period invoicing law requires (up to 10 years) |
| Tenant data after tenant deletion | Complete purge within 30 days |

Backups are retained for up to 35 days after the underlying data is deleted, after which the backup itself is overwritten.

Deletion is propagated to subprocessors where technically feasible. Some subprocessors (notably AI providers that do not retain query content) require no deletion action because the data was never persisted. Typesafe (Jev) sets no fixed retention period, and Alibaba Cloud keeps prompts and responses for the periods in Section 6.2.

## 10. Your rights

If you are in the United Kingdom, European Economic Area, or another jurisdiction with data protection laws comparable to UK GDPR, you have the following rights:

- **Access** — request a copy of the personal data we hold about you
- **Rectification** — correct inaccurate or incomplete data
- **Erasure** — request deletion of your personal data ("right to be forgotten")
- **Restriction** — limit how we process your data
- **Portability** — receive your data in a structured, machine-readable format
- **Objection** — object to processing based on legitimate interests, including profiling
- **Withdraw consent** — where processing is based on consent, withdraw it at any time

If you are a California resident, you have parallel rights under the California Consumer Privacy Act (CCPA) and California Privacy Rights Act (CPRA), including the rights to know, delete, correct, opt out of sale or sharing (we do neither), and limit the use of sensitive personal information.

### How to exercise your rights

Most requests can be completed directly in your Quelvio account:

- **Access your data:** request a data export from your account profile
- **Delete your account:** use "Delete account" in your account settings — this triggers full deletion of your personal data and content within 30 days

For requests that cannot be completed in-app, or for inquiries about data processed about you by a customer organisation, email [q@quelvio.com](mailto:q@quelvio.com).

We respond to all rights requests within 30 days. Where a request is complex or we receive multiple requests from the same person, we may extend the response period by up to two additional months and will notify you of the extension within the initial 30-day window.

You also have the right to lodge a complaint with the UK Information Commissioner's Office (ICO) at [ico.org.uk](https://ico.org.uk) or your local data protection authority.

## 11. AI and automated processing

Quelvio uses artificial intelligence to provide its core service. We disclose the following so you can make informed decisions:

- **Embeddings:** when content is connected, we generate vector representations using third-party models (see Section 6.2). The original content travels to the embedding provider; the resulting vectors are stored in your own storage.
- **Meetings:** Quelvio doesn't transcribe audio or video. It reads the transcripts that Teams, Zoom or Meet already produce.
- **Synthesis:** when you request a synthesised answer, your query and retrieved source excerpts are sent to a large language model provider (see Section 6.2). The provider returns a response which Quelvio cites and returns to you.
- **No model training:** we do not use customer content to train, fine-tune, or otherwise improve any AI model — neither our own nor those of our subprocessors, except as Section 6.2 describes for Typesafe (Jev). Subprocessor agreements prohibit training on customer queries or content without consent, which Quelvio does not give.
- **No automated decision-making with legal effect:** Quelvio does not make decisions that produce legal or similarly significant effects about you using only automated processing. Quelvio is a knowledge retrieval and synthesis tool; downstream decisions are made by humans in your organisation.

## 12. How we protect your information

**Encryption.** Content is encrypted in transit (TLS 1.2+) and at rest (AES-256). Authentication tokens and OAuth credentials are stored in a dedicated secrets manager with per-tenant scoping.

**Tenant isolation.** Each customer's content lives in a separate logical namespace, enforced at every layer of the system — vector storage, database queries, retrieval pipeline, and audit logs. Cross-tenant access is not possible through the application layer.

**Access controls.** Quelvio personnel access to customer data is restricted, logged, and limited to debugging and support activities initiated at your request. Role-based access controls within customer organisations let administrators determine which employees can connect sources, run queries, or manage billing.

**Audit logging.** Administrative actions and content access events are logged with immutable timestamps. Customer administrators can review audit logs from their account.

**Vulnerability management.** We monitor dependencies for known vulnerabilities, apply security patches promptly, and conduct regular security reviews.

**Incident response.** If we become aware of a security incident affecting your personal data, we will notify you and the relevant supervisory authority in accordance with applicable law (typically within 72 hours of becoming aware of a notifiable breach).

No system is completely secure. The protections above represent the standard of care we commit to maintaining.

## 13. Children's privacy

Quelvio is a business-to-business service and not directed at children under 16. We do not knowingly collect personal data from children. If you become aware that a child has provided personal data to us, contact [q@quelvio.com](mailto:q@quelvio.com) and we will take steps to delete it.

## 14. Cookies and similar technologies

Quelvio uses cookies and similar technologies for the following purposes:

**Essential cookies.** Required for the Service to function. These authenticate your session, remember your sign-in state, protect against cross-site request forgery, and maintain security. You cannot opt out of essential cookies because the Service will not work without them.

**Analytics cookies.** Used to understand how the Service is used in aggregate — which features are accessed, where users encounter errors, how performance varies across regions. Analytics data is processed in a way that does not identify individual users.

We do not use advertising cookies, retargeting cookies, or third-party tracking pixels for marketing purposes.

You can control cookies through your browser settings — most browsers let you refuse, accept, or delete cookies on a per-site basis. Disabling essential cookies will prevent you from signing in or using authenticated features.

## 15. Changes to this policy

We may update this policy from time to time. Material changes — including new subprocessors, expanded data uses, or changed retention periods — will be communicated to active account holders by email and posted at the top of this page at least 30 days before they take effect, where feasible.

The "Last updated" date at the top of this page reflects the most recent revision.

## 16. Contact

For privacy questions, complaints, or to exercise your rights:

Email: [q@quelvio.com](mailto:q@quelvio.com)

Postal address:  
Rolle Ltd (Quelvio)  
71–75 Shelton Street, Covent Garden  
London WC2H 9JQ, United Kingdom

If we cannot resolve your concern, you have the right to contact the UK Information Commissioner's Office at [ico.org.uk](https://ico.org.uk) or your local data protection authority.

## Related

- [Human view of this page](https://quelvio.com/privacy)
- [Everything for agents: llms.txt](https://quelvio.com/llms.txt)


<!-- Page: https://quelvio.com/terms · Markdown: https://quelvio.com/terms.md -->

# Terms of Service

Human page: https://quelvio.com/terms · Machine view: https://quelvio.com/ai/terms

Last updated: 19 October 2026

These Terms of Service ("Terms") govern your access to and use of the Quelvio service ("Service") provided by Rolle Ltd, a company registered in England and Wales (company number 14560691), with registered office at 71–75 Shelton Street, Covent Garden, London WC2H 9JQ, United Kingdom ("Quelvio", "we", "us", "our").

By accessing or using the Service, you agree to be bound by these Terms. If you are entering into these Terms on behalf of an organisation, you represent that you have authority to bind that organisation, and "you" refers to that organisation.

If you do not agree to these Terms, do not use the Service.

## 1. The Service

Quelvio provides an enterprise knowledge platform that connects to your organisation's existing systems (such as Google Drive, SharePoint, Confluence, Slack, Notion, and other supported sources), indexes the content with authority and lifecycle awareness, and returns cited answers to natural-language queries. The Service is delivered as a hosted cloud application, with optional access through Model Context Protocol ("MCP") clients including Claude, Cursor, and similar AI assistants.

We may modify, suspend, or discontinue any part of the Service at any time, with reasonable notice for material changes as set out in Section 17.

## 2. Accounts and access

To use the Service, you must create an account or be invited to an organisation that has done so. You are responsible for:

- Maintaining the confidentiality of your account credentials and API keys
- All activity that occurs under your account
- Promptly notifying us of any unauthorised access at [q@quelvio.com](mailto:q@quelvio.com)

Each organisation ("Tenant") on the Service operates within an isolated environment. Cross-tenant access is structurally prevented.

We may suspend or terminate accounts that violate these Terms, present a security risk, or engage in fraudulent activity.

## 3. Acceptable use

You agree not to:

- Use the Service for any unlawful purpose or in violation of any applicable law
- Upload, index, or transmit content that infringes intellectual property rights, contains malware, or violates privacy rights of others
- Attempt to gain unauthorised access to the Service, other Tenants' data, or our infrastructure
- Reverse engineer, decompile, or attempt to derive source code of the Service except where permitted by law
- Use the Service to develop a competing product
- Exceed reasonable usage limits or attempt to circumvent rate limits
- Use the Service to generate content that violates applicable laws or these Terms

## 4. Your content and data

You retain all rights, title, and interest in the content you upload, connect, or generate through the Service ("Your Content"). You grant us a limited, non-exclusive licence to process Your Content solely for the purpose of providing the Service to you — including indexing, retrieval, embedding generation, and synthesis of cited answers.

We do not:

- Sell Your Content to third parties
- Use Your Content to train, fine-tune, or otherwise improve any AI model
- Access Your Content except as needed to provide and support the Service

You are responsible for ensuring you have the right to provide Your Content to the Service, including rights from any third parties whose content is contained within it.

## 5. Source system integrations

When you connect a third-party source (such as Google Drive or SharePoint), you authorise us to access that source according to the permissions you grant via OAuth or API credentials. We honour the access control rules of the underlying source system — content visible to a user in the source is the same content visible to that user through the Service.

We are not responsible for changes to third-party services, their availability, or modifications to their APIs.

## 6. Plans, allowances and prepaid packs

The Service is offered in plans, with current prices published at [https://quelvio.com/pricing](https://quelvio.com/pricing) and reflected in your account dashboard. Each plan includes a monthly allowance of:

- **Pages:** text Quelvio reads from your sources, counted in pages of 500 words after cleanup. Only new or changed text counts; unchanged content read again does not. The pricing page describes how pages are counted for each kind of source.
- **Agent runs:** calls from an agent or a scheduled report that return an answer, a memory, a rule check or source passages. Retries and errors do not count, and questions asked by people are not metered.

Use beyond the monthly allowance is drawn from prepaid page packs and run packs, bought in advance and valid for 12 months from purchase. Quelvio does not bill for use after the fact. When the allowance and all packs are used up, new reading waits until a pack is bought or the allowance renews, with nothing lost, and agents receive a "plan limit reached" reply. An owner may turn on automatic top-up, which buys a pack in advance when use reaches 90% of what is available; it is off by default.

If your organisation runs models in its own cloud account, that provider bills the model usage to you directly, under your agreement with it. Running models in your own cloud is offered on the Enterprise plan, and Quelvio's charges for it are set out in your order form.

Prices may be updated from time to time. Material price changes will be communicated with at least 7 days' notice via email or in-product notification. Continued use of the Service after a price change takes effect constitutes acceptance.

You agree to pay all charges for your Tenant. Plans are billed in advance, monthly or annually, as specified in your plan, and packs are paid for when bought.

## 7. Trial and developer sandbox

Quelvio does not offer a free plan. Instead:

- a 14-day trial, which starts with onboarding;
- a free developer sandbox for building and testing integrations, limited to 1 agent, 1,000 agent runs and 100 documents.

If a trial ends without a plan, the workspace becomes read-only for 30 days. During those days you can still export your data and buy a plan, and agents receive a "plan limit reached" reply. We send reminders 7 days and 1 day before the 30 days end. After that, the workspace and its data are deleted.

These limits may be adjusted from time to time with at least 7 days' notice. Current details are published at [https://quelvio.com/pricing](https://quelvio.com/pricing). Trial and sandbox data is subject to the same security, privacy and retention practices as data in paid plans.

## 8. Intellectual property

The Service, including all software, designs, documentation, and trademarks, is owned by Rolle Ltd or its licensors and is protected by intellectual property laws. We grant you a limited, non-exclusive, non-transferable licence to use the Service in accordance with these Terms.

Any feedback, suggestions, or ideas you provide about the Service may be used by us without restriction or compensation.

The Quelvio MCP server source code is published under the MIT license; usage of the Quelvio hosted service through the MCP server is governed by these Terms.

## 9. Confidentiality

Each party agrees to protect the other's confidential information with reasonable care and to use it only to perform obligations under these Terms. Confidential information does not include information that is publicly available, independently developed, or rightfully received from a third party without confidentiality obligations.

## 10. Privacy

Our handling of personal data is described in our Privacy Policy, which is incorporated into these Terms by reference. Where you process personal data through the Service as a data controller, we act as a data processor on your behalf. Data Processing Agreement availability, data export rights, retention timelines, sub-processors, and cross-border data transfer mechanisms are described in our Privacy Policy.

## 11. Security

We implement industry-standard administrative, technical, and physical safeguards to protect Your Content, including encryption in transit and at rest, tenant isolation, access controls, and audit logging. Detailed security measures are described in our Privacy Policy.

No system is perfectly secure. You acknowledge that no transmission over the internet or storage method is 100% secure.

If you become aware of a security incident affecting your account, contact us immediately at [q@quelvio.com](mailto:q@quelvio.com).

## 12. Third-party services

The Service integrates with third-party services (such as the source systems you connect, AI model providers we use to power synthesis, and infrastructure providers). Your use of those third-party services is governed by their own terms. Sub-processors are listed in our Privacy Policy. We are not responsible for third-party services' availability, performance, or content.

## 13. Warranties and disclaimers

The Service is provided "as is" and "as available". To the maximum extent permitted by law, we disclaim all warranties, whether express, implied, statutory, or otherwise, including warranties of merchantability, fitness for a particular purpose, and non-infringement.

We do not warrant that:

- The Service will be uninterrupted or error-free
- Defects will be corrected
- The Service or the servers that make it available are free of viruses or harmful components
- Search results, synthesised answers, or citations will be complete, accurate, or suitable for any particular purpose

You acknowledge that AI-generated content may contain errors, omissions, or biases. You are responsible for reviewing and verifying any output before relying on it.

## 14. Limitation of liability

To the maximum extent permitted by law, in no event will Rolle Ltd, its affiliates, officers, employees, agents, or licensors be liable for any indirect, incidental, special, consequential, or punitive damages, including loss of profits, data, use, goodwill, or other intangible losses, arising from or relating to your use of the Service.

Our total liability for any claim arising out of or relating to these Terms or the Service shall not exceed the total fees paid by you to us in the twelve months preceding the event giving rise to the claim. For trial and sandbox users who have not paid any fees, our total liability is limited to the maximum extent permitted by law.

Nothing in these Terms excludes or limits liability that cannot be excluded or limited under applicable law, including liability for death, personal injury caused by negligence, fraud, or fraudulent misrepresentation.

## 15. Indemnification

You agree to indemnify, defend, and hold harmless Rolle Ltd and its affiliates, officers, employees, agents, and licensors from and against any claims, damages, losses, liabilities, costs, and expenses (including reasonable legal fees) arising out of or relating to:

- Your use of the Service in violation of these Terms or applicable law
- Your Content
- Your violation of any third-party right

## 16. Term and termination

These Terms remain in effect while you use the Service. Either party may terminate:

- **For cause**, on notice if the other party materially breaches these Terms and fails to cure within 30 days
- **For convenience**, by closing your account or, where applicable, by giving notice in accordance with your plan

On termination:

- Your access to the Service ceases
- Your Content is retained and deleted in accordance with the retention periods described in our Privacy Policy
- Provisions that by their nature should survive (including intellectual property, confidentiality, limitations of liability, indemnification, and governing law) will survive

You may request data deletion at any time as described in our Privacy Policy.

## 17. Changes to these Terms

We may update these Terms from time to time. Material changes will be communicated by email or in-product notice at least 30 days before they take effect. Changes to prices are governed separately by Section 6 (at least 7 days' notice). Your continued use of the Service after changes take effect constitutes acceptance of the updated Terms.

## 18. Governing law and jurisdiction

These Terms are governed by the laws of England and Wales, without regard to conflict of law principles. Any dispute arising out of or relating to these Terms or the Service shall be subject to the exclusive jurisdiction of the courts of England and Wales, except that we may seek injunctive relief in any court of competent jurisdiction.

If you are a consumer based in the European Union, you may also have the right to bring proceedings in the courts of your country of residence under applicable consumer protection laws.

## 19. General

- **Entire agreement:** These Terms, together with our Privacy Policy and any order form or supplemental terms, constitute the entire agreement between you and us regarding the Service.
- **Assignment:** You may not assign these Terms without our prior written consent. We may assign these Terms in connection with a merger, acquisition, or sale of assets.
- **No waiver:** Our failure to enforce any provision does not constitute a waiver of that provision.
- **Severability:** If any provision is held unenforceable, the remaining provisions will continue in effect.
- **Notices:** Notices to us should be sent to [q@quelvio.com](mailto:q@quelvio.com). Notices to you may be sent to the email address on file for your account.
- **Force majeure:** Neither party is liable for delays or failures due to events beyond reasonable control, including natural disasters, war, terrorism, civil unrest, government action, labour disputes, or infrastructure failures affecting third-party providers.

## 20. Contact

For questions about these Terms, contact us at:

Rolle Ltd (operating Quelvio)  
Company number: 14560691  
Registered office: 71–75 Shelton Street, Covent Garden, London WC2H 9JQ, United Kingdom  
Email: [q@quelvio.com](mailto:q@quelvio.com)  
Website: [https://quelvio.com](https://quelvio.com)

These Terms apply to use of the Quelvio service. The Quelvio MCP server source code is separately licensed under the MIT license at [https://github.com/Quelvio/quelvio-platform](https://github.com/Quelvio/quelvio-platform).

## Related

- [Human view of this page](https://quelvio.com/terms)
- [Everything for agents: llms.txt](https://quelvio.com/llms.txt)