Kaveyl Deutsch
Kaveyl Wiki · beta now on GitHub

Simple for everyday docs.
Built for the AI era.

Your knowledge base for personal notes, documentation and team projects. As easy as a modern notes app – with plain Markdown files in Git underneath and a built-in MCP server for your AI agents.

No terminal neededNo database lock-inFree, AGPL-3.0
Kaveyl Wiki in the browser: on the left the folder tree with a personal source “My Notes” (recipes, travel, home) and three team sources, in the editor an apple strudel recipe with coloured tags, a table, a tip, a shopping list as a checklist and the steps, on the right the table of contents
Two worlds, one workspace

No more choosing between simplicity and control

Knowledge belongs neither behind complicated terminal commands nor inside a closed cloud. Kaveyl Wiki brings both together: you organise your notes as in a familiar notes app, Git keeps every version, and AI agents work with the very same files.

For everyday use

Nested folders, drag and drop, templates, coloured tags and an editor that shows formatting as you type. No technical knowledge needed – versions are kept in the background on their own.

For developers & DevOps

Every page stays a Markdown file in the repository. Edit the same files side by side in VS Code, Neovim or with git – your CI pipelines keep running as before.

For AI agents & automation

A built-in MCP server (Model Context Protocol) and a REST API: Claude Code, Cursor or your own scripts search, read and change notes – never with more rights than the account behind the token.

Under the hood

Git does the work – quietly in the background

Every save automatically becomes a clean Git commit, with you as the author. Changes from outside – a git push, a CI script, or a file another program changes in a folder on the server – come in too: at once when your Git server sends a webhook, otherwise with the next sync. Your content lives in no database, and nothing is ever silently overwritten.

How Kaveyl Wiki keeps files in sync The browser saves to Kaveyl Wiki, which commits and pushes to a Git server such as Gitea, GitHub or GitLab. Editors, scripts and AI agents change the same repository; a webhook brings their changes back into Kaveyl Wiki within seconds. You, in the browser write, rename, move Kaveyl Wiki saves at once · commits pushes · links repaired conflicts shown, never lost Git server Gitea · GitHub · GitLab any Git URL Editors & agents VS Code · Neovim · git scripts · AI agents (MCP / API) save commit & push webhook:back in seconds
Git underneath every source: repositories sync with your Git server – a plain folder on the server keeps its versions with a Git of its own.
Gitea GitHub GitLab Any Git URL (HTTPS) Folders on the server As many sources as you like
Working together

One team, one shared state – nothing gets lost

Good teamwork doesn’t need frantic live typing in the same sentence. Kaveyl Wiki brings every saved change straight to everyone who has the note open, speaks up before two people get in each other’s way, and shows conflicts openly instead of resolving them silently.

Different places come together

If two people or an agent changed different paragraphs of the same note, one click on “Merge” keeps both. When the changes come through Git – from VS Code or a CI script – Kaveyl Wiki merges them by itself.

The same place: you decide

If the same line was changed twice, no automatism decides. For Git conflicts you see the base, your version and the other one side by side and choose – or merge by hand.

How simultaneous changes are handled Maria and Sam change the same note. Changes in different places are merged – automatically from Git, with one click in the editor. Changes to the same line become a conflict where you see the versions and choose, so nothing is lost silently. MC Maria SR Sam Different places ✓ merged – nothing lost Same line base mine theirs you choose – nothing lost

See who is writing

As soon as someone types in a note, everyone else sees “Maria Chen is editing”. Whoever then starts typing too is asked once – before two changes get in each other’s way.

Changes arrive at once

When someone saves – in the browser, through the API or as an AI agent – everyone who has the note open sees the new version right away. Your cursor stays where it was.

Every change has a name

Each person, script and agent gets its own commit. Bring back an older version with one click; deleted notes wait in the trash.

Follow what concerns you

Follow a note, a folder or a whole source: a dot in the sidebar, the “New for you” list or a bundled e-mail keep you up to date.

AI agents play by the rules

They work with the rights of their own account, never unnoticed overwrite a newer version, and see when a person is typing in the note.

Permissions that fit teams

Permissions per source, folder and note, with groups and guests. Invite new people, share notes and folders by e-mail.

A runbook in Kaveyl Wiki with the notice “Maria Chen is editing” at the top
Someone else is typing in the same note
The versions of a runbook: commits by Maria Chen and Sam Rivera, with the added canary step highlighted in green
Every change, with author and difference
Agents in the team

Safe AI workflows with a human in the loop

Full control instead of flying blind: agents get an account of their own and write only where they may. They suggest actions, and people approve them right in the note – checked and traceable. You build the agent yourself; an example agent to start with is included.

How agents, people and Git work on the same notes A server agent writes an incident note into Kaveyl Wiki through MCP. The team, who follows the folder, gets a dot or an e-mail. Someone ticks a suggested action or asks a question in the note. Kaveyl Wiki tells the agent who changed the note. The agent runs its fixed action only for people on its list and writes the result into the note. An AI assistant reads the notes through MCP and answers questions. Developers push to the same Git repository from VS Code or Claude Code. Every change carries the name of whoever made it. Kaveyl Wiki Markdown in Git every change with a name Server agent your script · syslog · MCP AI assistant e.g. Claude via MCP Team browser · follows the folder Developers VS Code · Claude Code · git 1 writes the incident … later the result (5) 2 dot · e-mail 3 ticks · asks 4 who was it? reads · answers push · pull
  1. An alert becomes a note

    An agent – say one that reads system logs – creates an incident note through MCP, with the suggested actions as checkboxes.

  2. The team is notified

    Whoever follows the folder sees a dot in the sidebar right away or gets an e-mail.

  3. Answers right in the note

    Team members review the note, tick the right action or write their questions directly underneath.

  4. A clearly known person

    Kaveyl Wiki reliably tells the agent which signed-in account set the tick. Ticks without a clear owner – from a Git push, for example – don’t count.

  5. The agent acts

    If the person may approve, the agent runs the action and writes the result into the same note a few seconds later. Ticks from others it takes back, with a reason.

An incident note written by a server agent: Sam Rivera’s tick was not accepted, a question was answered, and “Restart nginx” ran after Maria Chen released it
Real run of the example agent: refused, answered, released

Approval by account, not by text

Only a change by a signed-in account can trigger anything, never text in a note. Tested with a real AI: Claude ignored hidden instructions in notes and logs. When asked to tick a box itself, it did – and the agent took the tick back, because an AI is not on its list.

Open to your tools

Kaveyl Wiki provides the building blocks: MCP, event webhooks with the person behind every change, permissions and the Git history. Which agents you connect and what they may do is up to you – an example agent to start with is included. Meant for decisions a person should make, not as a replacement for monitoring.

AI & MCP

Your docs, right inside your AI tools

No more copying and pasting into a chat window. Through the built-in MCP server your AI tools work with your wiki directly: they search, read and write notes. In a Git source every change becomes a commit with a name – review it, keep it or bring back the version before.

The closed loop between documentation, agents and developers An AI writes a runbook into the wiki. The wiki keeps it as Markdown in Git. An agent follows the runbook with its own tools. When a step is wrong, the agent corrects the page through MCP. A developer reviews the change in the version history or in VS Code, and the loop starts again. Kaveyl Markdown in Git 1 · AI writesa runbook 2 · An agentfollows it live 3 · Finds a gapa step is wrong 4 · Fixes the pagevia MCP · a commit 5 · You reviewdiff · keep · restore

A runbook that repairs itself

An agent sets up a server by following a guide from the wiki. Step 4 fails because a package was renamed. It finds the new name, finishes the setup and corrects the page through MCP. The commit carries the name of the person behind the token, the log marks it as MCP – and you see the exact difference in the version history.

Docs that move with the code

Claude Code changes a service and its documentation in the same repository. Kaveyl Wiki picks up the push via webhook and shows the new page to the whole team within seconds – no copying, no second system.

Built this way

Kaveyl Wiki itself was developed in exactly this loop: AI agents and a human working on the same Markdown, Git as the single source of truth.

One standard, many tools

The MCP server works with Claude Code, Cursor, VS Code, LM Studio and – through a small bridge – Claude Desktop. Scripts use the REST API, described at /api/v1/openapi.json.

The right context while working

Agents look up runbooks, specs and guidelines exactly when they need them – while coding or setting up a server.

Files stay as they are

YAML front matter is kept byte for byte, tables stay Markdown tables. Agents read the file exactly as it sits in the repository.

Bring in AI agents like team members

An agent – Claude, for example – gets an account of its own, like a colleague. It works on notes by itself, but sees only the sources, folders and notes you share with it, and every change it makes carries its name in Git.

  1. Create an account

    Under Users & permissions, create an account of its own, such as “Claude Assistant”. The initial password can stay as you set it – nobody signs in with the account.

  2. Set its permissions

    Give the account exactly the sources, folders or single notes it should read or change. With the default set to “see nothing”, everything else stays invisible to the agent.

  3. Create a token

    Under AI & APIs → All tokens you create a token for the account with read, write and MCP permission – without signing in as the agent. It can never do more than the account; renew or delete it at any time.

  4. Connect the agent

    Kaveyl Wiki shows the ready-made command for Claude Code and the configuration for other MCP clients. From then on the agent creates pages, updates documentation and reworks drafts – only where its account may write.

Settings, API tokens: a token for Claude Code with read, write and MCP permission and a read-only token for a status page script
One token per tool – never more rights than the person behind it
Features

Everything included, no plugins

Editor, search, permissions, encryption, backups, import from other apps, AI and much more – all on one page.

Self-hosted & free

Your servers, your repositories, your data

Kaveyl Wiki runs entirely on your side – as a single Docker container on a Linux server or NAS. No tracking, no forced cloud, no subscription.

  • Set up in a few minutes with one docker-compose.yml – a single container.
  • Your notes stay files. Markdown in Git or in folders – readable even without Kaveyl Wiki.
  • Free software under the GNU Affero General Public License v3.0.
  • No telemetry. Kaveyl Wiki only talks to the services you connect yourself – plus, if you want, a daily check for new versions.

Notes, Git and AI – in one place

Your notes, the safety of Git and your AI tools in one fast workspace.

Kaveyl Wiki is in beta, in its final round of testing: the feature set is complete, bugs are still possible – so back up your data regularly and tell us what you find at me@kaveyl.app.