feat(ai): implement intelligent auto-tagging system

- Added multi-provider AI infrastructure (OpenAI/Ollama)
- Implemented real-time tag suggestions with debounced analysis
- Created AI diagnostics and database maintenance tools in Settings
- Added automated garbage collection for orphan labels
- Refined UX with deterministic color hashing and interactive ghost tags

keep-notes/lib/ai/factory.ts

@@ -0,0 +1,25 @@
+import { OpenAIProvider } from './providers/openai';
+import { OllamaProvider } from './providers/ollama';
+import { AIProvider } from './types';
+
+export function getAIProvider(): AIProvider {
+  const providerType = process.env.AI_PROVIDER || 'ollama'; // Default to ollama for local dev
+
+  switch (providerType.toLowerCase()) {
+    case 'ollama':
+      console.log('Using Ollama Provider with model:', process.env.OLLAMA_MODEL || 'granite4:latest');
+      return new OllamaProvider(
+        process.env.OLLAMA_BASE_URL || 'http://localhost:11434/api',
+        process.env.OLLAMA_MODEL || 'granite4:latest'
+      );
+    case 'openai':
+    default:
+      if (!process.env.OPENAI_API_KEY) {
+        console.warn('OPENAI_API_KEY non configurée. Les fonctions IA pourraient échouer.');
+      }
+      return new OpenAIProvider(
+        process.env.OPENAI_API_KEY || '',
+        process.env.OPENAI_MODEL || 'gpt-4o-mini'
+      );
+  }
+}

keep-notes/lib/ai/providers/ollama.ts

@@ -0,0 +1,77 @@
+import { AIProvider, TagSuggestion } from '../types';
+
+export class OllamaProvider implements AIProvider {
+  private baseUrl: string;
+  private modelName: string;
+
+  constructor(baseUrl: string = 'http://localhost:11434/api', modelName: string = 'llama3') {
+    this.baseUrl = baseUrl.endsWith('/') ? baseUrl.slice(0, -1) : baseUrl;
+    this.modelName = modelName;
+  }
+
+  async generateTags(content: string): Promise<TagSuggestion[]> {
+    try {
+      const response = await fetch(`${this.baseUrl}/generate`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({
+          model: this.modelName,
+        prompt: `Analyse la note suivante et extrais les concepts clés sous forme de tags courts (1-3 mots max).
+        
+        Règles:
+        - Pas de mots de liaison (le, la, pour, et...).
+        - Garde les expressions composées ensemble (ex: "semaine prochaine", "New York").
+        - Normalise en minuscules sauf noms propres.
+        - Maximum 5 tags.
+
+        Réponds UNIQUEMENT sous forme de liste JSON d'objets : [{"tag": "string", "confidence": number}].
+        
+        Contenu de la note: "${content}"`,
+          stream: false,
+        }),
+      });
+
+      if (!response.ok) throw new Error(`Ollama error: ${response.statusText}`);
+
+      const data = await response.json();
+      const text = data.response;
+
+      const jsonMatch = text.match(/\[\s*\{.*\}\s*\]/s);
+      if (jsonMatch) {
+        return JSON.parse(jsonMatch[0]);
+      }
+
+      // Support pour le format { "tags": [...] }
+      const objectMatch = text.match(/\{\s*"tags"\s*:\s*(\[.*\])\s*\}/s);
+      if (objectMatch && objectMatch[1]) {
+        return JSON.parse(objectMatch[1]);
+      }
+      
+      return [];
+    } catch (e) {
+      console.error('Erreur API directe Ollama:', e);
+      return [];
+    }
+  }
+
+  async getEmbeddings(text: string): Promise<number[]> {
+    try {
+      const response = await fetch(`${this.baseUrl}/embeddings`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({
+          model: this.modelName,
+          prompt: text,
+        }),
+      });
+
+      if (!response.ok) throw new Error(`Ollama error: ${response.statusText}`);
+
+      const data = await response.json();
+      return data.embedding;
+    } catch (e) {
+      console.error('Erreur embeddings directs Ollama:', e);
+      return [];
+    }
+  }
+}

keep-notes/lib/ai/providers/openai.ts

@@ -0,0 +1,46 @@
+import { openai } from '@ai-sdk/openai';
+import { generateObject, embed } from 'ai';
+import { z } from 'zod';
+import { AIProvider, TagSuggestion } from '../types';
+
+export class OpenAIProvider implements AIProvider {
+  private model: any;
+
+  constructor(apiKey: string, modelName: string = 'gpt-4o-mini') {
+    this.model = openai(modelName);
+  }
+
+  async generateTags(content: string): Promise<TagSuggestion[]> {
+    try {
+      const { object } = await generateObject({
+        model: this.model,
+        schema: z.object({
+          tags: z.array(z.object({
+            tag: z.string().describe('Le nom du tag, court et en minuscules'),
+            confidence: z.number().min(0).max(1).describe('Le niveau de confiance entre 0 et 1')
+          }))
+        }),
+        prompt: `Analyse la note suivante et suggère entre 1 et 5 tags pertinents. 
+        Contenu de la note: "${content}"`,
+      });
+
+      return object.tags;
+    } catch (e) {
+      console.error('Erreur génération tags OpenAI:', e);
+      return [];
+    }
+  }
+
+  async getEmbeddings(text: string): Promise<number[]> {
+    try {
+      const { embedding } = await embed({
+        model: openai.embedding('text-embedding-3-small'),
+        value: text,
+      });
+      return embedding;
+    } catch (e) {
+      console.error('Erreur embeddings OpenAI:', e);
+      return [];
+    }
+  }
+}

keep-notes/lib/ai/types.ts

@@ -0,0 +1,25 @@
+export interface TagSuggestion {
+  tag: string;
+  confidence: number;
+}
+
+export interface AIProvider {
+  /**
+   * Analyse le contenu et suggère des tags pertinents.
+   */
+  generateTags(content: string): Promise<TagSuggestion[]>;
+
+  /**
+   * Génère un vecteur d'embeddings pour la recherche sémantique.
+   */
+  getEmbeddings(text: string): Promise<number[]>;
+}
+
+export type AIProviderType = 'openai' | 'ollama';
+
+export interface AIConfig {
+  provider: AIProviderType;
+  apiKey?: string;
+  baseUrl?: string; // Utile pour Ollama
+  model?: string;
+}