Keep/mcp-server/MCP-DOCS.md

Memento MCP Server - Documentation Complete

Version 3.0.0 | 34 outils | Model Context Protocol

Table des matieres

1. Introduction
2. Architecture
3. Installation
4. Configuration
5. Modes de transport
6. Reference complete des outils
7. Integrations
8. Docker
9. Securite
10. Guide de demarrage rapide
11. Depannage

---

1. Introduction

Memento MCP Server est un serveur Model Context Protocol (MCP) qui expose toutes les fonctionnalites de l'application de prise de notes Memento sous forme d'outils programmables.

Il permet a n'importe quel client MCP (Claude Code, Cursor, N8N, scripts Python, etc.) de :

• Creer, lire, modifier, supprimer des notes
• Gerer les notebooks et labels
• Utiliser les fonctionnalites AI (titres, tags, reformulation, Memory Echo, fusion, etc.)
• Exporter/importer les donnees
• Traiter les rappels en retard

Pourquoi MCP ?

Sans MCP :  Vous devez utiliser l'interface web manuellement
Avec MCP :  N'importe quel agent AI ou automate peut interagir avec vos notes

---

2. Architecture

Vue d'ensemble

┌─────────────────────────────────────────────────────────────────┐
│                    CLIENTS MCP                                   │
│  ┌───────────┐  ┌──────────┐  ┌──────────┐  ┌──────────────┐  │
│  │Claude Code│  │  Cursor  │  │   N8N    │  │Script Python │  │
│  └─────┬─────┘  └────┬─────┘  └────┬─────┘  └──────┬───────┘  │
│        │              │              │                │          │
│   stdio           stdio          HTTP/SSE         HTTP/SSE     │
└────────┼──────────────┼──────────────┼────────────────┼─────────┘
         │              │              │                │
         ▼              ▼              ▼                ▼
┌─────────────────────────────────────────────────────────────────┐
│                    MCP SERVER v3.0.0                              │
│                                                                  │
│  ┌──────────────────────────────────────────────────────────┐   │
│  │                    tools.js (34 outils)                    │   │
│  │                                                            │   │
│  │  ┌──────────┐  ┌──────────┐  ┌──────────┐  ┌──────────┐ │   │
│  │  │  Notes   │  │Notebooks │  │  Labels  │  │Reminders │ │   │
│  │  │  12 tools│  │  6 tools │  │  4 tools │  │  1 tool  │ │   │
│  │  └──────────┘  └──────────┘  └──────────┘  └──────────┘ │   │
│  │  ┌────────────────────────────────────────────────────┐  │   │
│  │  │                    AI (11 tools)                    │  │   │
│  │  │  Titres | Tags | Reformulation | Memory Echo       │  │   │
│  │  │  Fusion | Notebook AI | Batch | Auto-labels        │  │   │
│  │  └────────────────────────────────────────────────────┘  │   │
│  └──────────────────────────────────────────────────────────┘   │
│                                                                  │
│  ┌─────────────┐                         ┌─────────────────┐    │
│  │  index.js   │                         │  index-sse.js   │    │
│  │  (stdio)    │                         │  (HTTP/SSE)     │    │
│  └──────┬──────┘                         └────────┬────────┘    │
└─────────┼─────────────────────────────────────────┼────────────┘
          │                                         │
          ▼                                         ▼
┌──────────────────┐                    ┌──────────────────────┐
│   SQLite DB      │                    │  Next.js App API     │
│  (Prisma ORM)    │                    │  (Outils AI)         │
│                  │                    │                      │
│  - Notes         │                    │  /api/ai/*           │
│  - Notebooks     │                    │  /api/notes/*        │
│  - Labels        │                    │                      │
│  - Users         │                    │  localhost:3000      │
│  - Reminders     │                    └──────────────────────┘
└──────────────────┘

Flux de donnees par type d'outil

Outils CRUD (Notes, Notebooks, Labels, Reminders) :

Client MCP ──► tools.js ──► Prisma ORM ──► SQLite

Acces direct a la base de donnees. Pas besoin que l'app Next.js soit lancee.

Outils AI :

Client MCP ──► tools.js ──► fetch() ──► Next.js /api/ai/* ──► AI Provider

Proxy vers l'API Next.js. L'application doit etre lancee et un provider AI configure.

Structure des fichiers

mcp-server/
├── index.js          # Transport stdio (CLI local)
├── index-sse.js      # Transport HTTP/SSE (distant)
├── tools.js          # Definitions et handlers des 34 outils
├── package.json      # Dependances et scripts
├── Dockerfile        # Image Docker multi-mode
│
├── n8n-workflow-create-note.json          # Workflow N8N pre-construit
├── n8n-workflow-email-integration.json
├── n8n-workflow-label-management.json
├── n8n-workflow-notebook-management.json
├── n8n-workflow-reminder-notifications.json
├── n8n-workflow-search-summary.json
│
└── prisma/           # Schema Prisma (generation)

---

3. Installation

Prerequis

• Node.js 18+ (recommande 20+)
• SQLite (inclus avec Prisma)
• L'application Memento Next.js (pour les outils AI)

Installation rapide

cd mcp-server

# Installer les dependances
npm install

# Regenerer le client Prisma (si le schema a change)
npx prisma generate --schema=../keep-notes/prisma/schema.prisma

Verification

# Test d'import du module
node -e "import('./tools.js').then(() => console.log('OK'))"

# Lancement rapide en mode stdio
node index.js

---

4. Configuration

Variables d'environnement

Variable	Defaut	Requis	Description
DATABASE_URL	file:../keep-notes/prisma/dev.db	Non	Chemin vers la base SQLite
USER_ID	Auto-detecte (1er user)	Non	ID utilisateur pour le filtrage multi-user
APP_BASE_URL	http://localhost:3000	AI	URL de l'app Next.js (requis pour les outils AI)
PORT	3001	Non	Port du serveur HTTP (mode SSE uniquement)
MCP_REQUIRE_AUTH	false	Non	Activer l'authentification (true/false)
MCP_API_KEY	-	Non	Cle API statique (si auth activee)

Multi-utilisateur

Memento supporte plusieurs utilisateurs. Le MCP peut operer de deux manieres :

┌─────────────────────────────────────────┐
│  USER_ID non defini                      │
│  → Auto-detection du 1er utilisateur     │
│  → Toutes les operations utilisent       │
│    cet utilisateur par defaut            │
└─────────────────────────────────────────┘

┌─────────────────────────────────────────┐
│  USER_ID="cmk36y..." defini             │
│  → Toutes les operations sont filtreees  │
│    pour cet utilisateur specifique       │
│  → Create/Read/Update/Delete scopes      │
└─────────────────────────────────────────┘

---

5. Modes de transport

5.1 Mode Stdio (CLI local)

Pour une utilisation locale avec Claude Code, Cursor, ou tout client MCP qui supporte le transport stdio.

┌──────────────┐    stdin/stdout    ┌──────────────┐
│  Claude Code │ ◄──────────────► │   index.js   │
│  ou Cursor   │   (JSON-RPC)     │  (stdio)     │
└──────────────┘                   └──────┬───────┘
                                          │
                                          ▼
                                   ┌──────────────┐
                                   │  SQLite DB   │
                                   └──────────────┘

Lancement :

node index.js

Configuration Claude Code (.claude/mcp.json) :

{
  "mcpServers": {
    "memento": {
      "command": "node",
      "args": ["/chemin/vers/mcp-server/index.js"],
      "env": {
        "APP_BASE_URL": "http://localhost:3000",
        "USER_ID": "votre-user-id"
      }
    }
  }
}

Configuration Cursor (.cursor/mcp.json) :

{
  "mcpServers": {
    "memento": {
      "command": "node",
      "args": ["/chemin/vers/mcp-server/index.js"],
      "env": {
        "APP_BASE_URL": "http://localhost:3000"
      }
    }
  }
}

5.2 Mode HTTP/SSE (distant)

Pour les automatisations N8N, les scripts, ou tout client HTTP.

┌──────────────┐    HTTP POST      ┌──────────────────┐
│     N8N      │ ────────────────► │   index-sse.js   │
│  ou Script   │ ◄──────────────── │  (port 3001)     │
└──────────────┘   SSE response    └────────┬─────────┘
                                            │
                                  ┌─────────┴─────────┐
                                  ▼                   ▼
                           ┌──────────────┐   ┌──────────────┐
                           │  SQLite DB   │   │  Next.js API │
                           └──────────────┘   └──────────────┘

Lancement :

# Mode dev (sans auth)
node index-sse.js

# Mode production (avec auth)
MCP_REQUIRE_AUTH=true MCP_API_KEY=votre-cle-secrete node index-sse.js

# Port personnalise
PORT=8080 node index-sse.js

Endpoints HTTP :

GET  /            → Health check (version, status, outils)
GET  /sessions    → Sessions utilisateur actives
ALL  /mcp         → Endpoint MCP Streamable HTTP
ALL  /sse         → Alias legacy → /mcp

Exemple de health check :

curl http://localhost:3001/

# Reponse :
{
  "name": "Memento MCP Server",
  "version": "3.0.0",
  "status": "running",
  "tools": { "notes": 12, "notebooks": 6, "labels": 4, "ai": 11, "reminders": 1, "total": 34 }
}

---

6. Reference complete des outils

6.1 Notes (12 outils)

create_note

Cree une nouvelle note avec support complet.

Parametres :
  content*             string          Contenu de la note
  title                string          Titre (optionnel)
  color                string          Couleur (default, red, orange, yellow,
                                       green, teal, blue, purple, pink, gray)
  type                 string          "text" ou "checklist"
  checkItems           array           Items de checklist [{id, text, checked}]
  labels               array[string]   Tags/labels
  isPinned             boolean         Epingler la note
  isArchived           boolean         Creer directement archivee
  images               array[string]   URLs ou base64
  links                array[string]   URLs attachees
  reminder             string          Date/heure ISO 8601
  reminderRecurrence   string          "daily" | "weekly" | "monthly" | "yearly"
  reminderLocation     string          Lieu du rappel
  isMarkdown           boolean         Activer le rendu Markdown
  size                 string          "small" | "medium" | "large"
  notebookId           string          ID du notebook cible

Exemple :

{
  "title": "Idees de projet",
  "content": "Creer un bot Discord qui resume les notes",
  "color": "blue",
  "labels": ["idee", "bot"],
  "isMarkdown": true,
  "notebookId": "cmk36..."
}

get_notes

Recupere les notes avec filtres. Retourne un format leger par defaut (contenu tronque a 200 caracteres, pas d'images).

Parametres :
  includeArchived  boolean   Inclure les notes archivees (defaut: false)
  search           string    Filtrer par mot-cle
  notebookId       string    Filtrer par notebook ("inbox" = sans notebook)
  fullDetails      boolean   Retour complet avec images (defaut: false)
  limit            number    Max notes (defaut: 100)

get_note

Recupere une note par ID avec tous les details.

Parametres :
  id*   string   ID de la note

update_note

Met a jour une note. N'inclure que les champs a modifier.

Parametres :
  id*                  string   ID de la note
  title                string
  content              string
  color                string
  type                 string
  checkItems           array
  labels               array[string]
  isPinned             boolean
  isArchived           boolean
  images               array[string]
  links                array[string]
  reminder             string
  isReminderDone       boolean
  reminderRecurrence   string
  reminderLocation     string
  isMarkdown           boolean
  size                 string
  notebookId           string

delete_note

Supprime une note par ID.

Parametres :
  id*   string   ID de la note

delete_all_notes

Supprime TOUTES les notes, labels et notebooks. Use avec extreme caution.

search_notes

Recherche par mot-cle dans le titre et le contenu.

Parametres :
  query*            string   Requete de recherche
  notebookId        string   Limiter a un notebook
  includeArchived   boolean  Inclure les archivees (defaut: false)

move_note

Deplace une note vers un autre notebook (ou Inbox).

Parametres :
  id*         string   ID de la note
  notebookId  string   ID du notebook cible (null = Inbox)

toggle_pin

Inverse le statut d'epinglage d'une note.

Parametres : id* (string)

toggle_archive

Inverse le statut d'archivage d'une note.

Parametres : id* (string)

export_notes

Exporte toutes les donnees au format JSON.

// Reponse :
{
  "version": "2.0",
  "exportDate": "2026-04-11T...",
  "data": {
    "notes": [...],
    "notebooks": [...],
    "labels": [...]
  }
}

import_notes

Importe des donnees depuis un export JSON. Les doublons (meme nom) sont ignores.

Parametres :
  data*   object   L'objet JSON exporte (de export_notes)

---

6.2 Notebooks (6 outils)

create_notebook

Parametres :
  name*   string   Nom du notebook
  icon    string   Icone emoji (defaut: "📁")
  color   string   Couleur hex (defaut: "#3B82F6")
  order   number   Position (auto si omis)

get_notebooks

Retourne tous les notebooks avec nombre de notes et labels.

get_notebook

Parametres : id* (string)

Retourne le notebook avec ses notes (format leger) et labels.

update_notebook

Parametres :
  id*    string   ID du notebook
  name   string
  icon   string
  color  string
  order  number

delete_notebook

Supprime un notebook. Les notes a l'interieur sont deplacees vers Inbox.

Parametres : id* (string)

reorder_notebooks

Reordonne les notebooks. Passe un tableau d'IDs dans l'ordre souhaite.

Parametres :
  notebookIds*  array[string]   IDs dans l'ordre voulu

---

6.3 Labels (4 outils)

create_label

Parametres :
  name*       string   Nom du label
  notebookId* string   Notebook d'appartenance
  color       string   Couleur (red, orange, yellow, green, teal, blue, purple, pink, gray)

get_labels

Parametres :
  notebookId  string   Filtrer par notebook (optionnel)

update_label

Parametres :
  id*    string   ID du label
  name   string
  color  string

delete_label

Parametres : id* (string)

---

6.4 AI (11 outils)

Important : Ces outils necessitent que l'application Next.js soit lancee (localhost:3000) ET qu'un provider AI soit configure (OpenAI, Ollama, etc.).

generate_title_suggestions

Genere 3 suggestions de titre pour un contenu.

Parametres :
  content*  string   Contenu de la note (10+ mots recommandes)

Reponse :
  { suggestions: [{ title, confidence, reasoning }] }

reformulate_text

Reformule un texte avec 3 modes disponibles.

Parametres :
  text*    string   Texte a reformuler
  option*  string   "clarify" | "shorten" | "improve"

Reponse :
  { originalText, reformulatedText, option, wordCountChange }

generate_tags

Genere des tags/labels pour un contenu. Mode contextuel si un notebookId est fourni.

Parametres :
  content*    string   Contenu a analyser
  notebookId  string   ID du notebook pour tags contextuels
  language    string   Langue (defaut: "en")

Reponse :
  { tags: [{ tag, confidence, isNewLabel }] }

suggest_notebook

Suggere un notebook pour une note base sur son contenu.

Parametres :
  noteContent*  string   Contenu (20+ mots recommandes)
  language      string   Langue (defaut: "en")

get_notebook_summary

Genere un resume AI de toutes les notes d'un notebook.

Parametres :
  notebookId*  string   ID du notebook
  language     string   Langue (defaut: "en")

get_memory_echo

Recupere le prochain insight Memory Echo - des connexions semantiques decouvertes entre vos notes.

Pas de parametres.

Reponse :
  { insight: { note1, note2, similarityScore, insight } | null }

get_note_connections

Liste toutes les notes semantiquement liees a une note donnee.

Parametres :
  noteId*  string   ID de la note
  page     number   Page (defaut: 1)
  limit    number   Par page (defaut: 10, max: 50)

Reponse :
  { connections: [...], pagination: { total, page, totalPages } }

dismiss_connection

Rejette une connexion entre deux notes.

Parametres :
  noteId*          string   ID de la premiere note
  connectedNoteId* string   ID de la note connectee a rejeter

fuse_notes

Fusionne plusieurs notes en une seule via AI.

Parametres :
  noteIds*  array[string]   IDs des notes (minimum 2)
  prompt    string          Instructions supplementaires

batch_organize

Organisation intelligente des notes de l'Inbox.

# Etape 1 : Creer le plan
{ "action": "create_plan", "language": "fr" }

# Etape 2 : Appliquer le plan
{
  "action": "apply_plan",
  "plan": { ... },           // L'objet retourne par create_plan
  "selectedNoteIds": [...]   // IDs des notes a deplacer
}

suggest_auto_labels

Suggere ou cree des labels pour un notebook (requiert 15+ notes).

# Suggere des labels
{ "action": "suggest", "notebookId": "..." }

# Cree les labels selectionnes
{
  "action": "create",
  "notebookId": "...",
  "selectedLabels": ["label1", "label2"],
  "suggestions": { ... }     // Objet de l'etape suggest
}

---

6.5 Reminders (1 outil)

get_due_reminders

Recupere les notes avec des rappels en retard non traites. Les marque comme traites.

Pas de parametres.

Reponse :
  { count: 3, reminders: [{ id, title, content, reminder }] }

---

7. Integrations

7.1 N8N

Le serveur MCP inclut 6 workflows N8N pre-construits :

Fichier	Description
n8n-workflow-create-note.json	Creation de notes depuis diverses sources
n8n-workflow-email-integration.json	Création de notes depuis les emails
n8n-workflow-label-management.json	Gestion automatique des labels
n8n-workflow-notebook-management.json	Organisation automatique des notebooks
n8n-workflow-reminder-notifications.json	Notifications de rappels
n8n-workflow-search-summary.json	Recherche et resume automatique

Configuration dans N8N :

1. Ajouter un noeud "MCP" dans N8N
2. Configurer :
   - Transport : SSE / Streamable HTTP
   - URL : http://VOTRE_IP:3001/mcp
   - Headers : x-api-key: votre-cle (si auth activee)
3. Importer un workflow JSON depuis le dossier n8n-workflow-*

Exemple de workflow - Sauvegarde automatique d'articles RSS :

┌──────────────┐     ┌──────────────┐     ┌──────────────┐     ┌──────────────┐
│  RSS Feed    │────►│  AI Agent    │────►│  Filtre      │────►│  create_note │
│  (trigger)   │     │  (analyse)   │     │  (pertinence)│     │  (MCP tool)  │
│  Toutes les  │     │  Resume et   │     │  Score > 7   │     │  Sauvegarde  │
│  2 heures    │     │  evalue      │     │              │     │  dans Memento│
└──────────────┘     └──────────────┘     └──────────────┘     └──────────────┘

7.2 Claude Code

// .claude/mcp.json
{
  "mcpServers": {
    "memento": {
      "command": "node",
      "args": ["/chemin/absolu/vers/mcp-server/index.js"],
      "env": {
        "APP_BASE_URL": "http://localhost:3000",
        "USER_ID": "votre-user-id-optionnel"
      }
    }
  }
}

Apres configuration, vous pouvez dire a Claude :

"Cree une note avec mes idees de vacances"
"Recherche toutes les notes sur l'IA"
"Combien de notebooks ai-je ?"
"Genere des tags pour ce contenu"
"Resume le notebook Boulot"

7.3 Cursor

// .cursor/mcp.json
{
  "mcpServers": {
    "memento": {
      "command": "node",
      "args": ["/chemin/absolu/vers/mcp-server/index.js"],
      "env": {
        "APP_BASE_URL": "http://localhost:3000"
      }
    }
  }
}

7.4 Script Personnalise (HTTP)

import requests

MCP_URL = "http://localhost:3001/mcp"
HEADERS = {
    "Content-Type": "application/json",
    "Accept": "application/json, text/event-stream",
}

# 1. Initialiser
res = requests.post(MCP_URL, headers=HEADERS, json={
    "jsonrpc": "2.0", "id": 1, "method": "initialize",
    "params": {
        "protocolVersion": "2024-11-05",
        "capabilities": {},
        "clientInfo": {"name": "mon-script", "version": "1.0"}
    }
})
session_id = res.headers["mcp-session-id"]
HEADERS["mcp-session-id"] = session_id

# 2. Appeler un outil
res = requests.post(MCP_URL, headers=HEADERS, json={
    "jsonrpc": "2.0", "id": 2, "method": "tools/call",
    "params": {
        "name": "create_note",
        "arguments": {
            "title": "Depuis Python",
            "content": "Note creee automatiquement !",
            "color": "green"
        }
    }
})
print(res.json())

# En bash avec curl
SESSION_ID=$(curl -s -D - -X POST http://localhost:3001/mcp \
  -H "Content-Type: application/json" \
  -H "Accept: application/json, text/event-stream" \
  -d '{"jsonrpc":"2.0","id":1,"method":"initialize","params":{"protocolVersion":"2024-11-05","capabilities":{},"clientInfo":{"name":"test","version":"1.0"}}}' \
  2>&1 | grep -i 'mcp-session-id' | awk '{print $2}' | tr -d '\r')

curl -s -X POST http://localhost:3001/mcp \
  -H "Content-Type: application/json" \
  -H "Accept: application/json, text/event-stream" \
  -H "mcp-session-id: $SESSION_ID" \
  -d '{"jsonrpc":"2.0","id":2,"method":"tools/call","params":{"name":"get_notebooks","arguments":{}}}'

---

8. Docker

Docker Compose (recommande)

Le fichier docker-compose.yml a la racine du projet inclut le MCP server :

┌─────────────────────────────────────────────────────┐
│  docker-compose.yml                                  │
│                                                      │
│  ┌──────────────┐  ┌──────────────┐  ┌───────────┐ │
│  │ memento-web  │  │ memento-mcp  │  │  ollama   │ │
│  │  :3000       │  │  :3001       │  │  :11434   │ │
│  │  Next.js     │  │  MCP Server  │  │  (option) │ │
│  └──────┬───────┘  └──────┬───────┘  └───────────┘ │
│         │                 │                         │
│         └────────┬────────┘                         │
│                  ▼                                   │
│         ┌──────────────┐                             │
│         │  db-data     │  Volume partage SQLite      │
│         └──────────────┘                             │
└─────────────────────────────────────────────────────┘

# Lancer l'ensemble
docker compose up -d

# MCP en mode SSE (HTTP)
MCP_MODE=sse docker compose up -d mcp-server

# MCP en mode stdio (CLI)
MCP_MODE=stdio docker compose up -d mcp-server

Docker seul

# Build
docker build -t memento-mcp ./mcp-server

# Run en mode HTTP
docker run -d \
  -p 3001:3001 \
  -e MCP_MODE=sse \
  -e DATABASE_URL=file:/app/db/dev.db \
  -v /chemin/vers/db:/app/db \
  memento-mcp

# Run en mode stdio
docker run -i \
  -e MCP_MODE=stdio \
  -e DATABASE_URL=file:/app/db/dev.db \
  -v /chemin/vers/db:/app/db \
  memento-mcp

---

9. Securite

Modele d'authentification

┌──────────────────────────────────────────────────────┐
│  MCP_REQUIRE_AUTH=false (defaut)                     │
│                                                       │
│  → Aucune authentification requise                   │
│  → Pour developpement et reseau local uniquement     │
│  → Session "dev-user" assignee automatiquement       │
└──────────────────────────────────────────────────────┘

┌──────────────────────────────────────────────────────┐
│  MCP_REQUIRE_AUTH=true                               │
│                                                       │
│  → Header requis : x-api-key OU x-user-id           │
│  → Si MCP_API_KEY defini : valide la cle statique    │
│  → Sinon : accepte n'importe quelle valeur comme ID  │
│  → Sessions en memoire (perdues au redemarrage)      │
└──────────────────────────────────────────────────────┘

Recommandations production

1. Activez l'authentification : MCP_REQUIRE_AUTH=true
2. Definissez une cle API forte : MCP_API_KEY=une-cle-tres-longue-et-aleatoire
3. Utilisez HTTPS via un reverse proxy (nginx, caddy)
4. Limitez le reseau : n'exposez pas le port publiquement
5. Filtrez par utilisateur : definissez USER_ID pour isoler les donnees

Exemple avec reverse proxy

Internet ──► Nginx (HTTPS) ──► MCP Server (localhost:3001)
              - SSL/TLS
              - Rate limiting
              - IP whitelist

---

10. Guide de demarrage rapide

Scenario 1 : Utilisation locale avec Claude Code

# 1. Installer les dependances
cd mcp-server && npm install

# 2. Ajouter dans .claude/mcp.json

{
  "mcpServers": {
    "memento": {
      "command": "node",
      "args": ["/chemin/vers/mcp-server/index.js"],
      "env": { "APP_BASE_URL": "http://localhost:3000" }
    }
  }
}

# 3. Lancer l'app Next.js (pour les outils AI)
cd ../keep-notes && npm run dev

# 4. Redemarrer Claude Code - les outils sont disponibles !

Scenario 2 : Automatisation N8N

# 1. Lancer le serveur HTTP
MCP_REQUIRE_AUTH=true MCP_API_KEY=ma-cle node index-sse.js

# 2. Dans N8N, ajouter un noeud MCP
#    URL : http://IP_SERVEUR:3001/mcp
#    Headers : x-api-key: ma-cle

# 3. Importer un workflow pre-construit

Scenario 3 : Docker

# 1. Lancer tout l'ecosysteme
MCP_MODE=sse docker compose up -d

# 2. Verifier
curl http://localhost:3001/

# 3. Utiliser depuis n'importe quel client MCP

---

11. Depannage

Erreurs communes

Erreur	Cause	Solution
Cannot find package 'zod'	Dependance manquante	npm install zod
Unknown field 'labels' for include	Client Prisma obsolete	npx prisma generate --schema=../keep-notes/prisma/schema.prisma
Tool execution failed: ... Invalid prisma	Schema DB incompatibles	Regenerer le client Prisma
Outils AI retournent des erreurs	App Next.js non lancee	cd keep-notes && npm run dev
Port 3001 already in use	Port occupe	Changer avec PORT=3002
Aucune note retournee	USER_ID incorrect ou absent	Verifier l'ID ou le retirer pour auto-detection

Logs

# Mode stdio - les logs vont dans stderr
node index.js 2>mcp.log

# Mode HTTP - logs dans la console
node index-sse.js

# Verifier les sessions actives
curl http://localhost:3001/sessions

Regenerer le client Prisma

Si le schema de la base de donnees change dans l'app Next.js :

cd mcp-server
npx prisma generate --schema=../keep-notes/prisma/schema.prisma

Test de connectivite

# Test HTTP
curl -s http://localhost:3001/ | python3 -m json.tool

# Test d'initialisation MCP
curl -s -X POST http://localhost:3001/mcp \
  -H "Content-Type: application/json" \
  -H "Accept: application/json, text/event-stream" \
  -d '{"jsonrpc":"2.0","id":1,"method":"initialize","params":{"protocolVersion":"2024-11-05","capabilities":{},"clientInfo":{"name":"test","version":"1.0"}}}'

# Test d'appel d'outil (apres avoir recupere le session-id)
curl -s -X POST http://localhost:3001/mcp \
  -H "Content-Type: application/json" \
  -H "Accept: application/json, text/event-stream" \
  -H "mcp-session-id: VOTRE_SESSION_ID" \
  -d '{"jsonrpc":"2.0","id":2,"method":"tools/call","params":{"name":"get_notebooks","arguments":{}}}'

---

Resume des 34 outils

┌─────────────────────────────────────────────────────────────┐
│                    NOTES (12 outils)                         │
├─────────────────────────────────────────────────────────────┤
│  create_note          Creer une note                        │
│  get_notes            Lister les notes (filtres)            │
│  get_note             Lire une note par ID                  │
│  update_note          Modifier une note                     │
│  delete_note          Supprimer une note                    │
│  delete_all_notes     Supprimer TOUTES les donnees          │
│  search_notes         Rechercher par mot-cle                │
│  move_note            Deplacer vers un notebook             │
│  toggle_pin           Epingler/Destingler                   │
│  toggle_archive       Archiver/Desarchiver                  │
│  export_notes         Exporter en JSON                      │
│  import_notes         Importer depuis JSON                  │
├─────────────────────────────────────────────────────────────┤
│                   NOTEBOOKS (6 outils)                       │
├─────────────────────────────────────────────────────────────┤
│  create_notebook      Creer un notebook                     │
│  get_notebooks        Lister les notebooks                  │
│  get_notebook         Lire un notebook avec ses notes       │
│  update_notebook      Modifier un notebook                  │
│  delete_notebook      Supprimer (notes → Inbox)             │
│  reorder_notebooks    Reordonner les notebooks              │
├─────────────────────────────────────────────────────────────┤
│                    LABELS (4 outils)                         │
├─────────────────────────────────────────────────────────────┤
│  create_label         Creer un label                        │
│  get_labels           Lister les labels                     │
│  update_label         Modifier un label                     │
│  delete_label         Supprimer un label                    │
├─────────────────────────────────────────────────────────────┤
│                     AI (11 outils)                           │
├─────────────────────────────────────────────────────────────┤
│  generate_title_suggestions    Suggestions de titre         │
│  reformulate_text              Clarifier/Reduire/Ameliorer  │
│  generate_tags                 Generation de tags AI        │
│  suggest_notebook              Suggestion de notebook       │
│  get_notebook_summary          Resume AI d'un notebook      │
│  get_memory_echo               Connexions entre notes       │
│  get_note_connections          Notes liees a une note       │
│  dismiss_connection            Rejeter une connexion        │
│  fuse_notes                    Fusionner des notes          │
│  batch_organize                Organisation automatique     │
│  suggest_auto_labels           Suggestion de labels AI      │
├─────────────────────────────────────────────────────────────┤
│                  REMINDERS (1 outil)                         │
├─────────────────────────────────────────────────────────────┤
│  get_due_reminders    Rappels en retard                      │
└─────────────────────────────────────────────────────────────┘