Momento/GUIDE.md

Memento - Guide d'utilisation complet

Table des matieres

1. Presentation
2. Architecture
3. Installation locale
4. Deploiement Docker
5. Configuration des providers IA
6. Agents IA et Outils externes
7. Serveur MCP (Model Context Protocol)
8. Integrations N8N
9. Configuration email (SMTP)
10. Administration
11. Reference des variables d'environnement
12. Commandes utiles
13. Resolution des problemes

---

Presentation

Memento est une application de prise de notes intelligente, inspiree de Google Keep, construite avec Next.js 16, React 19, TypeScript, Tailwind CSS 4, Prisma ORM 5 et PostgreSQL 16.

Fonctionnalites principales

Notes et organisation :

• Notes texte, checklists et Markdown (avec support LaTeX/KaTeX)
• Grille masonry responsive avec drag-and-drop
• Upload d'images avec preservation de la taille originale
• Notebooks et labels contextuels pour organiser les notes
• Partage de notes avec permissions
• Corbeille et archive

IA et automatisation :

• Recherche semantique (embeddings IA) + recherche plein texte
• Generation automatique de tags et suggestions de titre via IA
• Agents IA configurables avec instructions personnalisees
• Chat IA avec conversations persistees
• Memory Echo - decouverte de connexions entre notes
• Organisation automatique par batch et labels intelligents
• Workflows visuels - automate de creation de workflows (noeuds, triggers)
• Resume de notebooks genere par IA

Productivite :

• Systeme de rappels avec notifications et recurrence
• Mode sombre/clair avec preference systeme
• Export/import de donnees (JSON)
• PWA (Progressive Web App)
• Support i18n - 15 langues (FR, EN, AR, DE, ES, FA, HI, IT, JA, KO, NL, PL, PT, RU, ZH)

Outils avances :

• Canvas/Lab - tableau blanc avec dessin (Excalidraw)
• Flux RSS - integration de feeds RSS
• Serveur MCP - 22 outils pour integrer avec Claude Desktop, N8N, ou tout client MCP

Administration :

• Authentification NextAuth.js v5 (credentials, inscription, reset mot de passe)
• Panneau admin pour configurer les providers IA, SMTP, etc.
• Gestion des cles API MCP
• Pages settings : profil, apparence, donnees, MCP, IA

Stack technique

Composant	Technologie
Frontend	Next.js 16.1, React 19.2, TypeScript 5, Tailwind CSS 4
UI	shadcn/ui, Lucide React, Radix UI
Backend	Next.js Server Actions, API Routes
Base de donnees	PostgreSQL 16 via Prisma ORM 5.22
Authentification	NextAuth.js v5
IA	Vercel AI SDK (OpenAI, Ollama, Custom OpenAI-compatible)
MCP	@modelcontextprotocol/sdk v3.1
Email	Nodemailer (SMTP) ou Resend
Canvas	Excalidraw
Docker	Docker Compose (postgres + memento-note + mcp-server + ollama)

---

Architecture

Memento/
├── docker-compose.yml           # Orchestration multi-conteneurs
├── .env.docker.example          # Template config Docker
├── GUIDE.md                     # Ce guide (FR)
├── GUIDE.en.md                  # English guide
├── LICENSE                      # Apache 2.0 + Commons Clause
├── memento-note/                # Application Next.js
│   ├── app/                     # App Router (pages, actions, API)
│   │   ├── (auth)/              # Login, register, reset password
│   │   ├── (main)/              # Dashboard, admin, archive, trash, chat,
│   │   │                        # agents, reminders, lab, settings, support
│   │   ├── actions/             # Server actions (auth, notes, AI, admin)
│   │   └── api/                 # REST API routes
│   ├── components/              # Composants React
│   ├── lib/                     # Logique metier
│   │   ├── ai/                  # Factory IA + providers + services
│   │   │   ├── factory.ts       # Factory pattern (ollama/openai/custom)
│   │   │   ├── providers/       # Providers: ollama, openai, custom-openai
│   │   │   └── services/        # Agent executor, RSS, title, batch, etc.
│   │   ├── prisma.ts            # Client DB
│   │   ├── mail.ts              # Envoi d'emails (SMTP + Resend)
│   │   ├── config.ts            # Config depuis DB (SystemConfig)
│   │   └── i18n/                # Detection langue + provider
│   ├── prisma/                  # Schema + migrations PostgreSQL
│   ├── locales/                 # 15 fichiers i18n (fr.json, en.json, etc.)
│   ├── Dockerfile               # Build multi-stage (node:22-bullseye-slim)
│   ├── docker-compose.yml       # Standalone (postgres + app)
│   └── .env.example             # Template dev local
├── mcp-server/                  # Serveur MCP (22 outils)
│   ├── index.js                 # Mode stdio (Claude Desktop)
│   ├── index-sse.js             # Mode HTTP Streamable (N8N, remote)
│   ├── tools.js                 # Definitions des 22 outils MCP
│   ├── auth.js                  # Authentification API keys
│   ├── Dockerfile               # Conteneur MCP (node:20-alpine)
│   └── .env.example             # Template MCP
└── n8n-memento-workflow.json    # Workflow N8N preconfigure

Flux de donnees

Navigateur -> Next.js App Router
              |-- Server Components (lecture)
              |-- Server Actions (ecriture)
              `-- API Routes (REST)
                      |
                  Prisma ORM
                      |
                  PostgreSQL 16
                      ^
              MCP Server (stdio ou HTTP Streamable)
                      ^
              Claude Desktop / N8N / Client MCP

---

Installation locale

Prerequis

• Node.js 20+ (22 recommande)
• PostgreSQL 16
• npm

Installation rapide (script interactif)

git clone https://github.com/votre-user/Memento.git
cd Memento

# macOS / Linux
./scripts/deploy-local.sh

# Windows PowerShell
.\scripts\deploy-local.ps1

Le script va :

1. Verifier que Node.js, npm et PostgreSQL sont installes
2. Demander la configuration (base de donnees, email admin, provider IA, etc.)
3. Generer le .env avec des secrets auto-generes
4. Installer les dependances et lancer les migrations

Etapes manuelles

# 1. Cloner le depot
git clone https://github.com/votre-user/Memento.git
cd Memento/memento-note

# 2. Installer les dependances
npm install --legacy-peer-deps

# 3. Configurer l'environnement
cp .env.example .env
# Editer .env avec vos valeurs (DATABASE_URL, NEXTAUTH_SECRET, ADMIN_EMAIL, etc.)

# 4. Creer la base de donnees et appliquer les migrations
npx prisma migrate dev

# 5. Lancer en developpement
npm run dev

# 6. Acceder a l'application
# http://localhost:3000

Premier lancement

1. Inscrivez-vous avec l'email defini dans ADMIN_EMAIL
2. Ce compte obtient automatiquement le role ADMIN
3. Accedez au panneau admin : http://localhost:3000/admin/settings

---

Deploiement Docker

Installation rapide (script interactif)

git clone https://github.com/votre-user/Memento.git
cd Memento

# macOS / Linux
./scripts/deploy-docker.sh

# Windows PowerShell
.\scripts\deploy-docker.ps1

Le script va :

1. Verifier que Docker et Docker Compose sont installes
2. Demander la configuration (URL, email admin, PostgreSQL, provider IA, MCP, email, Ollama, recherche web)
3. Auto-generer NEXTAUTH_SECRET et POSTGRES_PASSWORD
4. Construire et demarrer tous les conteneurs
5. Lancer les migrations de base de donnees

Options du script de deploiement :

Commande	Description
./scripts/deploy-docker.sh	Setup complet (env + build + deploy)
./scripts/deploy-docker.sh --env-only	Generer .env.docker seulement
./scripts/deploy-docker.sh --build	Build + deploy (requiert .env.docker existant)
./scripts/deploy-docker.sh --stop	Arreter tous les conteneurs
./scripts/deploy-docker.sh --logs	Afficher les logs des conteneurs

Setup manuel

# 1. Cloner le depot
git clone https://github.com/votre-user/Memento.git
cd Memento

# 2. Configurer l'environnement
cp .env.docker.example .env.docker
nano .env.docker
# Modifier NEXTAUTH_URL, NEXTAUTH_SECRET et ADMIN_EMAIL (obligatoire)

# 3. Lancer les conteneurs
docker compose up -d

# 4. Verifier que tout fonctionne
docker compose ps
docker compose logs -f memento-note

Avec Ollama (IA locale)

# Ajouter le profile ollama
docker compose --profile ollama up -d

# Tirer un modele
docker exec memento-ollama ollama pull granite4
docker exec memento-ollama ollama pull embeddinggemma

Variables Docker obligatoires

Variable	Description
NEXTAUTH_URL	URL publique de l'app (ex: http://192.168.1.190:3000)
NEXTAUTH_SECRET	Secret JWT - generer avec openssl rand -base64 32
ADMIN_EMAIL	Email qui obtient automatiquement le role ADMIN a l'inscription

Ports utilises

Service	Port	Description
memento-note	3000	Application web
PostgreSQL	5432	Base de donnees
MCP Server	3001	Mode HTTP Streamable
Ollama	11434	IA locale (optionnel)

Reverse Proxy (Nginx)

server {
    listen 80;
    server_name notes.yourdomain.com;

    location / {
        proxy_pass http://localhost:3000;
        proxy_http_version 1.1;
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection 'upgrade';
        proxy_set_header Host $host;
        proxy_cache_bypass $http_upgrade;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;
    }

    client_max_body_size 10M;
}

---

Configuration des providers IA

Memento supporte 3 providers IA, configurables independamment pour chaque fonctionnalite (tags, embeddings, chat).

Provider 1 : Ollama (IA locale, gratuit)

# .env.docker
AI_PROVIDER_TAGS=ollama
AI_PROVIDER_EMBEDDING=ollama
OLLAMA_BASE_URL="http://ollama:11434"
AI_MODEL_TAGS="granite4:latest"
AI_MODEL_EMBEDDING="embeddinggemma:latest"

Lancer avec le profile ollama :

docker compose --profile ollama up -d
docker exec memento-ollama ollama pull granite4
docker exec memento-ollama ollama pull embeddinggemma

Ressources recommandees : 8 Go RAM, 4 CPU

Provider 2 : OpenAI (cloud, payant)

# .env.docker
AI_PROVIDER_TAGS=openai
AI_PROVIDER_EMBEDDING=openai
OPENAI_API_KEY="sk-votre-cle-ici"
AI_MODEL_TAGS="gpt-4o-mini"
AI_MODEL_EMBEDDING="text-embedding-3-small"

Provider 3 : Custom (OpenRouter, Groq, Together, Mistral...)

# .env.docker
AI_PROVIDER_TAGS=custom
AI_PROVIDER_EMBEDDING=custom
CUSTOM_OPENAI_API_KEY="votre-cle-api"
CUSTOM_OPENAI_BASE_URL="https://openrouter.ai/api/v1"
AI_MODEL_TAGS="openai/gpt-4o-mini"
AI_MODEL_EMBEDDING="openai/text-embedding-3-small"

Provider	URL de base
OpenRouter	https://openrouter.ai/api/v1
Groq	https://api.groq.com/openai/v1
Together AI	https://api.together.xyz/v1
Mistral	https://api.mistral.ai/v1

Configuration mixte

Vous pouvez utiliser des providers differents pour chaque fonctionnalite :

# Ollama pour les tags, OpenAI pour les embeddings
AI_PROVIDER_TAGS=ollama
AI_PROVIDER_EMBEDDING=openai
OLLAMA_BASE_URL="http://ollama:11434"
OPENAI_API_KEY="sk-..."
AI_MODEL_TAGS="granite4:latest"
AI_MODEL_EMBEDDING="text-embedding-3-small"

Chaine de fallback IA

Chaque fonctionnalite IA a une chaine de fallback :

• Tags : AI_PROVIDER_TAGS -> AI_PROVIDER
• Embeddings : AI_PROVIDER_EMBEDDING -> AI_PROVIDER_TAGS -> AI_PROVIDER
• Chat : AI_PROVIDER_CHAT -> AI_PROVIDER_TAGS -> AI_PROVIDER_EMBEDDING -> AI_PROVIDER

Configuration via le panneau admin

Les providers IA peuvent aussi etre configures depuis l'interface :

1. Se connecter en admin
2. Aller sur /admin/settings
3. Section "AI Settings"
4. Choisir le provider, le modele, et entrer la cle API
5. Sauvegarder

Note : Les parametres du panneau admin (stockes en DB) sont prioritaires sur les variables d'environnement.

---

Agents IA et Outils externes

Memento inclut un systeme d'agents IA configurables qui peuvent executer des actions automatisees en utilisant des outils externes.

Types d'agents

Type	Description	Outils par defaut
Scraper	Scrape des pages web et cree des notes	web_scrape, note_create
Researcher	Recherche web approfondie + synthese	web_search, web_scrape, note_search, note_create
Monitor	Surveille un notebook et analyse les notes	note_search, note_read, note_create
Custom	Agent libre avec instructions personnalisees	configurable

Outils disponibles

Outil	Externe	Description	Configuration requise
web_search	Oui	Recherche web (SearXNG ou Brave)	URL SearXNG ou cle Brave
web_scrape	Oui	Scrape une page web en Markdown (Jina Reader)	Cle Jina (optionnel)
url_fetch	Non	Recupere du contenu JSON/CSV/texte	Aucune
note_search	Non	Recherche par mots-cles dans les notes	Aucune
note_read	Non	Lire une note par ID	Aucune
note_create	Non	Creer une nouvelle note	Aucune
memory_search	Non	Rechercher dans l'historique des executions	Aucune

Recherche web - SearXNG (recommande)

SearXNG est un moteur de metarecherche open-source et auto-hberge. C'est le provider par defaut pour la recherche web.

Installation de SearXNG :

# Via Docker
docker run -d --name searxng \
  -p 8080:8080 \
  -e SEARXNG_BASE_URL=http://localhost:8080 \
  --restart unless-stopped \
  searxng/searxng:latest

Configuration dans Memento :

1. Aller dans /admin/settings
2. Section "Tools"
3. Web Search Provider : selectionner SearXNG (Self-hosted)
4. SearXNG URL : http://localhost:8080 (ou l'URL de votre instance)
5. Sauvegarder

En Docker (reseau partage) :

Si SearXNG et Memento sont dans le meme reseau Docker, utiliser le nom du service :

http://searxng:8080

Recherche web - Brave Search (alternative)

Brave Search est une API payante comme alternative a SearXNG.

1. Creer un compte sur brave.com/search/api
2. Obtenir une cle API
3. Dans /admin/settings > Tools : selectionner Brave Search API et entrer la cle

Les deux providers peuvent etre utilises en meme temps en selectionnant Both.

Scraping web - Jina Reader (optionnel)

L'outil web_scrape utilise Jina Reader pour convertir des pages web en Markdown. Fonctionne sans cle API (avec limites de debit), ou avec une cle pour des limites plus elevees.

1. Creer un compte sur jina.ai
2. Obtenir une cle API
3. Dans /admin/settings > Tools : entrer la cle Jina

Utilisation des agents

1. Aller sur /agents
2. Cliquer sur "Nouvel agent" ou choisir un template
3. Configurer :
   • Nom et description
   • Type (Scraper, Researcher, Monitor, Custom)
   • Instructions (prompt systeme)
   • Outils (selectionner les outils actifs)
   • Frequence (manuel, hourly, daily, weekly, monthly)
   • Notebook cible (ou sauvegarder les resultats)
   • URLs sources (pour les scrapers)
4. Sauvegarder et executer

Les agents sont aussi disponibles dans le Chat IA : si la recherche web est activee, le chat utilise automatiquement les outils web_search et web_scrape.

---

Serveur MCP

Le serveur MCP (Model Context Protocol, v3.1) permet aux agents IA d'interagir avec vos notes via un protocole standardise.

Outils disponibles (22 outils)

Notes (11) :

Outil	Description
create_note	Creer une nouvelle note
get_notes	Recuperer les notes
get_note	Recuperer une note specifique
update_note	Modifier une note existante
delete_note	Supprimer une note
search_notes	Rechercher des notes par contenu
move_note	Deplacer une note vers un notebook
toggle_pin	Epingler/Depingler une note
toggle_archive	Archiver/Desarchiver une note
export_notes	Exporter les notes en JSON
import_notes	Importer des notes depuis JSON

Notebooks (6) :

Outil	Description
create_notebook	Creer un notebook
get_notebooks	Lister les notebooks
get_notebook	Details d'un notebook
update_notebook	Modifier un notebook
delete_notebook	Supprimer un notebook
reorder_notebooks	Reordonner les notebooks

Labels (4) :

Outil	Description
create_label	Creer un label
get_labels	Lister les labels
update_label	Modifier un label
delete_label	Supprimer un label

Rappels (1) :

Outil	Description
get_due_reminders	Recuperer les rappels dus

Mode stdio (Claude Desktop, Cline)

Communication via stdin/stdout, ideal pour les clients locaux.

Configuration Claude Desktop (claude_desktop_config.json) :

{
  "mcpServers": {
    "memento": {
      "command": "docker",
      "args": ["exec", "-i", "memento-mcp", "node", "index.js"]
    }
  }
}

Mode HTTP Streamable (N8N, remote)

Communication via HTTP Streamable, accessible sur le reseau. L'authentification par cle API est activee par defaut dans Docker.

Les cles API sont generees depuis Parametres > MCP dans l'interface Memento.

# docker-compose.yml (preconfigure)
MCP_MODE=sse
MCP_REQUIRE_AUTH=true

Le serveur sera accessible sur http://localhost:3001/mcp.

Endpoints HTTP

Endpoint	Methode	Description
/	GET	Health check
/mcp	GET/POST	Endpoint MCP principal (Streamable HTTP)
/sse	GET/POST	Legacy (redirige vers /mcp)
/sessions	GET	Sessions actives

Verification

curl http://localhost:3001/
# {"name":"Memento MCP Server","version":"3.1.0","status":"running",...}

Configuration MCP avancee

# .env.docker
MCP_LOG_LEVEL=info          # debug, info, warn, error
MCP_REQUEST_TIMEOUT=30000   # Timeout en ms
MCP_REQUIRE_AUTH=true       # Authentification par cle API
APP_BASE_URL="http://localhost:3000"  # URL de l'app pour les liens

---

Integrations N8N

Configuration du noeud MCP Client

1. Ajouter un noeud "MCP Client" dans N8N
2. Selectionner "HTTP Streamable" comme transport
3. Configurer l'endpoint : http://memento-mcp:3001/mcp (Docker) ou http://VOTRE_IP:3001/mcp
4. Ajouter une Header Auth : x-api-key = votre cle API (generee depuis Parametres > MCP)

Workflows preconfigures

Le fichier n8n-memento-workflow.json contient un workflow pret a l'emploi pour :

• Creer des notes automatiquement
• Rechercher des notes
• Archiver les notes anciennes

Exemples d'utilisation

Creer une note via curl

curl -X POST http://localhost:3001/mcp \
  -H "Content-Type: application/json" \
  -d '{
    "jsonrpc": "2.0",
    "id": 1,
    "method": "tools/call",
    "params": {
      "name": "create_note",
      "arguments": {
        "title": "Ma note",
        "content": "Contenu de la note"
      }
    }
  }'

Lister les outils disponibles

curl -X POST http://localhost:3001/mcp \
  -H "Content-Type: application/json" \
  -d '{
    "jsonrpc": "2.0",
    "id": 2,
    "method": "tools/list",
    "params": {}
  }'

---

Configuration email

L'email est necessaire pour la reinitialisation de mot de passe et les rappels. Deux providers sont supportes.

Option 1 : SMTP

# .env.docker
SMTP_HOST="smtp.gmail.com"
SMTP_PORT="587"
SMTP_USER="votre-email@gmail.com"
SMTP_PASS="votre-mot-de-passe-app"
SMTP_FROM="noreply@votre-domaine.com"

Provider	Host	Port
Gmail	smtp.gmail.com	587
Outlook	smtp.office365.com	587
SendGrid	smtp.sendgrid.net	587
Mailgun	smtp.mailgun.org	587

Option 2 : Resend

# .env.docker
RESEND_API_KEY="re_votre-cle"

Mode auto

En mode auto (defaut), Memento essaie Resend en premier, puis SMTP en fallback.

Les parametres SMTP_SECURE et SMTP_IGNORE_CERT sont configurables depuis le panneau admin (stockes en DB).

---

Administration

Panneau admin

Accessibles uniquement aux utilisateurs avec le role admin.

Le premier utilisateur inscrit avec l'email defini dans ADMIN_EMAIL obtient automatiquement le role ADMIN. Assurez-vous de definir cette variable dans votre .env ou .env.docker avant le deploiement.

URL : /admin/settings

Sections configurables

1. AI Settings - Provider, modele, cle API pour tags, embeddings et chat
2. Email Settings - Configuration SMTP
3. General Settings - Inscription publique activee/desactivee

Pages settings utilisateur

Page	Route	Description
Profil	/settings/profile	Nom, email, mot de passe
Apparence	/settings/appearance	Theme, langue
Donnees	/settings/data	Export/import, suppression
MCP	/settings/mcp	Configuration serveur MCP
IA	/settings/ai	Preferences IA

Gestion des utilisateurs

• Les utilisateurs sont geres via /admin
• Le premier utilisateur inscrit est automatiquement admin
• L'inscription peut etre desactivee avec ALLOW_REGISTRATION=false

---

Reference des variables d'environnement

Fichiers .env

Fichier	Usage
.env.docker	Configuration Docker (lu par docker-compose via env_file)
.env.docker.example	Template pour .env.docker
memento-note/.env	Configuration dev local
memento-note/.env.example	Template pour dev local
mcp-server/.env	Configuration du serveur MCP
mcp-server/.env.example	Template pour MCP

Variables completes

Core (obligatoire)

Variable	Defaut	Description
DATABASE_URL	-	Connection string PostgreSQL
NEXTAUTH_SECRET	-	Secret JWT (openssl rand -base64 32)
NEXTAUTH_URL	http://localhost:3000	URL publique de l'app
ADMIN_EMAIL	-	Email qui obtient automatiquement le role ADMIN a l'inscription

Inscription et admin

Variable	Defaut	Description
ALLOW_REGISTRATION	true	Autoriser l'inscription publique
ADMIN_EMAIL	-	Email qui obtient le role ADMIN a l'inscription

PostgreSQL (Docker)

Variable	Defaut	Description
POSTGRES_USER	memento	Utilisateur PostgreSQL
POSTGRES_PASSWORD	memento	Mot de passe PostgreSQL
POSTGRES_DB	memento	Nom de la base
POSTGRES_PORT	5432	Port expose

IA - Tags

Variable	Defaut	Description
AI_PROVIDER_TAGS	-	Provider pour tags (ollama, openai, custom)
AI_MODEL_TAGS	granite4:latest	Modele pour tags

IA - Embeddings

Variable	Defaut	Description
AI_PROVIDER_EMBEDDING	fallback Tags	Provider pour embeddings
AI_MODEL_EMBEDDING	embeddinggemma:latest	Modele pour embeddings

IA - Chat

Variable	Defaut	Description
AI_PROVIDER_CHAT	fallback Tags->Embedding	Provider pour chat
AI_MODEL_CHAT	fallback Tags	Modele pour chat

IA - OpenAI

Variable	Description
OPENAI_API_KEY	Cle API OpenAI (sk-...)

IA - Ollama

Variable	Defaut	Description
OLLAMA_BASE_URL	-	URL du service Ollama

IA - Custom provider

Variable	Description
CUSTOM_OPENAI_API_KEY	Cle API du provider
CUSTOM_OPENAI_BASE_URL	URL de base du provider

MCP Server

Variable	Defaut	Description
MCP_MODE	stdio	Mode (stdio ou sse)
MCP_PORT	3001	Port HTTP Streamable
MCP_LOG_LEVEL	info	Niveau de log
MCP_REQUEST_TIMEOUT	30000	Timeout (ms)
MCP_REQUIRE_AUTH	false	Activer authentification
MCP_API_KEY	-	Cle API pour auth
APP_BASE_URL	http://localhost:3000	URL de l'app
USER_ID	-	Filtrer par utilisateur

Email

Variable	Defaut	Description
SMTP_HOST	-	Serveur SMTP
SMTP_PORT	587	Port SMTP
SMTP_USER	-	Utilisateur SMTP
SMTP_PASS	-	Mot de passe SMTP
SMTP_FROM	noreply@memento.app	Email expediteur
RESEND_API_KEY	-	Cle API Resend

Application

Variable	Defaut	Description
ALLOW_REGISTRATION	true	Autoriser l'inscription publique
NODE_ENV	development	Environnement
PORT	3000	Port de l'app
HOSTNAME	0.0.0.0	Host d'ecoute

---

Commandes utiles

Scripts de deploiement

# Deploiement Docker (macOS / Linux)
./scripts/deploy-docker.sh              # Setup complet (env + build + deploy)
./scripts/deploy-docker.sh --env-only   # Generer .env.docker interactivement
./scripts/deploy-docker.sh --build      # Build + deploy (requiert .env.docker existant)
./scripts/deploy-docker.sh --stop       # Arreter tous les conteneurs
./scripts/deploy-docker.sh --logs       # Afficher les logs des conteneurs

# Deploiement local (macOS / Linux)
./scripts/deploy-local.sh               # Setup complet (env + install + migrate)
./scripts/deploy-local.sh --env-only    # Generer .env interactivement
./scripts/deploy-local.sh --start       # Demarrer l'app (mode dev ou prod)
./scripts/deploy-local.sh --migrate     # Lancer les migrations
./scripts/deploy-local.sh --install     # Installer les dependances npm

# Windows PowerShell
.\scripts\deploy-docker.ps1             # Setup Docker complet
.\scripts\deploy-docker.ps1 -EnvOnly    # Generer .env.docker seulement
.\scripts\deploy-docker.ps1 -Build      # Build + deploy
.\scripts\deploy-docker.ps1 -Stop       # Arreter les conteneurs
.\scripts\deploy-docker.ps1 -Logs       # Afficher les logs

.\scripts\deploy-local.ps1              # Setup local complet
.\scripts\deploy-local.ps1 -EnvOnly     # Generer .env seulement
.\scripts\deploy-local.ps1 -Start       # Demarrer l'app
.\scripts\deploy-local.ps1 -Migrate     # Lancer les migrations
.\scripts\deploy-local.ps1 -Install     # Installer les dependances

Docker

# Demarrer tous les services
docker compose up -d

# Avec Ollama
docker compose --profile ollama up -d

# Voir les logs
docker compose logs -f
docker compose logs -f memento-note    # App seulement
docker compose logs -f mcp-server      # MCP seulement

# Statut des services
docker compose ps

# Reconstruire apres modification
docker compose down
docker compose build --no-cache
docker compose up -d

# Acceder a un conteneur
docker compose exec memento-note sh
docker compose exec mcp-server sh

# Arreter et supprimer les volumes (ATTENTION : perte de donnees)
docker compose down -v

Base de donnees

# Lancer Prisma Studio (GUI pour la DB)
cd memento-note
npx prisma studio

# Creer une migration
npx prisma migrate dev --name nom_de_la_migration

# Appliquer les migrations en production
npx prisma migrate deploy

# Regenerer le client Prisma
npx prisma generate

Developpement

cd memento-note

# Dev avec hot-reload
npm run dev

# Build production
npm run build
npm start

# Linter
npm run lint

deploy.sh (script de deploiement - legacy)

L'ancien script memento-note/deploy.sh reste disponible pour le Docker Compose standalone :

cd memento-note
chmod +x deploy.sh

./deploy.sh build     # Construire l'image
./deploy.sh start     # Demarrer les conteneurs
./deploy.sh logs      # Voir les logs
./deploy.sh backup    # Sauvegarder la DB
./deploy.sh update    # Mettre a jour l'app

---

Resolution des problemes

Erreur : ECONNREFUSED 127.0.0.1:11434

Cause : L'app essaie d'acceder a Ollama via localhost au lieu du service Docker.

Solution : Verifier que .env.docker contient :

OLLAMA_BASE_URL="http://ollama:11434"

Le provider IA ne change pas dans l'admin

1. Sauvegarder les modifications dans l'admin
2. Rafraichir la page (F5)
3. Verifier la valeur affichee sous le dropdown

Docker ne demarre pas

# Verifier les logs
docker compose logs memento-note

# Verifier la DB
docker compose exec postgres pg_isready -U memento

# Reconstruire
docker compose build --no-cache memento-note

Mot de passe oublie sans SMTP

Si vous n'avez pas configure l'email, vous pouvez reinitialiser le mot de passe manuellement :

# Se connecter a la DB
docker compose exec postgres psql -U memento -d memento

# ou en local
cd memento-note
npx prisma studio

Les embeddings ne se generent pas

1. Verifier que le provider d'embeddings est correctement configure
2. Verifier que le modele d'embedding est disponible
3. En admin, lancer la regeneration manuelle des embeddings

---

Licence

Apache License 2.0 avec Commons Clause Restriction. Usage personnel et educatif libre. Usage commercial interdit sans autorisation ecrite de l'auteur. Voir le fichier LICENSE pour les details complets.