quelvio.com
human view ↗
---
title: Quelvio for AI agents · Quelvio docs
canonical: https://quelvio.com/docs/ai-agents
machine_url: https://quelvio.com/ai/docs/ai-agents
---

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

Docs · For 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](#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](/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](/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. 1.Install the CLI
    ```shnpm i -g @quelvio/cli
quelvio --version```
  2. 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):
    ```shexport QUELVIO_TOKEN=qlv_pat_<your-token>
quelvio whoami```
  3. 3.Install the skill — Drop the skill file into Claude Code's user-scoped skills directory:
    ```shmkdir -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. 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. 1.Open the integrations panel — Claude Desktop → Settings → Integrations → Add server.
  2. 2.Paste the server URL
    ```shhttps://mcp.quelvio.com/http```
  3. 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. 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](/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. 1.Add the server to ~/.cursor/mcp.json (or via Cursor settings UI)
    ```json{
  "mcpServers": {
    "quelvio": {
      "url": "https://mcp.quelvio.com/http"
    }
  }
}```
  2. 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. 1.Install the CLI and authenticate
    ```shnpm i -g @quelvio/cli
export QUELVIO_TOKEN=qlv_pat_<your-token>```
  2. 2.Install the Cursor rule
    ```shmkdir -p .cursor/rules
curl -fsSL https://raw.githubusercontent.com/Quelvio/quelvio-agent-skills/main/cursor/SKILL.md \
  -o .cursor/rules/quelvio.mdc```
  3. 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. 1.Install the CLI
    ```shnpm i -g @quelvio/cli
quelvio --version```
  2. 2.Authenticate
    ```shexport QUELVIO_TOKEN=qlv_pat_<your-token>
quelvio whoami```
  3. 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.
    ```shcurl -fsSL https://raw.githubusercontent.com/Quelvio/quelvio-agent-skills/main/codex/SKILL.md \
  -o AGENTS.md```
  4. 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 agentic 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. 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. 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. 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 →](/docs/integrations/llm-tool-definitions)

## What becomes possible

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

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

## Related