MCP (Model Context Protocol) connectors now let your AI assistant read from 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 your IDE.
What is the MCP protocol?
The Model Context Protocol (MCP) is an open standard developed by Anthropic that lets AI agents 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 offers 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 short: the Kalinotes MCP connector turns your Claude assistant into a collaborator capable of acting directly within your notes space, not just talking about it.
Setting up the Kalinotes MCP connector
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 check 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 Claude skills available 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, automatically inferring 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: functionality, 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 the skills
Each skill comes as a .md file to place in
~/.claude/commands/ for global availability, or in
.claude/commands/ at project level for a local scope.
Once in place, the corresponding slash command is immediately available in
any Claude Code session.
Use case: a complete application review with /kalinotes-qa
Here is a concrete scenario illustrating the power of combining MCP + skills. You have just finished developing a web application and want to run a quality review before delivery, generate bug and improvement notes, view a summary report and share the results with your client or your team.
Step 1 — Connect your AI and install the skills
Once you have set up 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 — Run the QA review with /kalinotes-qa
Launch the audit by providing the URL of your application (or the local path if it is running in development):
/kalinotes-qa https://mon-app.example.com
Claude Code then goes through the application along four lines of analysis:
- Functionality: checking user journeys, forms, links, navigation
- UX: visual consistency, accessibility, readability of error messages
- Performance: load times, unoptimised images, blocking resources
- Security: missing HTTP headers, exposure of 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 anomaly detected generates a bug-type note via
/kalinotes-bug, including:
- A description of the observed symptom
- The steps to reproduce the problem
- The estimated severity (blocking, major, minor)
- A suggested fix
The improvement points (UX, performance, accessibility) are recorded in a dedicated "Improvements" category, with a priority note and the expected benefit for the end user.
💡 Tip: set up a dedicated project in Kalinotes for your application beforehand, with two separate categories — Bugs and Improvements — so that Claude organises the notes automatically with no manual intervention.
Step 4 — View the summary report
Once the notes have been created, use the /kalinotes-review skill to generate
a consolidated report of the project:
/kalinotes-review
Claude aggregates all of the project's notes and produces a structured summary:
- Number of bugs by severity
- List of prioritised improvements
- Recap of any technical decisions made
- Estimate of the fixing effort
This report can be shared directly with your client or your project manager as a record of the acceptance testing phase.
Step 5 — Share access to the project
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 editing the notes
- Collaborator: full access for a team member taking part in the review
Invited members 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.
🔄 The complete flow in summary
- Configure the Kalinotes MCP in Claude Code (just once)
- Install the skill files in
~/.claude/commands/ - Create a Kalinotes project with the Bugs and Improvements categories
- Run
/kalinotes-qa <URL>for the automated audit - Review the generated notes directly in Kalinotes
- Run
/kalinotes-reviewfor the summary report - Share the project with the client or team via the Kalinotes settings
Why this approach is a game changer
Combining MCP + skills eliminates the most time-consuming manual steps of the review cycle: logging bugs, organising notes, writing the report. The AI takes care of the documentation while you focus on decisions and fixes. And since everything is centralised in Kalinotes, the feedback stays accessible, traceable and shareable, whatever the size of the team.
🚀 Ready to connect your AI to Kalinotes?
Download the skills, set up the MCP connector and run your first automated QA audit in under ten minutes. Access the skills on kalinotes.com