sepehr/Momento
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
79fd6553b7e47febf53d6c951faea123bb6bc923
Momento/GUIDE.md
Sepehr Ramezani dbd49d6fcb
All checks were successful
Deploy to Production / Build and Deploy (push) Successful in 1m25s
Details
feat: 8 AI providers, rich text editor, agent notifications, UI contrast & font settings 
- Add DeepSeek, OpenRouter, Mistral, Z.AI, LM Studio as AI providers
  with editable model names via Combobox in admin settings
- Fix OpenRouter broken by normalizeProvider bug in config.ts
- Convert agent-created notes from Markdown to HTML (TipTap rich text)
- Add Notification model + in-app notifications for agent results
- Agent notification click opens the created note directly
- Add note count display on notebook and inbox headers
- Fix checklist toggle in card view (persist state via localCheckItems)
- Add checklist creation option in tabs/list view (dropdown on + button)
- Fix image description ENOENT error with HTTP fallback
- Improve UI contrast across all themes (input, border, checkbox visibility)
- Add font family setting (Inter vs System Default) in Appearance settings
- Fix CSS font-sans variable conflict (removed dead Geist references)
- Update README with new features and 8 providers

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>
2026-05-01 16:14:07 +02:00

996 lines
30 KiB
Markdown
Raw Blame History

# Memento - Guide d'utilisation complet
## Table des matieres
1. [Presentation](#presentation)
2. [Architecture](#architecture)
3. [Installation locale](#installation-locale)
4. [Deploiement Docker](#deploiement-docker)
5. [Configuration des providers IA](#configuration-des-providers-ia)
6. [Agents IA et Outils externes](#agents-ia-et-outils-externes)
7. [Serveur MCP (Model Context Protocol)](#serveur-mcp)
8. [Integrations N8N](#integrations-n8n)
9. [Configuration email (SMTP)](#configuration-email)
10. [Administration](#administration)
11. [Reference des variables d'environnement](#reference-des-variables-denvironnement)
12. [Commandes utiles](#commandes-utiles)
13. [Resolution des problemes](#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
```
Momento/
├── 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)
```bash
git clone https://github.com/votre-user/Momento.git
cd Momento
# 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
```bash
# 1. Cloner le depot
git clone https://github.com/votre-user/Momento.git
cd Momento/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)
```bash
git clone https://github.com/votre-user/Momento.git
cd Momento
# 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
```bash
# 1. Cloner le depot
git clone https://github.com/votre-user/Momento.git
cd Momento
# 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)
```bash
# 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)
```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)
```bash
# .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 :
```bash
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)
```bash
# .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...)
```bash
# .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 :
```bash
# 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 :**
```bash
# 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](https://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](https://jina.ai/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](https://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`) :
```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.
```bash
# 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
```bash
curl http://localhost:3001/
# {"name":"Memento MCP Server","version":"3.1.0","status":"running",...}
```
### Configuration MCP avancee
```bash
# .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
```bash
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
```bash
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
```bash
# .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
```bash
# .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
```bash
# 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
```bash
# 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
```bash
# 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
```bash
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 :
```bash
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
```bash
# 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 :
```bash
# 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](LICENSE) pour les details complets.
Reference in New Issue View Git Blame Copy Permalink