Mon Flux de Travail Piloté par l'IA : Intégration de MCP, Docker et N8N pour Obsidian

Objectif

Automatiser l'organisation et le traitement des notes Obsidian à l'aide d'une IA accessible via API, orchestré avec Docker, MCP (Modular Copilot Platform), et les flux de travail N8N.

Pourquoi ce Flux de Travail ?

Le Problème

Défis de la Gestion Manuelle des Notes : - Notes éparpillées sur plusieurs sujets - Langue incohérente (mélange Français/Anglais) - Aucune catégorisation automatisée - Organisation manuelle chronophage - Difficile de trouver du contenu connexe

La Solution

Automatisation Pilotée par l'IA : - Organisation automatique des notes par thème - Détection et traduction de la langue - Regroupement intelligent du contenu - Génération automatisée d'index - Flux de travail de traitement planifiés

Prérequis

Exigences Logicielles

Outils Essentiels : - Docker installé et en cours d'exécution - MCP (Modular Copilot Platform) déployé - N8N installé (via Docker ou autonome) - Coffre-fort Obsidian accessible localement

Outils Optionnels : - Modèle LLM (Mistral, Llama, etc.) - Ollama pour l'hébergement de modèles locaux - Git pour le contrôle de version

Aperçu de l'Architecture

Obsidian Vault (Markdown Files)
    ↓
N8N Workflow (File Reader)
    ↓
MCP API (AI Processing)
├── Organize by theme
├── Translate content
├── Generate summaries
└── Create indexes
    ↓
N8N Workflow (File Writer)
    ↓
Obsidian Vault (Organized Files)

Étape 1 : Déployer MCP avec Docker

Démarrage Rapide

# Pull and run MCP container
docker run -d \
  --name mcp \
  -p 5000:5000 \
  -v $(pwd)/mcp_data:/app/data \
  ghcr.io/modularcopilot/mcp:latest

# Verify MCP is running
curl http://localhost:5000/health

# Expected response:
# {"status": "healthy", "version": "1.0.0"}

# docker-compose.yml
version: '3.8'

services:
  mcp:
    image: ghcr.io/modularcopilot/mcp:latest
    container_name: mcp-server
    restart: unless-stopped
    ports:
      - "5000:5000"
    volumes:
      - ./mcp_data:/app/data
      - ./models:/app/models
    environment:
      - MCP_MODEL=mistral:7b
      - MCP_API_PORT=5000
      - OLLAMA_HOST=http://host.docker.internal:11434
    networks:
      - homelab

  ollama:
    image: ollama/ollama:latest
    container_name: ollama
    restart: unless-stopped
    ports:
      - "11434:11434"
    volumes:
      - ollama_data:/root/.ollama
    networks:
      - homelab

networks:
  homelab:
    driver: bridge

volumes:
  ollama_data:

# Deploy services
docker-compose up -d

# Check logs
docker-compose logs -f mcp

# Pull model in Ollama
docker exec ollama ollama pull mistral:7b

Vérifier l'API MCP

# Test API endpoint
curl -X POST http://localhost:5000/api/prompt \
  -H "Content-Type: application/json" \
  -d '{
    "prompt": "Summarize this text: Proxmox is a virtualization platform.",
    "model": "mistral:7b"
  }'

Étape 2 : Préparer les Prompts de l'IA

Modèles d'Exemples de Prompts

Organiser les Notes par Langue :

{
  "prompt": "Unifiez toutes mes notes Obsidian en anglais. Traduisez les titres français, regroupez le contenu similaire et créez un index thématique."
}

Catégoriser les Notes :

{
  "prompt": "Analysez ces notes Obsidian et catégorisez-les en : Infrastructure, Sécurité, Automatisation et Référence. Retournez un JSON structuré."
}

Générer un Résumé :

{
  "prompt": "Créez un résumé concis (max 100 mots) de cet article technique tout en préservant les commandes et configurations clés."
}

Extraire les Tags :

{
  "prompt": "Extrayez les tags pertinents de cette note. Retournez des tags séparés par des virgules adaptés au frontmatter YAML d'Obsidian."
}

Étape 3 : Créer le Flux de Travail N8N

Composants du Flux de Travail

Structure Complète du Flux de Travail :

1. Déclencheur Planifié (Quotidien à 2h du matin)
    ↓
2. Lire les Fichiers Obsidian
    ↓
3. Filtrer (Seulement les fichiers .md)
    ↓
4. Extraire le Frontmatter YAML
    ↓
5. Requête HTTP vers MCP
    ↓
6. Traiter la Réponse de l'IA
    ↓
7. Mettre à Jour/Créer des Fichiers Organisés
    ↓
8. Envoyer une Notification (Telegram/Email)

Configuration du Flux de Travail

Nœud 1 : Déclencheur Planifié

{
  "node": "Schedule Trigger",
  "type": "n8n-nodes-base.cron",
  "parameters": {
    "rule": {
      "interval": [
        {
          "field": "cronExpression",
          "expression": "0 2 * * *"
        }
      ]
    }
  }
}

Nœud 2 : Lire les Fichiers

{
  "node": "Read Files",
  "type": "n8n-nodes-base.readBinaryFiles",
  "parameters": {
    "filePath": "/path/to/obsidian/vault",
    "filePattern": "*.md"
  }
}

Nœud 3 : Requête HTTP vers MCP

{
  "node": "MCP API Call",
  "type": "n8n-nodes-base.httpRequest",
  "parameters": {
    "method": "POST",
    "url": "http://localhost:5000/api/prompt",
    "authentication": "none",
    "sendHeaders": true,
    "headerParameters": {
      "parameters": [
        {
          "name": "Content-Type",
          "value": "application/json"
        }
      ]
    },
    "sendBody": true,
    "bodyParameters": {
      "parameters": [
        {
          "name": "prompt",
          "value": "Organize my notes Obsidian by theme and language."
        },
        {
          "name": "notes",
          "value": "={{ $json[\"content\"] }}"
        }
      ]
    }
  }
}

Nœud 4 : Écrire un Fichier

{
  "node": "Save Organized Notes",
  "type": "n8n-nodes-base.writeFile",
  "parameters": {
    "fileName": "/vault/Index/organization.md",
    "data": "={{ $json[\"response\"] }}"
  }
}

Étape 4 : Configuration de la Requête HTTP

Configuration Détaillée de la Requête

Méthode : POST

URL : http://localhost:5000/api/prompt

En-têtes :

{
  "Content-Type": "application/json",
  "Authorization": "Bearer YOUR_MCP_API_KEY"
}

Corps :

{
  "prompt": "Organize mes notes Obsidian par thème et langue.",
  "notes": "{{ $json[\"content\"] }}",
  "options": {
    "temperature": 0.7,
    "max_tokens": 2048,
    "output_format": "markdown"
  }
}

Traitement de la Réponse

Réponse Attendue :

{
  "status": "success",
  "organized_content": "# Infrastructure\n\n## Proxmox\n- Note 1\n- Note 2\n\n# Security\n...",
  "metadata": {
    "notes_processed": 45,
    "categories_created": 6,
    "languages_detected": ["en", "fr"]
  }
}

Étape 5 : Enregistrer les Résultats dans Obsidian

Stratégie d'Organisation des Fichiers

Structure des Répertoires :

Vault/
├── Index/
│   ├── organization.md (auto-generated)
│   ├── by-theme.md
│   └── by-language.md
├── Infrastructure/
│   ├── EN/
│   └── FR/
├── Security/
│   ├── EN/
│   └── FR/
└── Automation/
    ├── EN/
    └── FR/

Modèle de Fichier Index

# 📚 Index d'Organisation Automatisé
*Généré: {{date}}*

## Par Thème
[[Infrastructure]] | [[Security]] | [[Automation]] | [[Reference]]

## Par Langue
🇬🇧 [[Notes en Anglais]] | 🇫🇷 [[Notes en Français]]

## Statistiques
- Nombre total de notes: {{total_count}}
- Catégories: {{category_count}}
- Dernière mise à jour: {{timestamp}}

---
*Automatisé par le flux de travail MCP + N8N*

Conseils et Meilleures Pratiques

Utiliser des Tags de Langue

Dans les Notes Obsidian :

---
tags: [homelab, #en]
language: en
---

# Ma Note d'Infrastructure
Contenu ici...

Créer un Index Multilingue

Structure de l'Index :

# 🌍 Index Multilingue

## Infrastructure
- 🇬🇧 [[Proxmox Setup EN]]
- 🇫🇷 [[Installation Proxmox FR]]

## Sécurité
- 🇬🇧 [[pfSense Configuration EN]]
- 🇫🇷 [[Configuration pfSense FR]]

Améliorer les Prompts

Exemples de Prompts Avancés :

{
  "prompt": "Organisez les notes par thème et par langue. Pour chaque note:\n1. Détecter la langue\n2. Attribuer une catégorie\n3. Générer 3-5 tags\n4. Créer un résumé d'une phrase\n5. Lier les notes connexes\nRetournez un markdown structuré."
}

Fonctionnalités Avancées du Flux de Travail

Traitement Conditionnel

Traiter Seulement les Fichiers Modifiés :

// In N8N Function node
const lastRun = $node["Get Last Run"].json.timestamp;
const fileModified = new Date($json.modified);

if (fileModified > lastRun) {
  return $json; // Process this file
}

return null; // Skip this file

Gestion des Erreurs

Logique de Nouvelle Tentative :

{
  "node": "Error Handler",
  "onError": "continueErrorOutput",
  "retryOnFail": true,
  "maxTries": 3,
  "waitBetweenTries": 1000
}

Notification

Notification Telegram :

{
  "node": "Send Summary",
  "type": "n8n-nodes-base.telegram",
  "parameters": {
    "chatId": "YOUR_CHAT_ID",
    "text": "✅ Notes organisées !\n\nProcessed: {{notes_count}}\nCategories: {{categories}}\nTemps: {{duration}}s"
  }
}

Ressources

Documentation

Exemples de Flux de Travail

Dépôt GitHub :

git clone https://github.com/username/obsidian-ai-workflows
cd obsidian-ai-workflows/n8n

Importer dans N8N :

Paramètres → Importer à partir d'un Fichier
→ Sélectionner workflow.json
→ Activer le flux de travail

Dépannage

Problèmes de Connexion MCP

# Check MCP is running
docker ps | grep mcp

# View logs
docker logs -f mcp-server

# Test API
curl http://localhost:5000/health

N8N ne peut pas Atteindre MCP

# If MCP is in Docker, use docker network
docker network inspect homelab

# Or use host network mode
docker run --network host mcp

Erreurs de Permission de Fichier

# Fix Obsidian vault permissions
chmod -R 755 /path/to/vault

# For Docker volume access
chown -R 1000:1000 /path/to/vault

Conclusion

Ce flux de travail piloté par l'IA transforme la gestion des notes Obsidian, passant d'une corvée manuelle à une intelligence automatisée. En combinant les capacités d'IA de MCP avec l'orchestration de flux de travail de N8N, vous créez une base de connaissances auto-organisée qui s'améliore continuellement.

Avantages Clés : - Organisation automatique des notes - Gestion de contenu multilingue - Catégorisation intelligente - Gain de temps (heures → minutes) - Structure cohérente

Prochaines Étapes : - Affiner les prompts pour votre style de notes - Ajouter des catégories personnalisées - Intégrer avec d'autres outils (Notion, Evernote) - Créer des tableaux de bord de visualisation

Automatisez vos connaissances, amplifiez votre productivité.