MCP connectors (Model Context Protocol) now allow your AI assistant to read and write directly into your Kalinotes projects. Combined with Claude Code skills, they turn note-taking, application review, and bug tracking into fully automated workflows — without leaving your terminal or IDE.
What is the MCP protocol?
The Model Context Protocol (MCP) is an open standard developed by Anthropic that allows AI agents to connect to external data sources and tools in a standardised way. In practice, instead of manually copying and pasting content between your assistant and your tools, the MCP connector creates a direct bridge: the AI can read your notes, create new content and update existing entries in real time.
Kalinotes provides its own MCP connector that gives access to your entire workspace: projects, categories, notes and comments. Your AI therefore has the same context as you, with no extra effort.
💡 In a nutshell: the Kalinotes MCP connector turns your Claude assistant into a collaborator capable of acting directly in your notes space, not just talking about it.
Setting up the Kalinotes MCP connector
The setup takes three steps from your terminal:
- Install Claude Code:
npm install -g @anthropic-ai/claude-code - Retrieve your API token from your Kalinotes account settings
- Add the MCP server to Claude Code:
claude mcp add kalinotes --token YOUR_TOKEN
Once configured, Claude Code has access to all your Kalinotes projects and categories. You can verify the connection by asking Claude: "List my Kalinotes projects".
Prerequisites before you start
- An active Kalinotes account with at least one project created
- Node.js installed (version 18 or higher)
- Claude Code installed via npm
- An API token generated from your Kalinotes workspace
The 8 available Claude skills for Kalinotes
Skills are slash commands (Markdown files placed in ~/.claude/commands/)
that extend Claude Code's capabilities with specialised workflows. Kalinotes offers
eight dedicated skills, downloadable from the
app.kalinotes.com/outils/claude-skills
page.
| Skill | Command | Function |
|---|---|---|
| Capture | /kalinotes-capture |
Analyses the conversation and creates a note by automatically deducing the project and category |
| ADR | /kalinotes-adr |
Structures architectural decisions (Context / Options / Decision / Consequences) |
| Review | /kalinotes-review |
Aggregates a project's notes into a summary: open tasks, decisions, suggestions |
| Search | /kalinotes-search |
Keyword search across all your projects with contextual excerpts |
| Standup | /kalinotes-standup |
Generates daily standup notes from previous entries, tracking unresolved items |
| Bug | /kalinotes-bug |
Creates structured bug reports (symptoms, reproduction steps, solution) |
| QA | /kalinotes-qa |
Audits a web application: functional, UX, performance and security — then documents the results in Kalinotes |
| Snippet | /kalinotes-snippet |
Automatically detects the language, saves the snippet with generated metadata and tags |
Installing skills
Each skill comes as an .md file to be placed in
~/.claude/commands/ for global availability, or in
.claude/commands/ at project level for local scope.
Once in place, the corresponding slash command is immediately available in
any Claude Code session.
Use case: full application review with /kalinotes-qa
Here is a concrete scenario illustrating the power of the MCP + skills combination. You have just finished developing a web application and want to carry out a quality review before delivery, generate bug and improvement notes, consult a summary report, and share the results with your client or team.
Step 1 — Connect your AI and install the skills
After configuring the MCP connector as described above, download the skills from
the Kalinotes tools page. Copy the kalinotes-qa.md and
kalinotes-bug.md files into your ~/.claude/commands/ folder.
Then open Claude Code in your project directory:
Quick check
Type / in Claude Code to display the list of available commands.
You should see /kalinotes-qa, /kalinotes-bug
and the other installed skills appear.
Step 2 — Launch the QA review with /kalinotes-qa
Start the audit by providing your application's URL (or the local path if it is running in development):
/kalinotes-qa https://my-app.example.com
Claude Code then goes through the application along four axes of analysis:
- Functional: verification of user journeys, forms, links, navigation
- UX: visual consistency, accessibility, readability of error messages
- Performance: load times, unoptimised images, blocking resources
- Security: missing HTTP headers, exposed sensitive data, risky configurations
Step 3 — Generate bug and improvement notes
At the end of the audit, Claude automatically creates structured notes in your
Kalinotes project. Each detected anomaly generates a bug note via
/kalinotes-bug, including:
- The description of the observed symptom
- Steps to reproduce the issue
- Estimated severity (blocker, major, minor)
- A suggested fix
Improvement points (UX, performance, accessibility) are saved in a dedicated "Improvements" category, with a priority rating and the expected benefit for the end user.
💡 Tip: create a dedicated Kalinotes project for your application beforehand with two distinct categories — Bugs and Improvements — so that Claude organises the notes automatically without manual intervention.
Step 4 — View the summary report
Once the notes are created, use the /kalinotes-review skill to generate
a consolidated project report:
/kalinotes-review
Claude aggregates all the project's notes and produces a structured summary:
- Number of bugs by severity
- Prioritised list of improvements
- Recap of any technical decisions made
- Estimated correction workload
This report can be shared directly with your client or project manager as a record of the acceptance testing phase.
Step 5 — Share project access
Kalinotes lets you share a project with other users from the web interface. Go to the settings of the relevant project and invite your collaborators by email address. You can set two access levels:
- Read-only: ideal for a client who follows progress without modifying notes
- Collaborator: full access for a team member participating in the review
Invited members can access the notes created by your AI directly without needing to install Claude Code or configure the MCP — collaboration stays smooth even for non-developers.
🔄 Full workflow at a glance
- Configure the Kalinotes MCP in Claude Code (once only)
- Install the skill files in
~/.claude/commands/ - Create a Kalinotes project with Bugs and Improvements categories
- Run
/kalinotes-qa <URL>for the automated audit - View the generated notes directly in Kalinotes
- Run
/kalinotes-reviewfor the summary report - Share the project with the client or team via Kalinotes settings
Why this approach is a game changer
The MCP + skills combination eliminates the most time-consuming manual steps of the review cycle: entering bugs, organising notes, writing the report. The AI handles the documentation while you focus on decisions and fixes. And since everything is centralised in Kalinotes, feedback remains accessible, traceable and shareable, regardless of team size.
🚀 Ready to connect your AI to Kalinotes?
Download the skills, configure the MCP connector and launch your first automated QA audit in under ten minutes. Access the skills at kalinotes.com