Turn scattered institutional knowledge into a retrievable, versioned graph. Point any LLM agent at your own endpoint and get answers grounded in your documents — with citations you can audit.
http://acme.knowledge.servicev8.com/v1Follow the named traffic through kv8. Hover a small dot to inspect its sample document. Drag a hub to reshape the network; click to pin. On touch, tap to explore or drag a hub to move.
Git, Confluence and Linear connect incident context to the on-call team through reviewed concepts.
Runbook + postmortem + issue history → grounded incident response.
Explore this use case below →Keyboard: Tab to a hub, N / Shift+N to browse sample nodes, arrow keys to move the hub, Escape to dismiss and release. Reset restores the network.
Most RAG products index everything and curate nothing. knowledgev8 treats your knowledge like source code — reviewed, versioned, and graph-linked — so answers stay trustworthy as the corpus grows.
Author knowledge as plain markdown with frontmatter. Documents promote from draft to reviewed to authoritative as your team signs off — agents cite governed answers, not raw uploads.
pgvector narrows a huge corpus to the few concepts that matter; long-context expansion then reads them whole — full body plus everything they link to — instead of stitching fragments.
Answers reference the concept ids they drew from. No black box — you can trace any statement back to the document it came from.
Bring your own OpenAI or Anthropic model keys at zero platform cost, or run on managed credits — with plan tiers that grow with your workspace. No lock-in to a single provider's assistant.
Every agent, every document, every question — scoped, masked, and logged the way your own team already expects.
Connect Claude Code or any MCP agent to your workspace. Access is scoped live, per request, to the permissions of the person behind it — never a standing service account with broader reach.
Uploaded documents are parsed, indexed into concepts, and discarded. There's no growing pile of raw files sitting on our side for anyone to breach.
Turn on masking before anything is stored — from fast pattern-based rules to LLM-assisted de-identification — so sensitive values never make it into a concept.
Every question is attributed to the person who asked it, every agent action is logged, and retention is a setting you control, not one we impose.
Sources sync themselves. Agents can contribute back. Nothing becomes truth without a person signing off.
Ten connectors — Google Drive, Confluence, Zendesk, Git, S3/MinIO, Notion, SharePoint, Linear, email, and web crawl — sync on a schedule, re-ingesting only what changed; direct upload covers everything else. Never a stale answer from a doc that moved months ago.
Any agent can say "remember this" and deposit new knowledge mid-conversation — reviewable and attributed, and never authoritative until a human approves it (except sources you explicitly mark as trusted authors).
Autonomous per-source agents monitor each connected source, flag drift, and propose updates on their own — drafts for your team to review, on a schedule you set.
When a source document changes, the concepts distilled from it are flagged and queued for re-curation — the graph tells you what's out of date before an agent cites it.
The graph is the foundation. On top of it: curated skills your agents can run, private per-member context, and an open format that keeps your knowledge portable.
Curated how-to skills live alongside your knowledge — agents discover the right one for the task, execute it, and feed improvements back for human review.
Each member gets a private context store their agents draw on — blended with team knowledge at answer time through three-tier retrieval: session, personal, and company brain.
Your whole knowledge base round-trips losslessly as OKF bundles, an open format any compatible tool can read. Leaving is a download, not a migration project.
S3/MinIO, Google Drive, Confluence, Zendesk, Notion, SharePoint, Linear, Git, email, and web crawl — or just upload a file. Everything lands in the same reviewed, cited graph.
Same endpoint, same citations, same curation lifecycle — each team just asks it different questions.
Claude Code, Cursor, or any MCP client queries your runbooks, ADRs, and API references directly — no more grepping the wiki and hoping it's current.
Incident runbooks, postmortems, and escalation paths — retrieved and cited the moment an on-call engineer needs them, not rediscovered during the post-mortem.
Battlecards, security questionnaires, and pricing policy — one query away, with a citation you can actually show the prospect.
Refund windows, escalation policy, macros — support agents and your support bot pull from the same graph, so the answer doesn't depend on who's on shift.
Raw documents stay in your object storage. A small, git-curated layer holds the concepts worth trusting. pgvector is just the rebuildable index over both — recall, not the system of record.
Your S3 / GCS bucket or a git repo. Binaries and originals never leave your storage — we hold pointers.
Curated OKF concepts, reviewed and graph-linked. Small by design — PRs and diffs make sense here.
pgvector ANN narrows the corpus to the few concepts that matter. Recall only — it never sees the final answer.
Full bodies plus one-hop linked neighbors go into context whole, then the model generates with citations.
A REST API and a first-class MCP server. Claude, Gemini CLI, LangChain, or a bare curl loop — one config block and your knowledge is a tool.
# Ask your knowledge base a question curl acme.knowledge.servicev8.com/v1/answer \ -H "Authorization: Bearer kv8_…" \ -d '{"question":"how do refunds work?"}' # → grounded answer + auditable sources { "answer": "Reverse the charge within the 30-day window [playbooks/refunds].", "citations": ["playbooks/refunds"], "sources": [{ "status": "authoritative" }] }