Documentation menu
Getting Started

Quickstart

One path, in order, that ends in a first win: your agent planning real work in your project and later recalling the decision by meaning. We use the reference stack — the ready-made, everything-wired-together bundle — with local embeddings, so you get going with no signup and nothing leaving your machine. Everything below is copy-paste.

Shortcut (recommended): let your AI do it. In Claude Code, ask: Read https://kvendra.dev/llms.txt and install and configure Kvendra for me. It runs every step below and checks each one — see what it does.

The recommended host is Claude Code, but anything that speaks the Model Context Protocol can drive Kvendra. Prefer to build it yourself, step by step — from source, or against your own Postgres? See Advanced install.

Don't want to run it yourself? Kvendra Cloud is the same open-core engine, hosted and managed for you — kvendra.com →

Already on the hosted service? Its setup guide is at app.kvendra.cloud/docs.

Prerequisites

You need Docker (Docker Desktop, or Colima on macOS; engine ≥ 20.10) with the daemon running, Docker Compose v2, git and curl. Check them in one go: 

docker --version          # Docker version 20.10+ (Desktop or Colima)
docker compose version    # Docker Compose version v2.x  (note: "compose", not "docker-compose")
docker info               # the daemon must be running
git --version
curl --version
  • Docker runs the engine and its database in isolated containers, so you do not install Postgres or Node on your host — docker.com/get-started.
  • Ollama runs an embedding model locally so nothing leaves your machine — ollama.com. The reference stack runs it for you as a container, so there is nothing to install separately.

What you're spinning up

A quick look from above. The reference stack brings up these containers, wired together on an internal network:

  • PostgreSQL 16 + pgvector — your knowledge base. Entities and their embedding vectors live in the same database.
  • The Kvendra Platform engine — the MCP server your agent talks to, on :7777.
  • A backup sidecar — a tiny container that takes scheduled database dumps.
  • Ollama — the local embeddings runtime, started by default (skip it with --no-ollama if you bring your own provider).

Want the details of what's in the stack? see it on GitHub.

1. Start the stack

Clone the reference stack somewhere outside your project and bring it up with local embeddings: 

git clone https://github.com/KvendraAI/kvendra-reference-stack
cd kvendra-reference-stack
./scripts/up.sh

The script creates .env on the first run, points the engine at the local Ollama embedding model (mxbai-embed-large), waits until the engine reports healthy and prints the bearer token you need in step 3. Check it any time: 

curl http://localhost:7777/healthz

First boot takes 60–90 seconds while pgvector initialises and the engine runs its migrations; the embedding model is a one-time, lightweight download.

Already run an embeddings service? Point the EMBEDDINGS_* lines of .env at your own OpenAI-compatible provider and start the stack with ./scripts/up.sh --no-ollama. The engine stores 1024-dimension vectors and does not request a size, so use a model that is natively 1024-d (for example mxbai-embed-large or bge-large-en-v1.5 on vLLM/TEI, or mistral-embed) or a gateway that pins the output to 1024. Pick one before you store knowledge: vectors from different providers do not mix, so switching later means re-embedding.

2. Install the Skills

Skills turn pipelines into one-command workflows. They install as a Claude Code plugin: 

/plugin marketplace add KvendraAI/kvendra-skills
/plugin install kvendra-skills@kvendra-marketplace

3. Connect Claude Code

From your project's folder, read the token out of the container and register the Platform as an MCP server named kvendra-platform: 

TOKEN=$(docker exec kvendra-ref-platform cat /data/auth.token)
claude mcp add --transport http kvendra-platform http://localhost:7777/mcp \
  -H "Authorization: Bearer $TOKEN"

The server is registered for that folder. Add --scope user to have it in all your projects.

Now restart Claude Code once — that activates both the plugin and the new server. Then verify: 

claude mcp list    # kvendra-platform: http://localhost:7777/mcp (HTTP) - ✔ Connected

and ask your agent: “call whoami on kvendra-platform”. A real answer means your agent has the 14 knowledge-base tools.

The plugin also comes with a server for the hosted service, kvendra-cloud. You do not need it for self-hosting: leave it signed out, or disable it for the project from /mcp. The skills then work against kvendra-platform, which serves the knowledge-base tools they use under a different server name. A few extras of the hosted service (such as export) are not part of the self-hosted engine.

Prefer to do every step yourself with full control — your own Postgres, building from source, other embedding providers? The whole manual path lives in Advanced install.

4. Onboard your project

You are connected — now give your agent the structure to work against. The natural next step is not generic: it is to onboard your own project into the knowledge base. Run it in your own repo — the reference stack is infrastructure, not your project: 

/kvendra-skills:onboard-project <PROJECT_ID>

It bootstraps the structure of your project in the KB — a project (PRJ) entity, its components, the shared glossary and standards (GLO/STD), and a canonical CLAUDE.md for the repo. It auto-detects that it is running against the local Platform you just brought up. It works for a brand-new project, and for a project that already exists you can map its pieces one at a time: 

/kvendra-skills:onboard-project add-component <name>

Precise scope: /kvendra-skills:onboard-project scaffolds the project structure and a canonical CLAUDE.md. It does not crawl or analyse all the code in an existing repo for you — you (or your agent, as you work) fill in the detail. The win is that the skeleton your agent reads on every session now exists.

5. Day to day

Tell Kvendra what you want to do and it routes you to the right workflow: 

/kvendra-skills:kvendra <what you want to do>

6. Your first win

With your project onboarded, your agent has the structured context it needs. Now see what it is for — this is the payoff, not the healthcheck. In Claude Code, ask your agent to plan something small in your own project:

Plan a small change in this project: add a rate limit to the login endpoint. Open a transaction in Kvendra, draft a short roadmap and a couple of tasks for it, and link them.

Driven by the Skills, the agent opens a transaction, drafts a roadmap and the tasks as typed entities, links them, and commits — so the plan now lives in a queryable knowledge base, not in a chat that scrolls away. Here is an illustrative shape of what you would see: 

# illustrative — your ids and titles will differ
TXN-… opened
  ROAD-…   "Rate-limit the login endpoint"      (draft → active)
  ISSUE-…  "Add token-bucket limiter to /login" (draft → active)
  ISSUE-…  "Add tests for the limit"            (draft → active)
  relations: ISSUE-… part_of ROAD-…
TXN-… committed

Then, later in the session (or a new one), ask the question that proves the point:

What did we decide about login throttling, and why?

The agent finds the roadmap and tasks by meaning and answers from them — even though you asked about “throttling” and the entities say “rate limit.” That is the whole idea: it stops re-deciding, because the decision is recorded and findable. (Illustrative — exactly what surfaces depends on your project.)

7. (Optional, and deferred) Add the CLI security broker

You do NOT need the CLI to start. Add it later only when you want your agent to run real ops (a git push, a deploy) without exposing your tokens. It is a foundational security layer — but optional to get started, and everything above works without it.

The CLI is in alpha. Install it from crates.io when you are ready (pre-built binaries are also on GitHub Releases; see CLI): 

cargo install --locked kvendra

It runs an MCP stdio broker plus a zero-knowledge vault, exposing seven primitives — git, github, npm, pypi, aws, http and shell — plus an unsafe.raw_token escape hatch. Sensitive operations are routed through the broker so the model orchestrating the work never sees a raw token or key.

How the pieces fit

Your agent (Claude Code, the host) talks to the Platform over MCP HTTP on port 7777 — that is the knowledge base. The Skills plugin runs on top, calling the same Platform tools, and is your day-to-day. The optional CLI adds a second MCP server (stdio) that brokers credentialed operations. Start with the Platform and Skills; add the CLI only when you need it.

Want to go step by step instead — from source, or against your own Postgres? Advanced install has the one-by-one detail.