chore: clean up repo for public release

- Remove BMAD framework, IDE configs, dev screenshots, test files,
  internal docs, and backup files
- Rename keep-notes/ to memento-note/
- Update all references from keep-notes to memento-note
- Add Apache 2.0 license with Commons Clause (non-commercial restriction)
- Add clean .gitignore and .env.docker.example

memento-note/app/(auth)/forgot-password/page.tsx

@@ -0,0 +1,79 @@
+'use client'
+
+import { useState } from 'react'
+import { Button } from '@/components/ui/button'
+import { Input } from '@/components/ui/input'
+import { Card, CardContent, CardDescription, CardFooter, CardHeader, CardTitle } from '@/components/ui/card'
+import { forgotPassword } from '@/app/actions/auth-reset'
+import { toast } from 'sonner'
+import Link from 'next/link'
+import { useLanguage } from '@/lib/i18n'
+
+export default function ForgotPasswordPage() {
+  const { t } = useLanguage()
+  const [isSubmitting, setIsSubmitting] = useState(false)
+  const [isDone, setIsSubmittingDone] = useState(false)
+
+  const handleSubmit = async (e: React.FormEvent<HTMLFormElement>) => {
+    e.preventDefault()
+    setIsSubmitting(true)
+    const formData = new FormData(e.currentTarget)
+    const result = await forgotPassword(formData.get('email') as string)
+    setIsSubmitting(false)
+
+    if (result.error) {
+      toast.error(result.error)
+    } else {
+      setIsSubmittingDone(true)
+    }
+  }
+
+  if (isDone) {
+    return (
+      <main className="flex items-center justify-center md:h-screen p-4">
+        <Card className="w-full max-w-[400px]">
+          <CardHeader>
+            <CardTitle>{t('auth.checkYourEmail')}</CardTitle>
+            <CardDescription>
+              {t('auth.resetEmailSent')}
+            </CardDescription>
+          </CardHeader>
+          <CardFooter>
+            <Link href="/login" className="w-full">
+              <Button variant="outline" className="w-full">{t('auth.returnToLogin')}</Button>
+            </Link>
+          </CardFooter>
+        </Card>
+      </main>
+    )
+  }
+
+  return (
+    <main className="flex items-center justify-center md:h-screen p-4">
+      <Card className="w-full max-w-[400px]">
+        <CardHeader>
+          <CardTitle>{t('auth.forgotPasswordTitle')}</CardTitle>
+          <CardDescription>
+            {t('auth.forgotPasswordDescription')}
+          </CardDescription>
+        </CardHeader>
+        <form onSubmit={handleSubmit}>
+          <CardContent className="space-y-4">
+            <div className="space-y-2">
+              <label htmlFor="email" className="text-sm font-medium">{t('auth.email')}</label>
+              <Input id="email" name="email" type="email" required placeholder="name@example.com" />
+            </div>
+          </CardContent>
+          <CardFooter className="flex flex-col gap-4">
+            <Button type="submit" className="w-full" disabled={isSubmitting}>
+              {isSubmitting ? t('auth.sending') : t('auth.sendResetLink')}
+            </Button>
+            <Link href="/login" className="text-sm text-center underline">
+              {t('auth.backToLogin')}
+            </Link>
+          </CardFooter>
+        </form>
+      </Card>
+    </main>
+  )
+}

memento-note/app/(auth)/layout.tsx

@@ -0,0 +1,19 @@
+'use client';
+
+import { LanguageProvider } from '@/lib/i18n/LanguageProvider';
+
+export default function AuthLayout({
+  children,
+}: Readonly<{
+  children: React.ReactNode;
+}>) {
+  return (
+    <LanguageProvider>
+      <div className="flex min-h-screen items-center justify-center bg-gray-50 dark:bg-zinc-950">
+        <div className="w-full max-w-md p-4">
+          {children}
+        </div>
+      </div>
+    </LanguageProvider>
+  );
+}

memento-note/app/(auth)/login/page.tsx

@@ -0,0 +1,17 @@
+import { LoginForm } from '@/components/login-form';
+import { getSystemConfig } from '@/lib/config';
+ 
+export default async function LoginPage() {
+  const config = await getSystemConfig();
+  
+  // Default to true unless explicitly disabled in DB or Env
+  const allowRegister = config.ALLOW_REGISTRATION !== 'false' && process.env.ALLOW_REGISTRATION !== 'false';
+
+  return (
+    <main className="flex items-center justify-center md:h-screen">
+      <div className="relative mx-auto flex w-full max-w-[400px] flex-col space-y-2.5 p-4 md:-mt-32">
+        <LoginForm allowRegister={allowRegister} />
+      </div>
+    </main>
+  );
+}

memento-note/app/(auth)/register/page.tsx

@@ -0,0 +1,20 @@
+import { RegisterForm } from '@/components/register-form';
+import { getSystemConfig } from '@/lib/config';
+import { redirect } from 'next/navigation';
+ 
+export default async function RegisterPage() {
+  const config = await getSystemConfig();
+  const allowRegister = config.ALLOW_REGISTRATION !== 'false' && process.env.ALLOW_REGISTRATION !== 'false';
+
+  if (!allowRegister) {
+    redirect('/login');
+  }
+
+  return (
+    <main className="flex items-center justify-center md:h-screen">
+      <div className="relative mx-auto flex w-full max-w-[400px] flex-col space-y-2.5 p-4 md:-mt-32">
+        <RegisterForm />
+      </div>
+    </main>
+  );
+}

memento-note/app/(auth)/reset-password/page.tsx

@@ -0,0 +1,98 @@
+'use client'
+
+import { useState, Suspense } from 'react'
+import { Button } from '@/components/ui/button'
+import { Input } from '@/components/ui/input'
+import { Card, CardContent, CardDescription, CardFooter, CardHeader, CardTitle } from '@/components/ui/card'
+import { resetPassword } from '@/app/actions/auth-reset'
+import { toast } from 'sonner'
+import { useSearchParams, useRouter } from 'next/navigation'
+import Link from 'next/link'
+import { useLanguage } from '@/lib/i18n'
+
+function ResetPasswordForm() {
+  const searchParams = useSearchParams()
+  const router = useRouter()
+  const { t } = useLanguage()
+  const [isSubmitting, setIsSubmitting] = useState(false)
+  
+  const token = searchParams.get('token')
+
+  const handleSubmit = async (e: React.FormEvent<HTMLFormElement>) => {
+    e.preventDefault()
+    if (!token) return
+
+    const formData = new FormData(e.currentTarget)
+    const password = formData.get('password') as string
+    const confirm = formData.get('confirmPassword') as string
+
+    if (password !== confirm) {
+      toast.error(t('resetPassword.passwordMismatch'))
+      return
+    }
+
+    setIsSubmitting(true)
+    const result = await resetPassword(token, password)
+    setIsSubmitting(false)
+    
+    if (result.error) {
+      toast.error(result.error)
+    } else {
+      toast.success(t('resetPassword.success'))
+      router.push('/login')
+    }
+  }
+
+  if (!token) {
+    return (
+      <Card className="w-full max-w-[400px]">
+        <CardHeader>
+          <CardTitle>{t('resetPassword.invalidLinkTitle')}</CardTitle>
+          <CardDescription>{t('resetPassword.invalidLinkDescription')}</CardDescription>
+        </CardHeader>
+        <CardFooter>
+          <Link href="/forgot-password" title="Try again" className="w-full">
+            <Button variant="outline" className="w-full">{t('resetPassword.requestNewLink')}</Button>
+          </Link>
+        </CardFooter>
+      </Card>
+    )
+  }
+
+  return (
+    <Card className="w-full max-w-[400px]">
+      <CardHeader>
+        <CardTitle>{t('resetPassword.title')}</CardTitle>
+        <CardDescription>{t('resetPassword.description')}</CardDescription>
+      </CardHeader>
+      <form onSubmit={handleSubmit}>
+        <CardContent className="space-y-4">
+          <div className="space-y-2">
+            <label htmlFor="password">{t('resetPassword.newPassword')}</label>
+            <Input id="password" name="password" type="password" required minLength={6} autoFocus />
+          </div>
+          <div className="space-y-2">
+            <label htmlFor="confirmPassword">{t('resetPassword.confirmNewPassword')}</label>
+            <Input id="confirmPassword" name="confirmPassword" type="password" required minLength={6} />
+          </div>
+        </CardContent>
+        <CardFooter>
+          <Button type="submit" className="w-full" disabled={isSubmitting}>
+            {isSubmitting ? t('resetPassword.resetting') : t('resetPassword.resetPassword')}
+          </Button>
+        </CardFooter>
+      </form>
+    </Card>
+  )
+}
+
+export default function ResetPasswordPage() {
+  const { t } = useLanguage()
+  return (
+    <main className="flex items-center justify-center md:h-screen p-4">
+      <Suspense fallback={<div>{t('resetPassword.loading')}</div>}>
+        <ResetPasswordForm />
+      </Suspense>
+    </main>
+  )
+}

memento-note/app/(main)/admin/ai-test/ai-tester.tsx

@@ -0,0 +1,259 @@
+'use client'
+
+import { Button } from '@/components/ui/button'
+import { Card, CardContent } from '@/components/ui/card'
+import { Badge } from '@/components/ui/badge'
+import { useState, useEffect } from 'react'
+import { toast } from 'sonner'
+import { Loader2, CheckCircle2, XCircle, Clock, Zap, Info } from 'lucide-react'
+import { useLanguage } from '@/lib/i18n'
+
+interface TestResult {
+  success: boolean
+  provider?: string
+  model?: string
+  responseTime?: number
+  tags?: Array<{ tag: string; confidence: number }>
+  embeddingLength?: number
+  firstValues?: number[]
+  error?: string
+  details?: any
+}
+
+export function AI_TESTER({ type }: { type: 'tags' | 'embeddings' }) {
+  const { t } = useLanguage()
+  const [isLoading, setIsLoading] = useState(false)
+  const [result, setResult] = useState<TestResult | null>(null)
+  const [config, setConfig] = useState<any>(null)
+
+  useEffect(() => {
+    fetchConfig()
+  }, [])
+
+  const fetchConfig = async () => {
+    try {
+      const response = await fetch('/api/ai/config')
+      const data = await response.json()
+      setConfig(data)
+
+      if (data.previousTest) {
+        setResult(data.previousTest[type] || null)
+      }
+    } catch (error) {
+      console.error('Failed to fetch config:', error)
+    }
+  }
+
+  const runTest = async () => {
+    setIsLoading(true)
+    const startTime = Date.now()
+
+    try {
+      const response = await fetch(`/api/ai/test-${type}`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' }
+      })
+
+      const endTime = Date.now()
+      const data = await response.json()
+
+      setResult({
+        ...data,
+        responseTime: endTime - startTime
+      })
+
+      if (data.success) {
+        toast.success(
+          `✅ ${t('admin.aiTest.testSuccessToast', { type: type === 'tags' ? 'Tags' : 'Embeddings' })}`,
+          {
+            description: `Provider: ${data.provider} | Time: ${endTime - startTime}ms`
+          }
+        )
+      } else {
+        toast.error(
+          `❌ ${t('admin.aiTest.testFailedToast', { type: type === 'tags' ? 'Tags' : 'Embeddings' })}`,
+          {
+            description: data.error || 'Unknown error'
+          }
+        )
+      }
+    } catch (error: any) {
+      const endTime = Date.now()
+      const errorResult = {
+        success: false,
+        error: error.message || 'Network error',
+        responseTime: endTime - startTime
+      }
+      setResult(errorResult)
+      toast.error(t('admin.aiTest.testError', { error: error.message }))
+    } finally {
+      setIsLoading(false)
+    }
+  }
+
+  const getProviderInfo = () => {
+    if (!config) return { provider: t('admin.aiTest.testing'), model: t('admin.aiTest.testing') }
+
+    if (type === 'tags') {
+      return {
+        provider: config.AI_PROVIDER_TAGS || 'ollama',
+        model: config.AI_MODEL_TAGS || 'granite4:latest'
+      }
+    } else {
+      return {
+        provider: config.AI_PROVIDER_EMBEDDING || 'ollama',
+        model: config.AI_MODEL_EMBEDDING || 'embeddinggemma:latest'
+      }
+    }
+  }
+
+  const providerInfo = getProviderInfo()
+
+  return (
+    <div className="space-y-4">
+      {/* Provider Info */}
+      <div className="space-y-3 p-4 bg-muted/50 rounded-lg">
+        <div className="flex items-center justify-between">
+          <span className="text-sm font-medium">{t('admin.aiTest.provider')}</span>
+          <Badge variant="outline" className="text-xs">
+            {providerInfo.provider.toUpperCase()}
+          </Badge>
+        </div>
+        <div className="flex items-center justify-between">
+          <span className="text-sm font-medium">{t('admin.aiTest.model')}</span>
+          <span className="text-sm text-muted-foreground font-mono">
+            {providerInfo.model}
+          </span>
+        </div>
+      </div>
+
+      {/* Test Button */}
+      <Button
+        onClick={runTest}
+        disabled={isLoading}
+        className="w-full"
+        variant={result?.success ? 'default' : result?.success === false ? 'destructive' : 'default'}
+      >
+        {isLoading ? (
+          <>
+            <Loader2 className="mr-2 h-4 w-4 animate-spin" />
+            {t('admin.aiTest.testing')}
+          </>
+        ) : (
+          <>
+            <Zap className="mr-2 h-4 w-4" />
+            {t('admin.aiTest.runTest')}
+          </>
+        )}
+      </Button>
+
+      {/* Results */}
+      {result && (
+        <Card className={result.success ? 'border-green-200 dark:border-green-900' : 'border-red-200 dark:border-red-900'}>
+          <CardContent className="pt-6">
+            {/* Status */}
+            <div className="flex items-center gap-2 mb-4">
+              {result.success ? (
+                <>
+                  <CheckCircle2 className="h-5 w-5 text-green-600" />
+                  <span className="font-semibold text-green-600 dark:text-green-400">{t('admin.aiTest.testPassed')}</span>
+                </>
+              ) : (
+                <>
+                  <XCircle className="h-5 w-5 text-red-600" />
+                  <span className="font-semibold text-red-600 dark:text-red-400">{t('admin.aiTest.testFailed')}</span>
+                </>
+              )}
+            </div>
+
+            {/* Response Time */}
+            {result.responseTime && (
+              <div className="flex items-center gap-2 text-sm text-muted-foreground mb-4">
+                <Clock className="h-4 w-4" />
+                <span>{t('admin.aiTest.responseTime', { time: result.responseTime })}</span>
+              </div>
+            )}
+
+            {/* Tags Results */}
+            {type === 'tags' && result.success && result.tags && (
+              <div className="space-y-3">
+                <div className="flex items-center gap-2">
+                  <Info className="h-4 w-4 text-primary" />
+                  <span className="text-sm font-medium">{t('admin.aiTest.generatedTags')}</span>
+                </div>
+                <div className="flex flex-wrap gap-2">
+                  {result.tags.map((tag, idx) => (
+                    <Badge
+                      key={idx}
+                      variant="secondary"
+                      className="text-sm"
+                    >
+                      {tag.tag}
+                      <span className="ml-1 text-xs opacity-70">
+                        ({Math.round(tag.confidence * 100)}%)
+                      </span>
+                    </Badge>
+                  ))}
+                </div>
+              </div>
+            )}
+
+            {/* Embeddings Results */}
+            {type === 'embeddings' && result.success && result.embeddingLength && (
+              <div className="space-y-3">
+                <div className="flex items-center gap-2">
+                  <Info className="h-4 w-4 text-green-600" />
+                  <span className="text-sm font-medium">{t('admin.aiTest.embeddingDimensions')}</span>
+                </div>
+                <div className="p-3 bg-muted rounded-lg">
+                  <div className="text-2xl font-bold text-center">
+                    {result.embeddingLength}
+                  </div>
+                  <div className="text-xs text-center text-muted-foreground mt-1">
+                    {t('admin.aiTest.vectorDimensions')}
+                  </div>
+                </div>
+                {result.firstValues && result.firstValues.length > 0 && (
+                  <div className="space-y-1">
+                    <span className="text-xs font-medium">{t('admin.aiTest.first5Values')}</span>
+                    <div className="p-2 bg-muted rounded font-mono text-xs">
+                      [{result.firstValues.slice(0, 5).map((v, i) => v.toFixed(4)).join(', ')}]
+                    </div>
+                  </div>
+                )}
+              </div>
+            )}
+
+            {/* Error Details */}
+            {!result.success && result.error && (
+              <div className="mt-4 p-3 bg-red-50 dark:bg-red-950/20 rounded-lg border border-red-200 dark:border-red-900">
+                <p className="text-sm font-medium text-red-900 dark:text-red-100">{t('admin.aiTest.error')}</p>
+                <p className="text-sm text-red-700 dark:text-red-300 mt-1">{result.error}</p>
+                {result.details && (
+                  <details className="mt-2">
+                    <summary className="text-xs cursor-pointer text-red-600 dark:text-red-400">
+                      {t('admin.aiTest.technicalDetails')}
+                    </summary>
+                    <pre className="mt-2 text-xs overflow-auto p-2 bg-red-100 dark:bg-red-900/30 rounded">
+                      {JSON.stringify(result.details, null, 2)}
+                    </pre>
+                  </details>
+                )}
+              </div>
+            )}
+          </CardContent>
+        </Card>
+      )}
+
+      {/* Loading State */}
+      {isLoading && (
+        <div className="text-center py-4">
+          <Loader2 className="h-8 w-8 animate-spin mx-auto text-primary" />
+          <p className="text-sm text-muted-foreground mt-2">
+            {t('admin.aiTest.testingType', { type: type === 'tags' ? 'tags generation' : 'embeddings' })}
+          </p>
+        </div>
+      )}
+    </div>
+  )
+}

memento-note/app/(main)/admin/ai-test/page.tsx

@@ -0,0 +1,102 @@
+'use client'
+
+import { Card, CardContent, CardDescription, CardHeader, CardTitle } from '@/components/ui/card'
+import { Button } from '@/components/ui/button'
+import Link from 'next/link'
+import { ArrowLeft, TestTube } from 'lucide-react'
+import { AI_TESTER } from './ai-tester'
+import { useLanguage } from '@/lib/i18n'
+
+export default function AITestPage() {
+  const { t } = useLanguage()
+
+  return (
+    <div className="container mx-auto py-10 px-4 max-w-6xl">
+      <div className="flex justify-between items-center mb-8">
+        <div className="flex items-center gap-3">
+          <Link href="/admin/settings">
+            <Button variant="outline" size="icon">
+              <ArrowLeft className="h-4 w-4" />
+            </Button>
+          </Link>
+          <div>
+            <h1 className="text-3xl font-bold flex items-center gap-2">
+              <TestTube className="h-8 w-8" />
+              {t('admin.aiTest.title')}
+            </h1>
+            <p className="text-muted-foreground mt-1">
+              {t('admin.aiTest.description')}
+            </p>
+          </div>
+        </div>
+      </div>
+
+      <div className="grid gap-6 md:grid-cols-2">
+        {/* Tags Provider Test */}
+        <Card className="border-primary/20 dark:border-primary/30">
+          <CardHeader className="bg-primary/5 dark:bg-primary/10">
+            <CardTitle className="flex items-center gap-2">
+              <span className="text-2xl">🏷️</span>
+              {t('admin.aiTest.tagsTestTitle')}
+            </CardTitle>
+            <CardDescription>
+              {t('admin.aiTest.tagsTestDescription')}
+            </CardDescription>
+          </CardHeader>
+          <CardContent className="pt-6">
+            <AI_TESTER type="tags" />
+          </CardContent>
+        </Card>
+
+        {/* Embeddings Provider Test */}
+        <Card className="border-green-200 dark:border-green-900">
+          <CardHeader className="bg-green-50/50 dark:bg-green-950/20">
+            <CardTitle className="flex items-center gap-2">
+              <span className="text-2xl">🔍</span>
+              {t('admin.aiTest.embeddingsTestTitle')}
+            </CardTitle>
+            <CardDescription>
+              {t('admin.aiTest.embeddingsTestDescription')}
+            </CardDescription>
+          </CardHeader>
+          <CardContent className="pt-6">
+            <AI_TESTER type="embeddings" />
+          </CardContent>
+        </Card>
+      </div>
+
+      {/* Info Section */}
+      <Card className="mt-6">
+        <CardHeader>
+          <CardTitle>ℹ️ {t('admin.aiTest.howItWorksTitle')}</CardTitle>
+        </CardHeader>
+        <CardContent className="space-y-4 text-sm">
+          <div>
+            <h4 className="font-semibold mb-2">{t('admin.aiTest.tagsGenerationTest')}</h4>
+            <ul className="list-disc list-inside space-y-1 text-muted-foreground">
+              <li>{t('admin.aiTest.tagsStep1')}</li>
+              <li>{t('admin.aiTest.tagsStep2')}</li>
+              <li>{t('admin.aiTest.tagsStep3')}</li>
+              <li>{t('admin.aiTest.tagsStep4')}</li>
+            </ul>
+          </div>
+          <div>
+            <h4 className="font-semibold mb-2">{t('admin.aiTest.embeddingsTestLabel')}</h4>
+            <ul className="list-disc list-inside space-y-1 text-muted-foreground">
+              <li>{t('admin.aiTest.embeddingsStep1')}</li>
+              <li>{t('admin.aiTest.embeddingsStep2')}</li>
+              <li>{t('admin.aiTest.embeddingsStep3')}</li>
+              <li>{t('admin.aiTest.embeddingsStep4')}</li>
+            </ul>
+          </div>
+          <div className="bg-amber-50 dark:bg-amber-950/20 p-4 rounded-lg border border-amber-200 dark:border-amber-900">
+            <p className="font-semibold text-amber-900 dark:text-amber-100">💡 {t('admin.aiTest.tipTitle')}</p>
+            <p className="text-amber-800 dark:text-amber-200 mt-1">
+              {t('admin.aiTest.tipContent')}
+            </p>
+          </div>
+        </CardContent>
+      </Card>
+    </div>
+  )
+}

memento-note/app/(main)/admin/ai/page.tsx

@@ -0,0 +1,147 @@
+import { AdminMetrics } from '@/components/admin-metrics'
+import { Button } from '@/components/ui/button'
+import { Zap, Settings, Activity, TrendingUp } from 'lucide-react'
+import Link from 'next/link'
+import { getSystemConfig } from '@/lib/config'
+
+export default async function AdminAIPage() {
+  const config = await getSystemConfig()
+
+  // Determine provider status based on config
+  const openaiKey = config.OPENAI_API_KEY
+  const ollamaUrl = config.OLLAMA_BASE_URL || config.OLLAMA_BASE_URL_TAGS || config.OLLAMA_BASE_URL_EMBEDDING
+
+  const providers = [
+    {
+      name: 'OpenAI',
+      status: openaiKey ? 'Connected' : 'Not Configured',
+      requests: 'N/A' // We don't track request counts yet
+    },
+    {
+      name: 'Ollama',
+      status: ollamaUrl ? 'Available' : 'Not Configured',
+      requests: 'N/A'
+    },
+  ]
+
+  // Mock AI metrics - in a real app, these would come from analytics
+  // TODO: Implement real analytics tracking
+  const aiMetrics = [
+    {
+      title: 'Total Requests',
+      value: '—',
+      trend: { value: 0, isPositive: true },
+      icon: <Zap className="h-5 w-5 text-yellow-600 dark:text-yellow-400" />,
+    },
+    {
+      title: 'Success Rate',
+      value: '100%',
+      trend: { value: 0, isPositive: true },
+      icon: <TrendingUp className="h-5 w-5 text-green-600 dark:text-green-400" />,
+    },
+    {
+      title: 'Avg Response Time',
+      value: '—',
+      trend: { value: 0, isPositive: true },
+      icon: <Activity className="h-5 w-5 text-primary dark:text-primary-foreground" />,
+    },
+    {
+      title: 'Active Features',
+      value: '6',
+      icon: <Settings className="h-5 w-5 text-purple-600 dark:text-purple-400" />,
+    },
+  ]
+
+  return (
+    <div className="space-y-6">
+      <div className="flex justify-between items-center">
+        <div>
+          <h1 className="text-3xl font-bold text-gray-900 dark:text-white">
+            AI Management
+          </h1>
+          <p className="text-gray-600 dark:text-gray-400 mt-1">
+            Monitor and configure AI features
+          </p>
+        </div>
+        <Link href="/admin/settings">
+          <Button variant="outline">
+            <Settings className="mr-2 h-4 w-4" />
+            Configure
+          </Button>
+        </Link>
+      </div>
+
+      <AdminMetrics metrics={aiMetrics} />
+
+      <div className="grid grid-cols-1 lg:grid-cols-2 gap-6">
+        <div className="bg-white dark:bg-zinc-900 rounded-lg shadow overflow-hidden border border-gray-200 dark:border-gray-800 p-6">
+          <h2 className="text-lg font-semibold text-gray-900 dark:text-white mb-4">
+            Active AI Features
+          </h2>
+          <div className="space-y-3">
+            {[
+              'Title Suggestions',
+              'Semantic Search',
+              'Paragraph Reformulation',
+              'Memory Echo',
+              'Language Detection',
+              'Auto Labeling',
+            ].map((feature) => (
+              <div
+                key={feature}
+                className="flex items-center justify-between p-3 bg-gray-50 dark:bg-zinc-800 rounded-lg"
+              >
+                <span className="text-sm text-gray-900 dark:text-white">
+                  {feature}
+                </span>
+                <span className="px-2 py-1 text-xs font-medium text-green-700 dark:text-green-400 bg-green-100 dark:bg-green-900 rounded-full">
+                  Active
+                </span>
+              </div>
+            ))}
+          </div>
+        </div>
+
+        <div className="bg-white dark:bg-zinc-900 rounded-lg shadow overflow-hidden border border-gray-200 dark:border-gray-800 p-6">
+          <h2 className="text-lg font-semibold text-gray-900 dark:text-white mb-4">
+            AI Provider Status
+          </h2>
+          <div className="space-y-3">
+            {providers.map((provider) => (
+              <div
+                key={provider.name}
+                className="flex items-center justify-between p-3 bg-gray-50 dark:bg-zinc-800 rounded-lg"
+              >
+                <div>
+                  <p className="text-sm font-medium text-gray-900 dark:text-white">
+                    {provider.name}
+                  </p>
+                  <p className="text-xs text-gray-600 dark:text-gray-400">
+                    {provider.requests} requests
+                  </p>
+                </div>
+                <span
+                  className={`px-2 py-1 text-xs font-medium rounded-full ${provider.status === 'Connected' || provider.status === 'Available'
+                      ? 'text-green-700 dark:text-green-400 bg-green-100 dark:bg-green-900'
+                      : 'text-gray-600 dark:text-gray-400 bg-gray-100 dark:bg-gray-800'
+                    }`}
+                >
+                  {provider.status}
+                </span>
+              </div>
+            ))}
+          </div>
+        </div>
+      </div>
+
+      <div className="bg-white dark:bg-zinc-900 rounded-lg shadow overflow-hidden border border-gray-200 dark:border-gray-800 p-6">
+        <h2 className="text-lg font-semibold text-gray-900 dark:text-white mb-4">
+          Recent AI Requests
+        </h2>
+        <p className="text-gray-600 dark:text-gray-400">
+          Recent AI requests will be displayed here. (Coming Soon)
+        </p>
+      </div>
+    </div>
+  )
+}

memento-note/app/(main)/admin/create-user-dialog.tsx

@@ -0,0 +1,80 @@
+'use client'
+
+import { useState } from 'react'
+import { Button } from '@/components/ui/button'
+import {
+  Dialog,
+  DialogContent,
+  DialogDescription,
+  DialogHeader,
+  DialogTitle,
+  DialogTrigger,
+  DialogFooter,
+} from '@/components/ui/dialog'
+import { Input } from '@/components/ui/input'
+import { Plus } from 'lucide-react'
+import { createUser } from '@/app/actions/admin'
+import { toast } from 'sonner'
+import { useLanguage } from '@/lib/i18n'
+
+export function CreateUserDialog() {
+  const [open, setOpen] = useState(false)
+  const { t } = useLanguage()
+  
+  return (
+    <Dialog open={open} onOpenChange={setOpen}>
+      <DialogTrigger asChild>
+        <Button>
+          <Plus className="mr-2 h-4 w-4" /> {t('admin.users.addUser')}
+        </Button>
+      </DialogTrigger>
+      <DialogContent className="sm:max-w-[425px]">
+        <DialogHeader>
+          <DialogTitle>{t('admin.users.createUser')}</DialogTitle>
+          <DialogDescription>
+            {t('admin.users.createUserDescription')}
+          </DialogDescription>
+        </DialogHeader>
+        <form
+          action={async (formData) => {
+            const result = await createUser(formData)
+            if (result?.error) {
+              toast.error(t('admin.users.createFailed'))
+            } else {
+              toast.success(t('admin.users.createSuccess'))
+              setOpen(false)
+            }
+          }}
+          className="grid gap-4 py-4"
+        >
+          <div className="grid gap-2">
+            <label htmlFor="name">{t('admin.users.name')}</label>
+            <Input id="name" name="name" required />
+          </div>
+          <div className="grid gap-2">
+            <label htmlFor="email">{t('admin.users.email')}</label>
+            <Input id="email" name="email" type="email" required />
+          </div>
+          <div className="grid gap-2">
+            <label htmlFor="password">{t('admin.users.password')}</label>
+            <Input id="password" name="password" type="password" required minLength={6} />
+          </div>
+          <div className="grid gap-2">
+            <label htmlFor="role">{t('admin.users.role')}</label>
+            <select
+              id="role"
+              name="role"
+              className="flex h-9 w-full rounded-md border border-input bg-transparent px-3 py-1 text-sm shadow-sm transition-colors file:border-0 file:bg-transparent file:text-sm file:font-medium placeholder:text-muted-foreground focus-visible:outline-none focus-visible:ring-1 focus-visible:ring-ring disabled:cursor-not-allowed disabled:opacity-50"
+            >
+              <option value="USER">{t('admin.users.roles.user')}</option>
+              <option value="ADMIN">{t('admin.users.roles.admin')}</option>
+            </select>
+          </div>
+          <DialogFooter>
+            <Button type="submit">{t('admin.users.createUser')}</Button>
+          </DialogFooter>
+        </form>
+      </DialogContent>
+    </Dialog>
+  )
+}

memento-note/app/(main)/admin/layout.tsx

@@ -0,0 +1,23 @@
+import { AdminSidebar } from '@/components/admin-sidebar'
+import { AdminContentArea } from '@/components/admin-content-area'
+import { auth } from '@/auth'
+import { redirect } from 'next/navigation'
+
+export default async function AdminLayout({
+  children,
+}: {
+  children: React.ReactNode
+}) {
+  const session = await auth()
+
+  if ((session?.user as any)?.role !== 'ADMIN') {
+    redirect('/')
+  }
+
+  return (
+    <div className="flex h-full bg-gray-50 dark:bg-zinc-950">
+      <AdminSidebar />
+      <AdminContentArea>{children}</AdminContentArea>
+    </div>
+  )
+}

memento-note/app/(main)/admin/loading.tsx

@@ -0,0 +1,20 @@
+export default function AdminLoading() {
+  return (
+    <div className="space-y-6 animate-pulse">
+      <div>
+        <div className="h-9 w-48 bg-muted rounded-md mb-2" />
+        <div className="h-4 w-72 bg-muted rounded-md" />
+      </div>
+      {[1, 2, 3].map((i) => (
+        <div key={i} className="rounded-lg border border-border bg-white dark:bg-zinc-900 p-6 space-y-4">
+          <div className="h-5 w-40 bg-muted rounded" />
+          <div className="h-px bg-border" />
+          <div className="space-y-3">
+            <div className="h-4 w-full bg-muted rounded" />
+            <div className="h-4 w-3/4 bg-muted rounded" />
+          </div>
+        </div>
+      ))}
+    </div>
+  )
+}

memento-note/app/(main)/admin/page.tsx

@@ -0,0 +1,59 @@
+import { getUsers } from '@/app/actions/admin'
+import { AdminMetrics } from '@/components/admin-metrics'
+import { Users, Activity, Database, Zap } from 'lucide-react'
+
+export default async function AdminPage() {
+  const users = await getUsers()
+
+  // Mock metrics data - in a real app, these would come from analytics
+  const metrics = [
+    {
+      title: 'Total Users',
+      value: users.length,
+      trend: { value: 12, isPositive: true },
+      icon: <Users className="h-5 w-5 text-primary dark:text-primary-foreground" />,
+    },
+    {
+      title: 'Active Sessions',
+      value: '24',
+      trend: { value: 8, isPositive: true },
+      icon: <Activity className="h-5 w-5 text-green-600 dark:text-green-400" />,
+    },
+    {
+      title: 'Total Notes',
+      value: '1,234',
+      trend: { value: 24, isPositive: true },
+      icon: <Database className="h-5 w-5 text-purple-600 dark:text-purple-400" />,
+    },
+    {
+      title: 'AI Requests',
+      value: '856',
+      trend: { value: 5, isPositive: false },
+      icon: <Zap className="h-5 w-5 text-yellow-600 dark:text-yellow-400" />,
+    },
+  ]
+
+  return (
+    <div className="space-y-6">
+      <div>
+        <h1 className="text-3xl font-bold text-gray-900 dark:text-white">
+          Dashboard
+        </h1>
+        <p className="text-gray-600 dark:text-gray-400 mt-1">
+          Overview of your application metrics
+        </p>
+      </div>
+
+      <AdminMetrics metrics={metrics} />
+
+      <div className="bg-white dark:bg-zinc-900 rounded-lg shadow overflow-hidden border border-gray-200 dark:border-gray-800 p-6">
+        <h2 className="text-lg font-semibold text-gray-900 dark:text-white mb-4">
+          Recent Activity
+        </h2>
+        <p className="text-gray-600 dark:text-gray-400">
+          Recent activity will be displayed here.
+        </p>
+      </div>
+    </div>
+  )
+}

memento-note/app/(main)/admin/settings/page.tsx

@@ -0,0 +1,23 @@
+import { getSystemConfig } from '@/app/actions/admin-settings'
+import { AdminSettingsForm } from './admin-settings-form'
+
+export default async function AdminSettingsPage() {
+  const config = await getSystemConfig()
+
+  return (
+    <div className="space-y-6">
+      <div>
+        <h1 className="text-3xl font-bold text-gray-900 dark:text-white">
+          Settings
+        </h1>
+        <p className="text-gray-600 dark:text-gray-400 mt-1">
+          Configure application-wide settings
+        </p>
+      </div>
+
+      <div className="bg-white dark:bg-zinc-900 rounded-lg shadow overflow-hidden border border-gray-200 dark:border-gray-800 p-6">
+        <AdminSettingsForm config={config} />
+      </div>
+    </div>
+  )
+}

memento-note/app/(main)/admin/user-list.tsx

@@ -0,0 +1,83 @@
+'use client'
+
+import { useState } from 'react'
+import { Button } from '@/components/ui/button'
+import { deleteUser, updateUserRole } from '@/app/actions/admin'
+import { toast } from 'sonner'
+import { Trash2, Shield, ShieldOff } from 'lucide-react'
+import { format } from 'date-fns'
+import { useLanguage } from '@/lib/i18n'
+
+export function UserList({ initialUsers }: { initialUsers: any[] }) {
+  const { t } = useLanguage()
+
+  const handleDelete = async (id: string) => {
+    if (!confirm(t('admin.users.confirmDelete'))) return
+    try {
+      await deleteUser(id)
+      toast.success(t('admin.users.deleteSuccess'))
+    } catch (e) {
+      toast.error(t('admin.users.deleteFailed'))
+    }
+  }
+
+  const handleRoleToggle = async (user: any) => {
+    const newRole = user.role === 'ADMIN' ? 'USER' : 'ADMIN'
+    try {
+      await updateUserRole(user.id, newRole)
+      toast.success(t('admin.users.roleUpdateSuccess', { role: newRole }))
+    } catch (e) {
+      toast.error(t('admin.users.roleUpdateFailed'))
+    }
+  }
+
+  return (
+    <div className="w-full overflow-auto">
+      <table className="w-full caption-bottom text-sm text-left">
+        <thead className="[&_tr]:border-b">
+          <tr className="border-b transition-colors hover:bg-muted/50 data-[state=selected]:bg-muted">
+            <th className="h-12 px-4 align-middle font-medium text-muted-foreground">{t('admin.users.table.name')}</th>
+            <th className="h-12 px-4 align-middle font-medium text-muted-foreground">{t('admin.users.table.email')}</th>
+            <th className="h-12 px-4 align-middle font-medium text-muted-foreground">{t('admin.users.table.role')}</th>
+            <th className="h-12 px-4 align-middle font-medium text-muted-foreground">{t('admin.users.table.createdAt')}</th>
+            <th className="h-12 px-4 align-middle font-medium text-muted-foreground text-right">{t('admin.users.table.actions')}</th>
+          </tr>
+        </thead>
+        <tbody className="[&_tr:last-child]:border-0">
+          {initialUsers.map((user) => (
+            <tr key={user.id} className="border-b transition-colors hover:bg-muted/50 data-[state=selected]:bg-muted">
+              <td className="p-4 align-middle font-medium">{user.name || t('common.notAvailable')}</td>
+              <td className="p-4 align-middle">{user.email}</td>
+              <td className="p-4 align-middle">
+                <span className={`inline-flex items-center rounded-full border px-2.5 py-0.5 text-xs font-semibold transition-colors focus:outline-none focus:ring-2 focus:ring-ring focus:ring-offset-2 ${user.role === 'ADMIN' ? 'border-transparent bg-primary text-primary-foreground hover:bg-primary/80' : 'border-transparent bg-secondary text-secondary-foreground hover:bg-secondary/80'}`}>
+                  {user.role === 'ADMIN' ? t('admin.users.roles.admin') : t('admin.users.roles.user')}
+                </span>
+              </td>
+              <td className="p-4 align-middle">{format(new Date(user.createdAt), 'PP')}</td>
+              <td className="p-4 align-middle text-right">
+                <div className="flex justify-end gap-2">
+                  <Button
+                    variant="ghost"
+                    size="sm"
+                    onClick={() => handleRoleToggle(user)}
+                    title={user.role === 'ADMIN' ? t('admin.users.demote') : t('admin.users.promote')}
+                  >
+                    {user.role === 'ADMIN' ? <ShieldOff className="h-4 w-4" /> : <Shield className="h-4 w-4" />}
+                  </Button>
+                  <Button
+                    variant="ghost"
+                    size="sm"
+                    onClick={() => handleDelete(user.id)}
+                    className="text-red-600 hover:text-red-900"
+                  >
+                    <Trash2 className="h-4 w-4" />
+                  </Button>
+                </div>
+              </td>
+            </tr>
+          ))}
+        </tbody>
+      </table>
+    </div>
+  )
+}

memento-note/app/(main)/admin/users/page.tsx

@@ -0,0 +1,29 @@
+import { getUsers } from '@/app/actions/admin'
+import { CreateUserDialog } from '../create-user-dialog'
+import { UserList } from '../user-list'
+import { Plus } from 'lucide-react'
+import { Button } from '@/components/ui/button'
+
+export default async function AdminUsersPage() {
+  const users = await getUsers()
+
+  return (
+    <div className="space-y-6">
+      <div className="flex justify-between items-center">
+        <div>
+          <h1 className="text-3xl font-bold text-gray-900 dark:text-white">
+            Users
+          </h1>
+          <p className="text-gray-600 dark:text-gray-400 mt-1">
+            Manage application users and permissions
+          </p>
+        </div>
+        <CreateUserDialog />
+      </div>
+
+      <div className="bg-white dark:bg-zinc-900 rounded-lg shadow overflow-hidden border border-gray-200 dark:border-gray-800">
+        <UserList initialUsers={users} />
+      </div>
+    </div>
+  )
+}

memento-note/app/(main)/agents/agents-page-client.tsx

@@ -0,0 +1,281 @@
+'use client'
+
+/**
+ * Agents Page Client
+ * Main client component for the agents page.
+ */
+
+import { useState, useCallback, useMemo } from 'react'
+import { Plus, Bot, LifeBuoy, Search } from 'lucide-react'
+import { toast } from 'sonner'
+import { useLanguage } from '@/lib/i18n'
+
+import { AgentCard } from '@/components/agents/agent-card'
+import { AgentForm } from '@/components/agents/agent-form'
+import { AgentTemplates } from '@/components/agents/agent-templates'
+import { AgentRunLog } from '@/components/agents/agent-run-log'
+import { AgentHelp } from '@/components/agents/agent-help'
+import {
+  createAgent,
+  updateAgent,
+  getAgents,
+} from '@/app/actions/agent-actions'
+
+// --- Types ---
+
+interface Notebook {
+  id: string
+  name: string
+  icon?: string | null
+}
+
+interface AgentItem {
+  id: string
+  name: string
+  description?: string | null
+  type?: string | null
+  role: string
+  sourceUrls?: string | null
+  sourceNotebookId?: string | null
+  targetNotebookId?: string | null
+  frequency: string
+  isEnabled: boolean
+  lastRun: string | Date | null
+  createdAt: string | Date
+  updatedAt: string | Date
+  tools?: string | null
+  maxSteps?: number
+  notifyEmail?: boolean
+  includeImages?: boolean
+  _count: { actions: number }
+  actions: { id: string; status: string; createdAt: string | Date }[]
+  notebook?: { id: string; name: string; icon?: string | null } | null
+}
+
+interface AgentsPageClientProps {
+  agents: AgentItem[]
+  notebooks: Notebook[]
+}
+
+const typeFilterOptions = [
+  { value: '', labelKey: 'agents.filterAll' },
+  { value: 'scraper', labelKey: 'agents.types.scraper' },
+  { value: 'researcher', labelKey: 'agents.types.researcher' },
+  { value: 'monitor', labelKey: 'agents.types.monitor' },
+  { value: 'custom', labelKey: 'agents.types.custom' },
+] as const
+
+// --- Component ---
+
+export function AgentsPageClient({
+  agents: initialAgents,
+  notebooks,
+}: AgentsPageClientProps) {
+  const { t } = useLanguage()
+  const [agents, setAgents] = useState(initialAgents)
+  const [showForm, setShowForm] = useState(false)
+  const [editingAgent, setEditingAgent] = useState<AgentItem | null>(null)
+  const [logAgent, setLogAgent] = useState<{ id: string; name: string } | null>(null)
+  const [showHelp, setShowHelp] = useState(false)
+  const [searchQuery, setSearchQuery] = useState('')
+  const [typeFilter, setTypeFilter] = useState('')
+
+  const refreshAgents = useCallback(async () => {
+    try {
+      const updated = await getAgents()
+      setAgents(updated)
+    } catch {
+      // Silent
+    }
+  }, [])
+
+  const handleToggle = useCallback((id: string, isEnabled: boolean) => {
+    setAgents(prev => prev.map(a => a.id === id ? { ...a, isEnabled } : a))
+  }, [])
+
+  const handleCreate = useCallback(() => {
+    setEditingAgent(null)
+    setShowForm(true)
+  }, [])
+
+  const handleEdit = useCallback((id: string) => {
+    const agent = agents.find(a => a.id === id)
+    if (agent) {
+      setEditingAgent(agent)
+      setShowForm(true)
+    }
+  }, [agents])
+
+  const handleSave = useCallback(async (formData: FormData) => {
+    const data = {
+      name: formData.get('name') as string,
+      description: (formData.get('description') as string) || undefined,
+      type: formData.get('type') as string,
+      role: formData.get('role') as string,
+      sourceUrls: formData.get('sourceUrls') ? JSON.parse(formData.get('sourceUrls') as string) : undefined,
+      sourceNotebookId: (formData.get('sourceNotebookId') as string) || undefined,
+      targetNotebookId: (formData.get('targetNotebookId') as string) || undefined,
+      frequency: formData.get('frequency') as string,
+      tools: formData.get('tools') ? JSON.parse(formData.get('tools') as string) : undefined,
+      maxSteps: formData.get('maxSteps') ? Number(formData.get('maxSteps')) : undefined,
+      notifyEmail: formData.get('notifyEmail') === 'true',
+      includeImages: formData.get('includeImages') === 'true',
+    }
+
+    if (editingAgent) {
+      await updateAgent(editingAgent.id, data)
+      toast.success(t('agents.toasts.updated'))
+    } else {
+      await createAgent(data)
+      toast.success(t('agents.toasts.created'))
+    }
+
+    setShowForm(false)
+    setEditingAgent(null)
+    await refreshAgents()
+  }, [editingAgent, refreshAgents, t])
+
+  const filteredAgents = useMemo(() => {
+    return agents.filter(agent => {
+      const matchesType = !typeFilter || (agent.type || 'scraper') === typeFilter
+      if (!searchQuery.trim()) return matchesType
+      const q = searchQuery.toLowerCase()
+      const matchesSearch =
+        (agent.name || '').toLowerCase().includes(q) ||
+        (agent.description && agent.description.toLowerCase().includes(q))
+      return matchesType && matchesSearch
+    })
+  }, [agents, searchQuery, typeFilter])
+
+  const existingAgentNames = useMemo(() => agents.map(a => a.name), [agents])
+
+  return (
+    <>
+      {/* Header */}
+      <div className="flex items-center justify-between gap-4 mb-8">
+        <div className="flex items-center gap-4">
+          <div className="p-3 bg-primary/10 rounded-2xl shadow-sm border border-primary/20">
+            <Bot className="h-8 w-8 text-primary" />
+          </div>
+          <div>
+            <h1 className="text-3xl font-bold tracking-tight">{t('agents.title')}</h1>
+            <p className="text-muted-foreground text-sm">{t('agents.subtitle')}</p>
+          </div>
+        </div>
+      </div>
+
+      {/* Action buttons */}
+      <div className="flex items-center justify-between mb-6">
+        <button
+          onClick={() => setShowHelp(true)}
+          className="flex items-center gap-2 px-4 py-2 text-sm font-medium text-primary bg-primary/10 border border-primary/20 rounded-lg hover:bg-primary/15 transition-colors"
+        >
+          <LifeBuoy className="w-4 h-4" />
+          {t('agents.help.btnLabel')}
+        </button>
+        <button
+          onClick={handleCreate}
+          className="flex items-center gap-2 px-4 py-2 text-sm font-medium text-white bg-primary rounded-lg hover:bg-primary/90 transition-colors"
+        >
+          <Plus className="w-4 h-4" />
+          {t('agents.newAgent')}
+        </button>
+      </div>
+
+      {/* Agents grid */}
+      {agents.length > 0 && (
+        <div className="mb-10">
+          <h3 className="text-sm font-semibold text-muted-foreground uppercase tracking-wider mb-3">
+            {t('agents.myAgents')}
+          </h3>
+
+          {/* Search and filter */}
+          <div className="flex flex-col sm:flex-row items-start sm:items-center gap-3 mb-4">
+            <div className="relative flex-1 w-full sm:max-w-xs">
+              <Search className="absolute left-3 top-1/2 -translate-y-1/2 w-4 h-4 text-muted-foreground" />
+              <input
+                type="text"
+                value={searchQuery}
+                onChange={e => setSearchQuery(e.target.value)}
+                placeholder={t('agents.searchPlaceholder')}
+                className="w-full pl-9 pr-3 py-2 text-sm bg-card border border-border rounded-lg outline-none focus:border-primary/40 focus:ring-2 focus:ring-primary/10 transition-all"
+              />
+            </div>
+            <div className="flex items-center gap-1.5 flex-wrap">
+              {typeFilterOptions.map(opt => (
+                <button
+                  key={opt.value}
+                  onClick={() => setTypeFilter(opt.value)}
+                  className={`px-3 py-1.5 text-xs font-medium rounded-full transition-colors ${
+                    typeFilter === opt.value
+                      ? 'bg-primary text-white'
+                      : 'bg-muted text-muted-foreground hover:bg-accent'
+                  }`}
+                >
+                  {t(opt.labelKey)}
+                </button>
+              ))}
+            </div>
+          </div>
+
+          {filteredAgents.length > 0 ? (
+            <div className="grid grid-cols-1 md:grid-cols-2 lg:grid-cols-3 gap-4">
+              {filteredAgents.map(agent => (
+                <AgentCard
+                  key={agent.id}
+                  agent={agent}
+                  onEdit={handleEdit}
+                  onRefresh={refreshAgents}
+                  onToggle={handleToggle}
+                />
+              ))}
+            </div>
+          ) : (
+            <div className="flex flex-col items-center justify-center py-12 text-center">
+              <Search className="w-10 h-10 text-muted-foreground/30 mb-3" />
+              <p className="text-sm text-muted-foreground">{t('agents.noResults')}</p>
+            </div>
+          )}
+        </div>
+      )}
+
+      {/* Empty state */}
+      {agents.length === 0 && (
+        <div className="flex flex-col items-center justify-center py-16 text-center mb-10">
+          <Bot className="w-16 h-16 text-muted-foreground/30 mb-4" />
+          <h3 className="text-lg font-medium text-muted-foreground mb-2">{t('agents.noAgents')}</h3>
+          <p className="text-sm text-muted-foreground max-w-sm">
+            {t('agents.noAgentsDescription')}
+          </p>
+        </div>
+      )}
+
+      {/* Templates */}
+      <AgentTemplates onInstalled={refreshAgents} existingAgentNames={existingAgentNames} />
+
+      {/* Form modal */}
+      {showForm && (
+        <AgentForm
+          agent={editingAgent}
+          notebooks={notebooks}
+          onSave={handleSave}
+          onCancel={() => { setShowForm(false); setEditingAgent(null) }}
+        />
+      )}
+
+      {/* Run log modal */}
+      {logAgent && (
+        <AgentRunLog
+          agentId={logAgent.id}
+          agentName={logAgent.name}
+          onClose={() => setLogAgent(null)}
+        />
+      )}
+
+      {/* Help modal */}
+      {showHelp && (
+        <AgentHelp onClose={() => setShowHelp(false)} />
+      )}
+    </>
+  )
+}

memento-note/app/(main)/agents/page.tsx

@@ -0,0 +1,33 @@
+import { auth } from '@/auth'
+import { redirect } from 'next/navigation'
+import { prisma } from '@/lib/prisma'
+import { getAgents } from '@/app/actions/agent-actions'
+import { AgentsPageClient } from './agents-page-client'
+
+export default async function AgentsPage() {
+  const session = await auth()
+  if (!session?.user?.id) redirect('/login')
+
+  const userId = session.user.id
+
+  const [agents, notebooks] = await Promise.all([
+    getAgents(),
+    prisma.notebook.findMany({
+      where: { userId },
+      orderBy: { order: 'asc' }
+    })
+  ])
+
+  return (
+    <div className="flex-1 flex flex-col h-full bg-background">
+      <div className="flex-1 p-8 overflow-y-auto">
+        <div className="max-w-6xl mx-auto">
+          <AgentsPageClient
+            agents={agents}
+            notebooks={notebooks}
+          />
+        </div>
+      </div>
+    </div>
+  )
+}

memento-note/app/(main)/archive/page.tsx

@@ -0,0 +1,16 @@
+import { getArchivedNotes } from '@/app/actions/notes'
+import { MasonryGrid } from '@/components/masonry-grid'
+import { ArchiveHeader } from '@/components/archive-header'
+
+export const dynamic = 'force-dynamic'
+
+export default async function ArchivePage() {
+  const notes = await getArchivedNotes()
+
+  return (
+    <main className="container mx-auto px-4 py-8 max-w-7xl">
+      <ArchiveHeader />
+      <MasonryGrid notes={notes} />
+    </main>
+  )
+}

memento-note/app/(main)/chat/page.tsx

@@ -0,0 +1,44 @@
+import { Metadata } from 'next'
+import { auth } from '@/auth'
+import { redirect } from 'next/navigation'
+import { prisma } from '@/lib/prisma'
+import { ChatContainer } from '@/components/chat/chat-container'
+import { getConversations } from '@/app/actions/chat-actions'
+import { getSystemConfig } from '@/lib/config'
+
+export const metadata: Metadata = {
+  title: 'Chat IA | Memento',
+  description: 'Discutez avec vos notes et vos agents IA',
+}
+
+export default async function ChatPage() {
+  const session = await auth()
+  if (!session?.user?.id) redirect('/login')
+
+  const userId = session.user.id
+
+  // Fetch initial data
+  const [conversations, notebooks, config] = await Promise.all([
+    getConversations(),
+    prisma.notebook.findMany({
+      where: { userId },
+      orderBy: { order: 'asc' }
+    }),
+    getSystemConfig(),
+  ])
+
+  // Check if web search tools are configured
+  const webSearchAvailable = !!(
+    config.WEB_SEARCH_PROVIDER || config.BRAVE_SEARCH_API_KEY || config.SEARXNG_URL || config.JINA_API_KEY
+  )
+
+  return (
+    <div className="flex-1 flex flex-col h-full bg-white dark:bg-[#1a1c22]">
+      <ChatContainer
+        initialConversations={conversations}
+        notebooks={notebooks}
+        webSearchAvailable={webSearchAvailable}
+      />
+    </div>
+  )
+}

memento-note/app/(main)/lab/page.tsx

@@ -0,0 +1,56 @@
+import { Metadata } from 'next'
+import { auth } from '@/auth'
+import { redirect } from 'next/navigation'
+import { getCanvases, createCanvas } from '@/app/actions/canvas-actions'
+import { LabHeader } from '@/components/lab/lab-header'
+import { CanvasWrapper } from '@/components/lab/canvas-wrapper'
+
+export const metadata: Metadata = {
+  title: 'Le Lab | Memento',
+  description: 'Visualisez et connectez vos idées sur un canvas interactif',
+}
+
+export const dynamic = 'force-dynamic'
+export const revalidate = 0
+
+export default async function LabPage(props: {
+  searchParams: Promise<{ id?: string }>
+}) {
+  const searchParams = await props.searchParams
+  const id = searchParams.id
+  
+  const session = await auth()
+  if (!session?.user?.id) redirect('/login')
+
+  const canvases = await getCanvases()
+  
+  // Resolve current canvas correctly
+  const currentCanvasId = searchParams.id || (canvases.length > 0 ? canvases[0].id : undefined)
+  const currentCanvas = currentCanvasId ? canvases.find(c => c.id === currentCanvasId) : undefined
+
+  // Wrapper for server action creation
+  async function handleCreate() {
+    'use server'
+    const newCanvas = await createCanvas()
+    redirect(`/lab?id=${newCanvas.id}`)
+  }
+
+  return (
+    <div className="flex-1 flex flex-col h-full bg-slate-50 dark:bg-[#1a1c22] overflow-hidden">
+      <LabHeader 
+        canvases={canvases} 
+        currentCanvasId={currentCanvasId ?? null} 
+        onCreateCanvas={handleCreate}
+      />
+
+      <div className="flex-1 relative">
+        <CanvasWrapper 
+          key={currentCanvasId || 'new'}
+          canvasId={currentCanvas?.id} 
+          name={currentCanvas?.name || "Nouvel Espace de Pensée"}
+          initialData={currentCanvas?.data}
+        />
+      </div>
+    </div>
+  )
+}

memento-note/app/(main)/layout.tsx

@@ -0,0 +1,41 @@
+import { HeaderWrapper } from "@/components/header-wrapper";
+import { Sidebar } from "@/components/sidebar";
+import { ProvidersWrapper } from "@/components/providers-wrapper";
+import { auth } from "@/auth";
+import { detectUserLanguage } from "@/lib/i18n/detect-user-language";
+import { loadTranslations } from "@/lib/i18n/load-translations";
+
+export default async function MainLayout({
+  children,
+}: Readonly<{
+  children: React.ReactNode;
+}>) {
+  // Run auth + language detection + translation loading in parallel
+  const [session, initialLanguage] = await Promise.all([
+    auth(),
+    detectUserLanguage(),
+  ]);
+
+  // Load initial translations server-side to prevent hydration mismatch
+  const initialTranslations = await loadTranslations(initialLanguage);
+
+  return (
+    <ProvidersWrapper initialLanguage={initialLanguage} initialTranslations={initialTranslations}>
+      <div className="bg-background-light dark:bg-background-dark font-display text-slate-900 dark:text-white overflow-hidden h-screen flex flex-col">
+        {/* Top Navigation - Style Keep */}
+        <HeaderWrapper user={session?.user} />
+
+        {/* Main Layout */}
+        <div className="flex flex-1 overflow-hidden">
+          {/* Sidebar Navigation - Style Keep */}
+          <Sidebar className="w-64 flex-none flex-col bg-white dark:bg-[#1e2128] border-e border-slate-200 dark:border-slate-800 overflow-y-auto hidden md:flex" user={session?.user} />
+
+          {/* Main Content Area */}
+          <main className="flex min-h-0 flex-1 flex-col overflow-y-auto bg-background-light dark:bg-background-dark p-4 scroll-smooth">
+            {children}
+          </main>
+        </div>
+      </div>
+    </ProvidersWrapper>
+  );
+}

memento-note/app/(main)/page.tsx

@@ -0,0 +1,27 @@
+import { getAllNotes } from '@/app/actions/notes'
+import { getAISettings } from '@/app/actions/ai-settings'
+import { HomeClient } from '@/components/home-client'
+
+export default async function HomePage() {
+  const [allNotes, settings] = await Promise.all([
+    getAllNotes(),
+    getAISettings(),
+  ])
+
+  const notesViewMode =
+    settings?.notesViewMode === 'masonry'
+      ? 'masonry' as const
+      : settings?.notesViewMode === 'tabs' || settings?.notesViewMode === 'list'
+        ? 'tabs' as const
+        : 'masonry' as const
+
+  return (
+    <HomeClient
+      initialNotes={allNotes}
+      initialSettings={{
+        showRecentNotes: settings?.showRecentNotes !== false,
+        notesViewMode,
+      }}
+    />
+  )
+}

memento-note/app/(main)/reminders/page.tsx

@@ -0,0 +1,9 @@
+import { getNotesWithReminders } from '@/app/actions/notes'
+import { RemindersPage } from '@/components/reminders-page'
+
+export const dynamic = 'force-dynamic'
+
+export default async function RemindersRoute() {
+  const notes = await getNotesWithReminders()
+  return <RemindersPage notes={notes} />
+}

memento-note/app/(main)/settings/about/page.tsx

@@ -0,0 +1,136 @@
+'use client'
+
+import { SettingsSection } from '@/components/settings'
+import { Card, CardContent } from '@/components/ui/card'
+import { Badge } from '@/components/ui/badge'
+import { useLanguage } from '@/lib/i18n'
+
+export default function AboutSettingsPage() {
+  const { t } = useLanguage()
+  const version = '1.0.0'
+  const buildDate = '2026-01-17'
+
+  return (
+    <div className="space-y-6">
+      <div>
+        <h1 className="text-3xl font-bold mb-2">{t('about.title')}</h1>
+        <p className="text-gray-600 dark:text-gray-400">
+          {t('about.description')}
+        </p>
+      </div>
+
+      <SettingsSection
+        title={t('about.appName')}
+        icon={<span className="text-2xl">📝</span>}
+        description={t('about.appDescription')}
+      >
+        <Card>
+          <CardContent className="pt-6 space-y-4">
+            <div className="flex justify-between items-center">
+              <span className="font-medium">{t('about.version')}</span>
+              <Badge variant="secondary">{version}</Badge>
+            </div>
+            <div className="flex justify-between items-center">
+              <span className="font-medium">{t('about.buildDate')}</span>
+              <Badge variant="outline">{buildDate}</Badge>
+            </div>
+            <div className="flex justify-between items-center">
+              <span className="font-medium">{t('about.platform')}</span>
+              <Badge variant="outline">{t('about.platformWeb')}</Badge>
+            </div>
+          </CardContent>
+        </Card>
+      </SettingsSection>
+
+      <SettingsSection
+        title={t('about.features.title')}
+        icon={<span className="text-2xl">✨</span>}
+        description={t('about.features.description')}
+      >
+        <Card>
+          <CardContent className="pt-6 space-y-2">
+            <div className="flex items-center gap-2">
+              <span className="text-green-500">✓</span>
+              <span>{t('about.features.titleSuggestions')}</span>
+            </div>
+            <div className="flex items-center gap-2">
+              <span className="text-green-500">✓</span>
+              <span>{t('about.features.semanticSearch')}</span>
+            </div>
+            <div className="flex items-center gap-2">
+              <span className="text-green-500">✓</span>
+              <span>{t('about.features.paragraphReformulation')}</span>
+            </div>
+            <div className="flex items-center gap-2">
+              <span className="text-green-500">✓</span>
+              <span>{t('about.features.memoryEcho')}</span>
+            </div>
+            <div className="flex items-center gap-2">
+              <span className="text-green-500">✓</span>
+              <span>{t('about.features.notebookOrganization')}</span>
+            </div>
+            <div className="flex items-center gap-2">
+              <span className="text-green-500">✓</span>
+              <span>{t('about.features.dragDrop')}</span>
+            </div>
+            <div className="flex items-center gap-2">
+              <span className="text-green-500">✓</span>
+              <span>{t('about.features.labelSystem')}</span>
+            </div>
+            <div className="flex items-center gap-2">
+              <span className="text-green-500">✓</span>
+              <span>{t('about.features.multipleProviders')}</span>
+            </div>
+          </CardContent>
+        </Card>
+      </SettingsSection>
+
+      <SettingsSection
+        title={t('about.technology.title')}
+        icon={<span className="text-2xl">⚙️</span>}
+        description={t('about.technology.description')}
+      >
+        <Card>
+          <CardContent className="pt-6 space-y-2 text-sm">
+            <div><strong>{t('about.technology.frontend')}:</strong> Next.js 16, React 19, TypeScript</div>
+            <div><strong>{t('about.technology.backend')}:</strong> Next.js API Routes, Server Actions</div>
+            <div><strong>{t('about.technology.database')}:</strong> SQLite (Prisma ORM)</div>
+            <div><strong>{t('about.technology.authentication')}:</strong> NextAuth 5</div>
+            <div><strong>{t('about.technology.ai')}:</strong> Vercel AI SDK, OpenAI, Ollama</div>
+            <div><strong>{t('about.technology.ui')}:</strong> Radix UI, Tailwind CSS, Lucide Icons</div>
+            <div><strong>{t('about.technology.testing')}:</strong> Playwright (E2E)</div>
+          </CardContent>
+        </Card>
+      </SettingsSection>
+
+      <SettingsSection
+        title={t('about.support.title')}
+        icon={<span className="text-2xl">💬</span>}
+        description={t('about.support.description')}
+      >
+        <Card>
+          <CardContent className="pt-6 space-y-4">
+            <div>
+              <p className="font-medium mb-2">{t('about.support.documentation')}</p>
+              <p className="text-sm text-gray-600 dark:text-gray-400">
+                Check the documentation for detailed guides and tutorials.
+              </p>
+            </div>
+            <div>
+              <p className="font-medium mb-2">{t('about.support.reportIssues')}</p>
+              <p className="text-sm text-gray-600 dark:text-gray-400">
+                Found a bug? Report it in the issue tracker.
+              </p>
+            </div>
+            <div>
+              <p className="font-medium mb-2">{t('about.support.feedback')}</p>
+              <p className="text-sm text-gray-600 dark:text-gray-400">
+                We value your feedback! Share your thoughts and suggestions.
+              </p>
+            </div>
+          </CardContent>
+        </Card>
+      </SettingsSection>
+    </div>
+  )
+}

memento-note/app/(main)/settings/ai/ai-settings-header.tsx

@@ -0,0 +1,16 @@
+'use client'
+
+import { useLanguage } from '@/lib/i18n'
+
+export function AISettingsHeader() {
+  const { t } = useLanguage()
+
+  return (
+    <div className="mb-6">
+      <h1 className="text-3xl font-bold">{t('aiSettings.title')}</h1>
+      <p className="text-gray-600 dark:text-gray-400">
+        {t('aiSettings.description')}
+      </p>
+    </div>
+  )
+}

memento-note/app/(main)/settings/ai/page-new.tsx

@@ -0,0 +1,184 @@
+'use client'
+
+import { useState } from 'react'
+import { SettingsNav, SettingsSection, SettingToggle, SettingSelect, SettingInput } from '@/components/settings'
+import { updateAISettings } from '@/app/actions/ai-settings'
+import { toast } from 'sonner'
+import { useLanguage } from '@/lib/i18n'
+
+export default function AISettingsPage() {
+  const { t } = useLanguage()
+  const [apiKey, setApiKey] = useState('')
+
+  // Mock settings state - in real implementation, load from server
+  const [settings, setSettings] = useState({
+    titleSuggestions: true,
+    semanticSearch: true,
+    paragraphRefactor: true,
+    memoryEcho: true,
+    memoryEchoFrequency: 'daily' as 'daily' | 'weekly' | 'custom',
+    aiProvider: 'auto' as 'auto' | 'openai' | 'ollama',
+    preferredLanguage: 'auto' as 'auto' | 'en' | 'fr' | 'es' | 'de' | 'fa' | 'it' | 'pt' | 'ru' | 'zh' | 'ja' | 'ko' | 'ar' | 'hi' | 'nl' | 'pl',
+    demoMode: false
+  })
+
+  const handleToggle = async (feature: string, value: boolean) => {
+    setSettings(prev => ({ ...prev, [feature]: value }))
+    try {
+      await updateAISettings({ [feature]: value })
+    } catch (error) {
+      toast.error(t('aiSettings.error'))
+      setSettings(settings) // Revert on error
+    }
+  }
+
+  const handleFrequencyChange = async (value: string) => {
+    setSettings(prev => ({ ...prev, memoryEchoFrequency: value as any }))
+    try {
+      await updateAISettings({ memoryEchoFrequency: value as any })
+    } catch (error) {
+      toast.error(t('aiSettings.error'))
+    }
+  }
+
+  const handleProviderChange = async (value: string) => {
+    setSettings(prev => ({ ...prev, aiProvider: value as any }))
+    try {
+      await updateAISettings({ aiProvider: value as any })
+    } catch (error) {
+      toast.error(t('aiSettings.error'))
+    }
+  }
+
+  const handleApiKeyChange = async (value: string) => {
+    setApiKey(value)
+    // TODO: Implement API key persistence
+
+  }
+
+  return (
+    <div className="container mx-auto py-10 px-4 max-w-6xl">
+      <div className="grid grid-cols-1 lg:grid-cols-4 gap-6">
+        {/* Sidebar Navigation */}
+        <aside className="lg:col-span-1">
+          <SettingsNav />
+        </aside>
+
+        {/* Main Content */}
+        <main className="lg:col-span-3 space-y-6">
+          <div>
+            <h1 className="text-3xl font-bold mb-2">{t('aiSettings.title')}</h1>
+            <p className="text-gray-600 dark:text-gray-400">
+              {t('aiSettings.description')}
+            </p>
+          </div>
+
+          {/* AI Provider */}
+          <SettingsSection
+            title={t('aiSettings.provider')}
+            icon={<span className="text-2xl">🤖</span>}
+            description={t('aiSettings.providerDesc')}
+          >
+            <SettingSelect
+              label={t('aiSettings.provider')}
+              description={t('aiSettings.providerDesc')}
+              value={settings.aiProvider}
+              options={[
+                {
+                  value: 'auto',
+                  label: t('aiSettings.providerAuto'),
+                  description: t('aiSettings.providerAutoDesc')
+                },
+                {
+                  value: 'ollama',
+                  label: t('aiSettings.providerOllama'),
+                  description: t('aiSettings.providerOllamaDesc')
+                },
+                {
+                  value: 'openai',
+                  label: t('aiSettings.providerOpenAI'),
+                  description: t('aiSettings.providerOpenAIDesc')
+                },
+              ]}
+              onChange={handleProviderChange}
+            />
+
+            {settings.aiProvider === 'openai' && (
+              <SettingInput
+                label={t('admin.ai.apiKey')}
+                description={t('admin.ai.openAIKeyDescription')}
+                value={apiKey}
+                type="password"
+                placeholder="sk-..."
+                onChange={handleApiKeyChange}
+              />
+            )}
+          </SettingsSection>
+
+          {/* Feature Toggles */}
+          <SettingsSection
+            title={t('aiSettings.features')}
+            icon={<span className="text-2xl">✨</span>}
+            description={t('aiSettings.description')}
+          >
+            <SettingToggle
+              label={t('titleSuggestions.available').replace('💡 ', '')}
+              description={t('aiSettings.titleSuggestionsDesc')}
+              checked={settings.titleSuggestions}
+              onChange={(checked) => handleToggle('titleSuggestions', checked)}
+            />
+
+            <SettingToggle
+              label={t('semanticSearch.exactMatch')}
+              description={t('semanticSearch.searching')}
+              checked={settings.semanticSearch}
+              onChange={(checked) => handleToggle('semanticSearch', checked)}
+            />
+
+            <SettingToggle
+              label={t('paragraphRefactor.title')}
+              description={t('aiSettings.paragraphRefactorDesc')}
+              checked={settings.paragraphRefactor}
+              onChange={(checked) => handleToggle('paragraphRefactor', checked)}
+            />
+
+            <SettingToggle
+              label={t('memoryEcho.title')}
+              description={t('memoryEcho.dailyInsight')}
+              checked={settings.memoryEcho}
+              onChange={(checked) => handleToggle('memoryEcho', checked)}
+            />
+
+            {settings.memoryEcho && (
+              <SettingSelect
+                label={t('aiSettings.frequency')}
+                description={t('aiSettings.frequencyDesc')}
+                value={settings.memoryEchoFrequency}
+                options={[
+                  { value: 'daily', label: t('aiSettings.frequencyDaily') },
+                  { value: 'weekly', label: t('aiSettings.frequencyWeekly') },
+                  { value: 'custom', label: 'Custom' },
+                ]}
+                onChange={handleFrequencyChange}
+              />
+            )}
+          </SettingsSection>
+
+          {/* Demo Mode */}
+          <SettingsSection
+            title={t('demoMode.title')}
+            icon={<span className="text-2xl">🎭</span>}
+            description={t('demoMode.description')}
+          >
+            <SettingToggle
+              label={t('demoMode.title')}
+              description={t('demoMode.description')}
+              checked={settings.demoMode}
+              onChange={(checked) => handleToggle('demoMode', checked)}
+            />
+          </SettingsSection>
+        </main>
+      </div>
+    </div>
+  )
+}

memento-note/app/(main)/settings/ai/page.tsx

@@ -0,0 +1,22 @@
+import { auth } from '@/auth'
+import { redirect } from 'next/navigation'
+import { AISettingsPanel } from '@/components/ai/ai-settings-panel'
+import { getAISettings } from '@/app/actions/ai-settings'
+import { AISettingsHeader } from './ai-settings-header'
+
+export default async function AISettingsPage() {
+  const session = await auth()
+
+  if (!session?.user) {
+    redirect('/api/auth/signin')
+  }
+
+  const settings = await getAISettings()
+
+  return (
+    <div className="space-y-6">
+      <AISettingsHeader />
+      <AISettingsPanel initialSettings={settings} />
+    </div>
+  )
+}

memento-note/app/(main)/settings/appearance/appearance-form.tsx

@@ -0,0 +1,132 @@
+'use client'
+
+import { useRouter } from 'next/navigation'
+import { useState } from 'react'
+import { SettingsSection, SettingSelect } from '@/components/settings'
+import { updateAISettings as updateAI } from '@/app/actions/ai-settings'
+import { updateUserSettings as updateUser } from '@/app/actions/user-settings'
+import { useLanguage } from '@/lib/i18n'
+
+interface AppearanceSettingsFormProps {
+    initialTheme: string
+    initialFontSize: string
+    initialCardSizeMode?: string
+}
+
+export function AppearanceSettingsForm({ initialTheme, initialFontSize, initialCardSizeMode = 'variable' }: AppearanceSettingsFormProps) {
+    const router = useRouter()
+    const [theme, setTheme] = useState(initialTheme)
+    const [fontSize, setFontSize] = useState(initialFontSize)
+    const [cardSizeMode, setCardSizeMode] = useState(initialCardSizeMode)
+    const { t } = useLanguage()
+
+    const handleThemeChange = async (value: string) => {
+        setTheme(value)
+        localStorage.setItem('theme-preference', value)
+
+        // Instant visual update
+        const root = document.documentElement
+        root.removeAttribute('data-theme')
+        root.classList.remove('dark')
+
+        if (value === 'auto') {
+            if (window.matchMedia('(prefers-color-scheme: dark)').matches) root.classList.add('dark')
+        } else if (value === 'dark') {
+            root.classList.add('dark')
+        } else if (value === 'light') {
+            root.setAttribute('data-theme', 'light')
+        } else {
+            root.setAttribute('data-theme', value)
+            if (['midnight', 'blue', 'sepia'].includes(value)) root.classList.add('dark')
+        }
+
+        // Save to DB (no need for router.refresh - localStorage handles immediate visuals)
+        await updateUser({ theme: value as 'light' | 'dark' | 'auto' | 'sepia' | 'midnight' | 'blue' })
+    }
+
+    const handleFontSizeChange = async (value: string) => {
+        setFontSize(value)
+
+        // Instant visual update
+        const fontSizeMap: Record<string, string> = {
+            'small': '14px', 'medium': '16px', 'large': '18px', 'extra-large': '20px'
+        }
+        const root = document.documentElement
+        root.style.setProperty('--user-font-size', fontSizeMap[value] || '16px')
+
+        await updateAI({ fontSize: value as any })
+    }
+
+    const handleCardSizeModeChange = async (value: string) => {
+        setCardSizeMode(value)
+        localStorage.setItem('card-size-mode', value)
+        await updateUser({ cardSizeMode: value as 'variable' | 'uniform' })
+    }
+
+    return (
+        <div className="space-y-6">
+            <div>
+                <h1 className="text-3xl font-bold mb-2">{t('appearance.title')}</h1>
+                <p className="text-gray-600 dark:text-gray-400">
+                    {t('appearance.description')}
+                </p>
+            </div>
+
+            <SettingsSection
+                title={t('settings.theme')}
+                icon={<span className="text-2xl">🎨</span>}
+                description={t('settings.themeLight') + ' / ' + t('settings.themeDark')}
+            >
+                <SettingSelect
+                    label={t('settings.theme')}
+                    description={t('settings.selectLanguage')}
+                    value={theme}
+                    options={[
+                        { value: 'slate', label: t('settings.themeLight') },
+                        { value: 'dark', label: t('settings.themeDark') },
+                        { value: 'sepia', label: 'Sepia' },
+                        { value: 'midnight', label: 'Midnight' },
+                        { value: 'blue', label: 'Blue' },
+                        { value: 'auto', label: t('settings.themeSystem') },
+                    ]}
+                    onChange={handleThemeChange}
+                />
+            </SettingsSection>
+
+            <SettingsSection
+                title={t('profile.fontSize')}
+                icon={<span className="text-2xl">📝</span>}
+                description={t('profile.fontSizeDescription')}
+            >
+                <SettingSelect
+                    label={t('profile.fontSize')}
+                    description={t('profile.selectFontSize')}
+                    value={fontSize}
+                    options={[
+                        { value: 'small', label: t('profile.fontSizeSmall') },
+                        { value: 'medium', label: t('profile.fontSizeMedium') },
+                        { value: 'large', label: t('profile.fontSizeLarge') },
+                    ]}
+                    onChange={handleFontSizeChange}
+                />
+            </SettingsSection>
+
+            <SettingsSection
+                title={t('settings.cardSizeMode')}
+                icon={<span className="text-2xl">📐</span>}
+                description={t('settings.cardSizeModeDescription')}
+            >
+                <SettingSelect
+                    label={t('settings.cardSizeMode')}
+                    description={t('settings.selectCardSizeMode')}
+                    value={cardSizeMode}
+                    options={[
+                        { value: 'variable', label: t('settings.cardSizeVariable') },
+                        { value: 'uniform', label: t('settings.cardSizeUniform') },
+                    ]}
+                    onChange={handleCardSizeModeChange}
+                />
+            </SettingsSection>
+        </div>
+    )
+}

memento-note/app/(main)/settings/appearance/appearance-settings-client.tsx

@@ -0,0 +1,154 @@
+'use client'
+
+import { useState } from 'react'
+import { SettingsSection, SettingSelect } from '@/components/settings'
+import { updateAISettings } from '@/app/actions/ai-settings'
+import { updateUserSettings } from '@/app/actions/user-settings'
+import { useLanguage } from '@/lib/i18n'
+import { toast } from 'sonner'
+
+interface AppearanceSettingsClientProps {
+  initialFontSize: string
+  initialTheme: string
+  initialNotesViewMode: 'masonry' | 'tabs'
+  initialCardSizeMode?: 'variable' | 'uniform'
+}
+
+export function AppearanceSettingsClient({ initialFontSize, initialTheme, initialNotesViewMode, initialCardSizeMode = 'variable' }: AppearanceSettingsClientProps) {
+  const { t } = useLanguage()
+  const [theme, setTheme] = useState(initialTheme || 'light')
+  const [fontSize, setFontSize] = useState(initialFontSize || 'medium')
+  const [notesViewMode, setNotesViewMode] = useState<'masonry' | 'tabs'>(initialNotesViewMode)
+  const [cardSizeMode, setCardSizeMode] = useState<'variable' | 'uniform'>(initialCardSizeMode)
+
+  const handleThemeChange = async (value: string) => {
+    setTheme(value)
+    localStorage.setItem('theme-preference', value)
+
+    const root = document.documentElement
+    root.removeAttribute('data-theme')
+    root.classList.remove('dark')
+
+    if (value === 'auto') {
+      if (window.matchMedia('(prefers-color-scheme: dark)').matches) root.classList.add('dark')
+    } else if (value === 'dark') {
+      root.classList.add('dark')
+    } else {
+      root.setAttribute('data-theme', value)
+      if (['midnight'].includes(value)) root.classList.add('dark')
+    }
+
+    await updateUserSettings({ theme: value as 'light' | 'dark' | 'auto' })
+    toast.success(t('settings.settingsSaved') || 'Saved')
+  }
+
+  const handleFontSizeChange = async (value: string) => {
+    setFontSize(value)
+
+    const fontSizeMap: Record<string, string> = {
+      'small': '14px', 'medium': '16px', 'large': '18px', 'extra-large': '20px'
+    }
+    document.documentElement.style.setProperty('--user-font-size', fontSizeMap[value] || '16px')
+
+    await updateAISettings({ fontSize: value as any })
+    toast.success(t('settings.settingsSaved') || 'Saved')
+  }
+
+  const handleNotesViewChange = async (value: string) => {
+    const mode = value === 'tabs' ? 'tabs' : 'masonry'
+    setNotesViewMode(mode)
+    await updateAISettings({ notesViewMode: mode })
+    toast.success(t('settings.settingsSaved') || 'Saved')
+  }
+
+  const handleCardSizeModeChange = async (value: string) => {
+    const mode = value === 'uniform' ? 'uniform' : 'variable'
+    setCardSizeMode(mode)
+    localStorage.setItem('card-size-mode', mode)
+    await updateUserSettings({ cardSizeMode: mode })
+    toast.success(t('settings.settingsSaved') || 'Saved')
+  }
+
+  return (
+    <div className="space-y-6">
+      <div>
+        <h1 className="text-3xl font-bold mb-2">{t('appearance.title')}</h1>
+        <p className="text-gray-600 dark:text-gray-400">
+          {t('appearance.description')}
+        </p>
+      </div>
+
+      <SettingsSection
+        title={t('settings.theme')}
+        icon={<span className="text-2xl">🎨</span>}
+        description={t('settings.themeLight') + ' / ' + t('settings.themeDark')}
+      >
+        <SettingSelect
+          label={t('settings.theme')}
+          description={t('appearance.selectTheme')}
+          value={theme}
+          options={[
+            { value: 'light', label: t('settings.themeLight') },
+            { value: 'dark', label: t('settings.themeDark') },
+            { value: 'sepia', label: 'Sepia' },
+            { value: 'midnight', label: 'Midnight' },
+            { value: 'auto', label: t('settings.themeSystem') },
+          ]}
+          onChange={handleThemeChange}
+        />
+      </SettingsSection>
+
+      <SettingsSection
+        title={t('profile.fontSize')}
+        icon={<span className="text-2xl">📝</span>}
+        description={t('profile.fontSizeDescription')}
+      >
+        <SettingSelect
+          label={t('profile.fontSize')}
+          description={t('profile.selectFontSize')}
+          value={fontSize}
+          options={[
+            { value: 'small', label: t('profile.fontSizeSmall') },
+            { value: 'medium', label: t('profile.fontSizeMedium') },
+            { value: 'large', label: t('profile.fontSizeLarge') },
+          ]}
+          onChange={handleFontSizeChange}
+        />
+      </SettingsSection>
+
+      <SettingsSection
+        title={t('appearance.notesViewLabel')}
+        icon={<span className="text-2xl">📋</span>}
+        description={t('appearance.notesViewDescription')}
+      >
+        <SettingSelect
+          label={t('appearance.notesViewLabel')}
+          description={t('appearance.notesViewDescription')}
+          value={notesViewMode}
+          options={[
+            { value: 'masonry', label: t('appearance.notesViewMasonry') },
+            { value: 'tabs', label: t('appearance.notesViewTabs') },
+          ]}
+          onChange={handleNotesViewChange}
+        />
+      </SettingsSection>
+
+      <SettingsSection
+        title={t('settings.cardSizeMode')}
+        icon={<span className="text-2xl">📐</span>}
+        description={t('settings.cardSizeModeDescription')}
+      >
+        <SettingSelect
+          label={t('settings.cardSizeMode')}
+          description={t('settings.selectCardSizeMode')}
+          value={cardSizeMode}
+          options={[
+            { value: 'variable', label: t('settings.cardSizeVariable') },
+            { value: 'uniform', label: t('settings.cardSizeUniform') },
+          ]}
+          onChange={handleCardSizeModeChange}
+        />
+      </SettingsSection>
+    </div>
+  )
+}

memento-note/app/(main)/settings/appearance/page.tsx

@@ -0,0 +1,26 @@
+import { auth } from '@/auth'
+import { redirect } from 'next/navigation'
+import { getAISettings } from '@/app/actions/ai-settings'
+import { getUserSettings } from '@/app/actions/user-settings'
+import { AppearanceSettingsClient } from './appearance-settings-client'
+
+export default async function AppearanceSettingsPage() {
+  const session = await auth()
+  if (!session?.user) {
+    redirect('/api/auth/signin')
+  }
+
+  const [aiSettings, userSettings] = await Promise.all([
+    getAISettings(),
+    getUserSettings()
+  ])
+
+  return (
+    <AppearanceSettingsClient
+      initialFontSize={aiSettings.fontSize}
+      initialTheme={userSettings.theme}
+      initialNotesViewMode={aiSettings.notesViewMode === 'masonry' ? 'masonry' : 'tabs'}
+      initialCardSizeMode={userSettings.cardSizeMode}
+    />
+  )
+}

memento-note/app/(main)/settings/data/page.tsx

@@ -0,0 +1,191 @@
+'use client'
+
+import { useState } from 'react'
+import { SettingsSection } from '@/components/settings'
+import { Button } from '@/components/ui/button'
+import { Download, Upload, Trash2, Loader2 } from 'lucide-react'
+import { toast } from 'sonner'
+import { useLanguage } from '@/lib/i18n'
+import { useRouter } from 'next/navigation'
+
+export default function DataSettingsPage() {
+  const { t } = useLanguage()
+  const router = useRouter()
+  const [isExporting, setIsExporting] = useState(false)
+  const [isImporting, setIsImporting] = useState(false)
+  const [isDeleting, setIsDeleting] = useState(false)
+
+  const handleExport = async () => {
+    setIsExporting(true)
+    try {
+      const response = await fetch('/api/notes/export')
+      if (response.ok) {
+        const blob = await response.blob()
+        const url = window.URL.createObjectURL(blob)
+        const a = document.createElement('a')
+        a.href = url
+        a.download = `memento-note-export-${new Date().toISOString().split('T')[0]}.json`
+        document.body.appendChild(a)
+        a.click()
+        document.body.removeChild(a)
+        window.URL.revokeObjectURL(url)
+        toast.success(t('dataManagement.export.success'))
+      }
+    } catch (error) {
+      console.error('Export error:', error)
+      toast.error(t('dataManagement.export.failed'))
+    } finally {
+      setIsExporting(false)
+    }
+  }
+
+  const handleImport = async (event: React.ChangeEvent<HTMLInputElement>) => {
+    const file = event.target.files?.[0]
+    if (!file) return
+
+    setIsImporting(true)
+    try {
+      const formData = new FormData()
+      formData.append('file', file)
+
+      const response = await fetch('/api/notes/import', {
+        method: 'POST',
+        body: formData
+      })
+
+      if (response.ok) {
+        const result = await response.json()
+        toast.success(t('dataManagement.import.success', { count: result.count }))
+        router.refresh()
+      } else {
+        throw new Error('Import failed')
+      }
+    } catch (error) {
+      console.error('Import error:', error)
+      toast.error(t('dataManagement.import.failed'))
+    } finally {
+      setIsImporting(false)
+      event.target.value = ''
+    }
+  }
+
+  const handleDeleteAll = async () => {
+    if (!confirm(t('dataManagement.delete.confirm'))) {
+      return
+    }
+
+    setIsDeleting(true)
+    try {
+      const response = await fetch('/api/notes/delete-all', { method: 'POST' })
+      if (response.ok) {
+        toast.success(t('dataManagement.delete.success'))
+        router.refresh()
+      }
+    } catch (error) {
+      console.error('Delete error:', error)
+      toast.error(t('dataManagement.delete.failed'))
+    } finally {
+      setIsDeleting(false)
+    }
+  }
+
+  return (
+    <div className="space-y-6">
+      <div>
+        <h1 className="text-3xl font-bold mb-2">{t('dataManagement.title')}</h1>
+        <p className="text-gray-600 dark:text-gray-400">
+          {t('dataManagement.toolsDescription')}
+        </p>
+      </div>
+
+      <SettingsSection
+        title={`💾 ${t('dataManagement.export.title')}`}
+        icon={<span className="text-2xl">💾</span>}
+        description={t('dataManagement.export.description')}
+      >
+        <div className="flex items-center justify-between py-4">
+          <div>
+            <p className="font-medium">{t('dataManagement.export.title')}</p>
+            <p className="text-sm text-gray-600 dark:text-gray-400">
+              {t('dataManagement.export.description')}
+            </p>
+          </div>
+          <Button
+            onClick={handleExport}
+            disabled={isExporting}
+          >
+            {isExporting ? (
+              <Loader2 className="h-4 w-4 animate-spin mr-2" />
+            ) : (
+              <Download className="h-4 w-4 mr-2" />
+            )}
+            {isExporting ? t('dataManagement.exporting') : t('dataManagement.export.button')}
+          </Button>
+        </div>
+      </SettingsSection>
+
+      <SettingsSection
+        title={`📥 ${t('dataManagement.import.title')}`}
+        icon={<span className="text-2xl">📥</span>}
+        description={t('dataManagement.import.description')}
+      >
+        <div className="flex items-center justify-between py-4">
+          <div>
+            <p className="font-medium">{t('dataManagement.import.title')}</p>
+            <p className="text-sm text-gray-600 dark:text-gray-400">
+              {t('dataManagement.import.description')}
+            </p>
+          </div>
+          <div>
+            <input
+              type="file"
+              accept=".json"
+              onChange={handleImport}
+              disabled={isImporting}
+              className="hidden"
+              id="import-file"
+            />
+            <Button
+              onClick={() => document.getElementById('import-file')?.click()}
+              disabled={isImporting}
+            >
+              {isImporting ? (
+                <Loader2 className="h-4 w-4 animate-spin mr-2" />
+              ) : (
+                <Upload className="h-4 w-4 mr-2" />
+              )}
+              {isImporting ? t('dataManagement.importing') : t('dataManagement.import.button')}
+            </Button>
+          </div>
+        </div>
+      </SettingsSection>
+
+      <SettingsSection
+        title={`⚠️ ${t('dataManagement.dangerZone')}`}
+        icon={<span className="text-2xl">⚠️</span>}
+        description={t('dataManagement.dangerZoneDescription')}
+      >
+        <div className="flex items-center justify-between py-4 border-t border-red-200 dark:border-red-900">
+          <div>
+            <p className="font-medium text-red-600 dark:text-red-400">{t('dataManagement.delete.title')}</p>
+            <p className="text-sm text-gray-600 dark:text-gray-400">
+              {t('dataManagement.delete.description')}
+            </p>
+          </div>
+          <Button
+            variant="destructive"
+            onClick={handleDeleteAll}
+            disabled={isDeleting}
+          >
+            {isDeleting ? (
+              <Loader2 className="h-4 w-4 animate-spin mr-2" />
+            ) : (
+              <Trash2 className="h-4 w-4 mr-2" />
+            )}
+            {isDeleting ? t('dataManagement.deleting') : t('dataManagement.delete.button')}
+          </Button>
+        </div>
+      </SettingsSection>
+    </div>
+  )
+}

memento-note/app/(main)/settings/general/general-settings-client.tsx

@@ -0,0 +1,113 @@
+'use client'
+
+import { useState } from 'react'
+import { SettingsSection, SettingToggle, SettingSelect } from '@/components/settings'
+import { useLanguage } from '@/lib/i18n'
+import { updateAISettings } from '@/app/actions/ai-settings'
+import { toast } from 'sonner'
+import { useRouter } from 'next/navigation'
+
+interface GeneralSettingsClientProps {
+  initialSettings: {
+    preferredLanguage: string
+    emailNotifications: boolean
+    desktopNotifications: boolean
+  }
+}
+
+export function GeneralSettingsClient({ initialSettings }: GeneralSettingsClientProps) {
+  const { t, setLanguage: setContextLanguage } = useLanguage()
+  const router = useRouter()
+  const [language, setLanguage] = useState(initialSettings.preferredLanguage || 'auto')
+  const [emailNotifications, setEmailNotifications] = useState(initialSettings.emailNotifications ?? false)
+  const [desktopNotifications, setDesktopNotifications] = useState(initialSettings.desktopNotifications ?? false)
+
+  const handleLanguageChange = async (value: string) => {
+    setLanguage(value)
+    await updateAISettings({ preferredLanguage: value as any })
+
+    if (value === 'auto') {
+      localStorage.removeItem('user-language')
+      toast.success(t('settings.languageAuto') || 'Language set to Auto')
+    } else {
+      localStorage.setItem('user-language', value)
+      setContextLanguage(value as any)
+      toast.success(t('profile.languageUpdateSuccess') || 'Language updated')
+    }
+
+    setTimeout(() => router.refresh(), 300)
+  }
+
+  const handleEmailNotificationsChange = async (enabled: boolean) => {
+    setEmailNotifications(enabled)
+    await updateAISettings({ emailNotifications: enabled })
+    toast.success(t('settings.settingsSaved') || 'Saved')
+  }
+
+  const handleDesktopNotificationsChange = async (enabled: boolean) => {
+    setDesktopNotifications(enabled)
+    await updateAISettings({ desktopNotifications: enabled })
+    toast.success(t('settings.settingsSaved') || 'Saved')
+  }
+
+  return (
+    <div className="space-y-6">
+      <div>
+        <h1 className="text-3xl font-bold mb-2">{t('generalSettings.title')}</h1>
+        <p className="text-gray-600 dark:text-gray-400">
+          {t('generalSettings.description')}
+        </p>
+      </div>
+
+      <SettingsSection
+        title={t('settings.language')}
+        icon={<span className="text-2xl">🌍</span>}
+        description={t('profile.languagePreferencesDescription')}
+      >
+        <SettingSelect
+          label={t('settings.language')}
+          description={t('settings.selectLanguage')}
+          value={language}
+          options={[
+            { value: 'auto', label: t('profile.autoDetect') },
+            { value: 'en', label: 'English' },
+            { value: 'fr', label: 'Français' },
+            { value: 'es', label: 'Español' },
+            { value: 'de', label: 'Deutsch' },
+            { value: 'fa', label: 'فارسی' },
+            { value: 'it', label: 'Italiano' },
+            { value: 'pt', label: 'Português' },
+            { value: 'ru', label: 'Русский' },
+            { value: 'zh', label: '中文' },
+            { value: 'ja', label: '日本語' },
+            { value: 'ko', label: '한국어' },
+            { value: 'ar', label: 'العربية' },
+            { value: 'hi', label: 'हिन्दी' },
+            { value: 'nl', label: 'Nederlands' },
+            { value: 'pl', label: 'Polski' },
+          ]}
+          onChange={handleLanguageChange}
+        />
+      </SettingsSection>
+
+      <SettingsSection
+        title={t('settings.notifications')}
+        icon={<span className="text-2xl">🔔</span>}
+        description={t('settings.notificationsDesc')}
+      >
+        <SettingToggle
+          label={t('settings.emailNotifications')}
+          description={t('settings.emailNotificationsDesc')}
+          checked={emailNotifications}
+          onChange={handleEmailNotificationsChange}
+        />
+        <SettingToggle
+          label={t('settings.desktopNotifications')}
+          description={t('settings.desktopNotificationsDesc')}
+          checked={desktopNotifications}
+          onChange={handleDesktopNotificationsChange}
+        />
+      </SettingsSection>
+    </div>
+  )
+}

memento-note/app/(main)/settings/general/page.tsx

@@ -0,0 +1,15 @@
+import { auth } from '@/auth'
+import { redirect } from 'next/navigation'
+import { getAISettings } from '@/app/actions/ai-settings'
+import { GeneralSettingsClient } from './general-settings-client'
+
+export default async function GeneralSettingsPage() {
+  const session = await auth()
+  if (!session?.user) {
+    redirect('/api/auth/signin')
+  }
+
+  const settings = await getAISettings()
+
+  return <GeneralSettingsClient initialSettings={settings} />
+}

memento-note/app/(main)/settings/layout.tsx

@@ -0,0 +1,25 @@
+'use client'
+
+import { SettingsNav } from '@/components/settings'
+
+export default function SettingsLayout({
+    children,
+}: {
+    children: React.ReactNode
+}) {
+    return (
+        <div className="container mx-auto py-10 px-4 max-w-6xl">
+            <div className="grid grid-cols-1 lg:grid-cols-4 gap-6">
+                {/* Sidebar Navigation */}
+                <aside className="lg:col-span-1">
+                    <SettingsNav />
+                </aside>
+
+                {/* Main Content */}
+                <main className="lg:col-span-3 space-y-6">
+                    {children}
+                </main>
+            </div>
+        </div>
+    )
+}

memento-note/app/(main)/settings/loading.tsx

@@ -0,0 +1,26 @@
+export default function SettingsLoading() {
+  return (
+    <div className="space-y-6 animate-pulse">
+      <div>
+        <div className="h-9 w-64 bg-muted rounded-md mb-2" />
+        <div className="h-4 w-96 bg-muted rounded-md" />
+      </div>
+      {[1, 2, 3].map((i) => (
+        <div key={i} className="rounded-lg border border-border p-6 space-y-4">
+          <div className="flex items-center gap-3">
+            <div className="h-8 w-8 bg-muted rounded-full" />
+            <div className="h-5 w-40 bg-muted rounded-md" />
+          </div>
+          <div className="h-px bg-border" />
+          <div className="flex items-center justify-between p-4 rounded-lg bg-muted/30">
+            <div className="space-y-2">
+              <div className="h-4 w-32 bg-muted rounded" />
+              <div className="h-3 w-56 bg-muted rounded" />
+            </div>
+            <div className="h-6 w-11 bg-muted rounded-full" />
+          </div>
+        </div>
+      ))}
+    </div>
+  )
+}

memento-note/app/(main)/settings/mcp/page.tsx

@@ -0,0 +1,23 @@
+import { auth } from '@/auth'
+import { redirect } from 'next/navigation'
+import { McpSettingsPanel } from '@/components/mcp/mcp-settings-panel'
+import { listMcpKeys, getMcpServerStatus } from '@/app/actions/mcp-keys'
+
+export default async function McpSettingsPage() {
+  const session = await auth()
+
+  if (!session?.user) {
+    redirect('/api/auth/signin')
+  }
+
+  const [keys, serverStatus] = await Promise.all([
+    listMcpKeys(),
+    getMcpServerStatus(),
+  ])
+
+  return (
+    <div className="space-y-6">
+      <McpSettingsPanel initialKeys={keys} serverStatus={serverStatus} />
+    </div>
+  )
+}

memento-note/app/(main)/settings/page.tsx

@@ -0,0 +1,7 @@
+import { redirect } from 'next/navigation'
+
+// Immediate redirect to the first settings sub-page
+// This avoids loading the heavy settings/page.tsx client component on first visit
+export default function SettingsIndexPage() {
+  redirect('/settings/general')
+}

memento-note/app/(main)/settings/profile/ai-settings-link-card.tsx

@@ -0,0 +1,33 @@
+'use client'
+
+import { Button } from '@/components/ui/button'
+import { Card, CardContent, CardDescription, CardHeader, CardTitle } from '@/components/ui/card'
+import { ArrowRight, Sparkles } from 'lucide-react'
+import Link from 'next/link'
+import { useLanguage } from '@/lib/i18n'
+
+export function AISettingsLinkCard() {
+  const { t } = useLanguage()
+
+  return (
+    <Card className="mt-6">
+      <CardHeader>
+        <CardTitle className="flex items-center gap-2">
+          <Sparkles className="h-5 w-5 text-amber-500" />
+          {t('nav.aiSettings')}
+        </CardTitle>
+        <CardDescription>
+          {t('nav.configureAI')}
+        </CardDescription>
+      </CardHeader>
+      <CardContent>
+        <Link href="/settings/ai">
+          <Button variant="outline" className="w-full justify-between group">
+            <span>{t('nav.manageAISettings')}</span>
+            <ArrowRight className="h-4 w-4 group-hover:translate-x-1 transition-transform" />
+          </Button>
+        </Link>
+      </CardContent>
+    </Card>
+  )
+}

memento-note/app/(main)/settings/profile/page-new.tsx

@@ -0,0 +1,155 @@
+'use client'
+
+import { useState } from 'react'
+import { SettingsNav, SettingsSection, SettingToggle, SettingInput, SettingSelect } from '@/components/settings'
+import { updateAISettings } from '@/app/actions/ai-settings'
+import { toast } from 'sonner'
+import { useLanguage } from '@/lib/i18n'
+
+export default function ProfileSettingsPage() {
+  const { t } = useLanguage()
+
+  // Mock user data - in real implementation, load from server
+  const [user, setUser] = useState({
+    name: 'John Doe',
+    email: 'john@example.com'
+  })
+
+  const [language, setLanguage] = useState('auto')
+  const [showRecentNotes, setShowRecentNotes] = useState(false)
+
+  const handleNameChange = async (value: string) => {
+    setUser(prev => ({ ...prev, name: value }))
+    // TODO: Implement profile update
+
+  }
+
+  const handleEmailChange = async (value: string) => {
+    setUser(prev => ({ ...prev, email: value }))
+    // TODO: Implement email update
+
+  }
+
+  const handleLanguageChange = async (value: string) => {
+    setLanguage(value)
+    try {
+      await updateAISettings({ preferredLanguage: value as any })
+    } catch (error) {
+      console.error('Error updating language:', error)
+      toast.error(t('aiSettings.error'))
+    }
+  }
+
+  const handleRecentNotesChange = async (enabled: boolean) => {
+    setShowRecentNotes(enabled)
+    try {
+      await updateAISettings({ showRecentNotes: enabled })
+    } catch (error) {
+      console.error('Error updating recent notes setting:', error)
+      toast.error(t('aiSettings.error'))
+    }
+  }
+
+  return (
+    <div className="container mx-auto py-10 px-4 max-w-6xl">
+      <div className="grid grid-cols-1 lg:grid-cols-4 gap-6">
+        {/* Sidebar Navigation */}
+        <aside className="lg:col-span-1">
+          <SettingsNav />
+        </aside>
+
+        {/* Main Content */}
+        <main className="lg:col-span-3 space-y-6">
+          <div>
+            <h1 className="text-3xl font-bold mb-2">{t('profile.title')}</h1>
+            <p className="text-gray-600 dark:text-gray-400">
+              {t('profile.description')}
+            </p>
+          </div>
+
+          {/* Profile Information */}
+          <SettingsSection
+            title={t('profile.accountSettings')}
+            icon={<span className="text-2xl">👤</span>}
+            description={t('profile.description')}
+          >
+            <SettingInput
+              label={t('profile.displayName')}
+              description={t('profile.displayName')}
+              value={user.name}
+              onChange={handleNameChange}
+              placeholder={t('auth.namePlaceholder')}
+            />
+
+            <SettingInput
+              label={t('profile.email')}
+              description={t('profile.email')}
+              value={user.email}
+              type="email"
+              onChange={handleEmailChange}
+              placeholder={t('auth.emailPlaceholder')}
+            />
+          </SettingsSection>
+
+          {/* Preferences */}
+          <SettingsSection
+            title={t('settings.language')}
+            icon={<span className="text-2xl">⚙️</span>}
+            description={t('profile.languagePreferencesDescription')}
+          >
+            <SettingSelect
+              label={t('profile.preferredLanguage')}
+              description={t('profile.languageDescription')}
+              value={language}
+              options={[
+                { value: 'auto', label: t('profile.autoDetect') },
+                { value: 'en', label: 'English' },
+                { value: 'fr', label: 'Français' },
+                { value: 'es', label: 'Español' },
+                { value: 'de', label: 'Deutsch' },
+                { value: 'fa', label: 'فارسی' },
+                { value: 'it', label: 'Italiano' },
+                { value: 'pt', label: 'Português' },
+                { value: 'ru', label: 'Русский' },
+                { value: 'zh', label: '中文' },
+                { value: 'ja', label: '日本語' },
+                { value: 'ko', label: '한국어' },
+                { value: 'ar', label: 'العربية' },
+                { value: 'hi', label: 'हिन्दी' },
+                { value: 'nl', label: 'Nederlands' },
+                { value: 'pl', label: 'Polski' },
+              ]}
+              onChange={handleLanguageChange}
+            />
+
+            <SettingToggle
+              label={t('profile.showRecentNotes')}
+              description={t('profile.showRecentNotesDescription')}
+              checked={showRecentNotes}
+              onChange={handleRecentNotesChange}
+            />
+          </SettingsSection>
+
+          {/* AI Settings Link */}
+          <div className="p-6 border rounded-lg bg-gradient-to-r from-purple-50 to-pink-50 dark:from-purple-950 dark:to-pink-950">
+            <div className="flex items-center gap-4">
+              <div className="text-4xl">✨</div>
+              <div className="flex-1">
+                <h3 className="font-semibold text-lg mb-1">{t('aiSettings.title')}</h3>
+                <p className="text-sm text-gray-600 dark:text-gray-400">
+                  {t('aiSettings.description')}
+                </p>
+              </div>
+              <button
+                onClick={() => window.location.href = '/settings/ai'}
+                className="px-4 py-2 bg-purple-600 text-white rounded-lg hover:bg-purple-700 transition-colors"
+              >
+                {t('nav.configureAI')}
+              </button>
+            </div>
+          </div>
+        </main>
+      </div>
+    </div>
+  )
+}

memento-note/app/(main)/settings/profile/page.tsx

@@ -0,0 +1,44 @@
+import { auth } from '@/auth'
+import { redirect } from 'next/navigation'
+import { ProfileForm } from './profile-form'
+import prisma from '@/lib/prisma'
+import { ProfilePageHeader } from '@/components/profile-page-header'
+import { AISettingsLinkCard } from './ai-settings-link-card'
+
+export default async function ProfilePage() {
+  const session = await auth()
+
+  if (!session?.user?.id) {
+    redirect('/login')
+  }
+
+  // Parallel queries
+  const [user, aiSettings] = await Promise.all([
+    prisma.user.findUnique({
+      where: { id: session.user.id },
+      select: { name: true, email: true, role: true }
+    }),
+    prisma.userAISettings.findUnique({
+      where: { userId: session.user.id }
+    })
+  ])
+
+  if (!user) {
+    redirect('/login')
+  }
+
+  const userAISettings = {
+    preferredLanguage: aiSettings?.preferredLanguage || 'auto',
+    showRecentNotes: aiSettings?.showRecentNotes ?? false
+  }
+
+  return (
+    <div className="max-w-2xl">
+      <ProfilePageHeader />
+      <ProfileForm user={user} userAISettings={userAISettings} />
+
+      {/* AI Settings Link */}
+      <AISettingsLinkCard />
+    </div>
+  )
+}

memento-note/app/(main)/settings/profile/profile-form.tsx

@@ -0,0 +1,179 @@
+'use client'
+
+import { useState, useEffect } from 'react'
+import { useRouter } from 'next/navigation'
+import { Button } from '@/components/ui/button'
+import { Input } from '@/components/ui/input'
+import { Card, CardContent, CardDescription, CardFooter, CardHeader, CardTitle } from '@/components/ui/card'
+import { Label } from '@/components/ui/label'
+import { Switch } from '@/components/ui/switch'
+
+import { updateProfile, changePassword, updateFontSize, updateShowRecentNotes } from '@/app/actions/profile'
+import { toast } from 'sonner'
+import { useLanguage } from '@/lib/i18n'
+
+
+
+export function ProfileForm({ user, userAISettings }: { user: any; userAISettings?: any }) {
+  const router = useRouter()
+
+  const [fontSize, setFontSize] = useState(userAISettings?.fontSize || 'medium')
+  const [isUpdatingFontSize, setIsUpdatingFontSize] = useState(false)
+  const [showRecentNotes, setShowRecentNotes] = useState(userAISettings?.showRecentNotes ?? false)
+  const [isUpdatingRecentNotes, setIsUpdatingRecentNotes] = useState(false)
+  const { t } = useLanguage()
+
+  const FONT_SIZES = [
+    { value: 'small', label: t('profile.fontSizeSmall'), size: '14px' },
+    { value: 'medium', label: t('profile.fontSizeMedium'), size: '16px' },
+    { value: 'large', label: t('profile.fontSizeLarge'), size: '18px' },
+    { value: 'extra-large', label: t('profile.fontSizeExtraLarge'), size: '20px' },
+  ]
+
+  const handleFontSizeChange = async (size: string) => {
+    setIsUpdatingFontSize(true)
+    try {
+      const result = await updateFontSize(size)
+      if (result?.error) {
+        toast.error(t('profile.fontSizeUpdateFailed'))
+      } else {
+        setFontSize(size)
+        // Apply font size immediately
+        applyFontSize(size)
+        toast.success(t('profile.fontSizeUpdateSuccess'))
+      }
+    } catch (error) {
+      toast.error(t('profile.fontSizeUpdateFailed'))
+    } finally {
+      setIsUpdatingFontSize(false)
+    }
+  }
+
+  const applyFontSize = (size: string) => {
+    // Base font size in pixels (16px is standard)
+    const fontSizeMap = {
+      'small': '14px',    // ~87% of 16px
+      'medium': '16px',   // 100% (standard)
+      'large': '18px',    // ~112% of 16px
+      'extra-large': '20px' // 125% of 16px
+    }
+    const fontSizeFactorMap = {
+      'small': 0.95,
+      'medium': 1.0,
+      'large': 1.1,
+      'extra-large': 1.25
+    }
+    const fontSizeValue = fontSizeMap[size as keyof typeof fontSizeMap] || '16px'
+    const fontSizeFactor = fontSizeFactorMap[size as keyof typeof fontSizeFactorMap] || 1.0
+
+    document.documentElement.style.setProperty('--user-font-size', fontSizeValue)
+    document.documentElement.style.setProperty('--user-font-size-factor', fontSizeFactor.toString())
+    localStorage.setItem('user-font-size', size)
+  }
+
+  // Apply saved font size on mount
+  useEffect(() => {
+    const savedFontSize = localStorage.getItem('user-font-size') || userAISettings?.fontSize || 'medium'
+    applyFontSize(savedFontSize as string)
+  }, [])
+
+
+
+  const handleShowRecentNotesChange = async (enabled: boolean) => {
+    setIsUpdatingRecentNotes(true)
+    const previousValue = showRecentNotes
+
+    try {
+      const result = await updateShowRecentNotes(enabled)
+      if (result?.error) {
+        toast.error(result.error)
+      } else {
+        setShowRecentNotes(enabled)
+        toast.success(t('profile.recentNotesUpdateSuccess') || 'Paramètre mis à jour')
+        // Force full page reload to ensure settings are reloaded
+        window.location.href = '/settings/profile'
+      }
+    } catch (error: any) {
+      setShowRecentNotes(previousValue)
+      toast.error(error?.message || 'Erreur')
+    } finally {
+      setIsUpdatingRecentNotes(false)
+    }
+  }
+
+  return (
+    <div className="space-y-6">
+      <Card>
+        <CardHeader>
+          <CardTitle>{t('profile.title')}</CardTitle>
+          <CardDescription>{t('profile.description')}</CardDescription>
+        </CardHeader>
+        <form action={async (formData) => {
+          const result = await updateProfile({ name: formData.get('name') as string })
+          if (result?.error) {
+            toast.error(t('profile.updateFailed'))
+          } else {
+            toast.success(t('profile.updateSuccess'))
+          }
+        }}>
+          <CardContent className="space-y-4">
+            <div className="space-y-2">
+              <label htmlFor="name" className="text-sm font-medium leading-none peer-disabled:cursor-not-allowed peer-disabled:opacity-70">{t('profile.displayName')}</label>
+              <Input id="name" name="name" defaultValue={user.name} />
+            </div>
+            <div className="space-y-2">
+              <label htmlFor="email" className="text-sm font-medium leading-none peer-disabled:cursor-not-allowed peer-disabled:opacity-70">{t('profile.email')}</label>
+              <Input id="email" value={user.email} disabled className="bg-muted" />
+            </div>
+          </CardContent>
+          <CardFooter>
+            <Button type="submit">{t('general.save')}</Button>
+          </CardFooter>
+        </form>
+      </Card>
+
+
+
+
+
+      <Card>
+        <CardHeader>
+          <CardTitle>{t('profile.changePassword')}</CardTitle>
+          <CardDescription>{t('profile.changePasswordDescription')}</CardDescription>
+        </CardHeader>
+        <form action={async (formData) => {
+          const result = await changePassword(formData)
+          if (result?.error) {
+            const msg = '_form' in result.error
+              ? result.error._form[0]
+              : result.error.currentPassword?.[0] || result.error.newPassword?.[0] || result.error.confirmPassword?.[0] || t('profile.passwordChangeFailed')
+            toast.error(msg)
+          } else {
+            toast.success(t('profile.passwordChangeSuccess'))
+            // Reset form manually or redirect
+            const form = document.querySelector('form#password-form') as HTMLFormElement
+            form?.reset()
+          }
+        }} id="password-form">
+          <CardContent className="space-y-4">
+            <div className="space-y-2">
+              <label htmlFor="currentPassword" className="text-sm font-medium leading-none peer-disabled:cursor-not-allowed peer-disabled:opacity-70">{t('profile.currentPassword')}</label>
+              <Input id="currentPassword" name="currentPassword" type="password" required />
+            </div>
+            <div className="space-y-2">
+              <label htmlFor="newPassword" className="text-sm font-medium leading-none peer-disabled:cursor-not-allowed peer-disabled:opacity-70">{t('profile.newPassword')}</label>
+              <Input id="newPassword" name="newPassword" type="password" required minLength={6} />
+            </div>
+            <div className="space-y-2">
+              <label htmlFor="confirmPassword" className="text-sm font-medium leading-none peer-disabled:cursor-not-allowed peer-disabled:opacity-70">{t('profile.confirmPassword')}</label>
+              <Input id="confirmPassword" name="confirmPassword" type="password" required minLength={6} />
+            </div>
+          </CardContent>
+          <CardFooter>
+            <Button type="submit">{t('profile.updatePassword')}</Button>
+          </CardFooter>
+        </form>
+      </Card>
+    </div>
+  )
+}

memento-note/app/(main)/support/page.tsx

@@ -0,0 +1,156 @@
+'use client'
+
+import { Card, CardContent, CardHeader, CardTitle } from '@/components/ui/card';
+import { Button } from '@/components/ui/button';
+import { useLanguage } from '@/lib/i18n';
+
+export default function SupportPage() {
+  const { t } = useLanguage();
+
+  return (
+    <div className="container mx-auto py-10 max-w-4xl">
+      <div className="text-center mb-10">
+        <h1 className="text-4xl font-bold mb-4">
+          {t('support.title')}
+        </h1>
+        <p className="text-muted-foreground text-lg">
+          {t('support.description')}
+        </p>
+      </div>
+
+      <div className="grid gap-6 md:grid-cols-2 mb-10">
+        <Card className="border-2 border-primary">
+          <CardHeader>
+            <CardTitle className="flex items-center gap-2">
+              <span className="text-2xl">☕</span>
+              {t('support.buyMeACoffee')}
+            </CardTitle>
+          </CardHeader>
+          <CardContent>
+            <p className="mb-4">
+              {t('support.donationDescription')}
+            </p>
+            <Button asChild className="w-full">
+              <a href="https://ko-fi.com/yourusername" target="_blank" rel="noopener noreferrer">
+                {t('support.donateOnKofi')}
+              </a>
+            </Button>
+            <p className="text-xs text-muted-foreground mt-2">
+              {t('support.kofiDescription')}
+            </p>
+          </CardContent>
+        </Card>
+
+        <Card className="border-2 border-primary">
+          <CardHeader>
+            <CardTitle className="flex items-center gap-2">
+              <span className="text-2xl">💚</span>
+              {t('support.sponsorOnGithub')}
+            </CardTitle>
+          </CardHeader>
+          <CardContent>
+            <p className="mb-4">
+              {t('support.sponsorDescription')}
+            </p>
+            <Button asChild variant="outline" className="w-full">
+              <a href="https://github.com/sponsors/yourusername" target="_blank" rel="noopener noreferrer">
+                {t('support.sponsorOnGithub')}
+              </a>
+            </Button>
+            <p className="text-xs text-muted-foreground mt-2">
+              {t('support.githubDescription')}
+            </p>
+          </CardContent>
+        </Card>
+      </div>
+
+      <Card className="mb-10">
+        <CardHeader>
+          <CardTitle>{t('support.howSupportHelps')}</CardTitle>
+        </CardHeader>
+        <CardContent>
+          <div className="grid md:grid-cols-2 gap-4">
+            <div>
+              <h3 className="font-semibold mb-2">💰 {t('support.directImpact')}</h3>
+              <ul className="space-y-2 text-sm">
+                <li>☕ Keeps me fueled with coffee</li>
+                <li>🐛 Covers hosting and server costs</li>
+                <li>✨ Funds development of new features</li>
+                <li>📚 Improves documentation</li>
+                <li>🌍 Keeps Memento 100% open-source</li>
+              </ul>
+            </div>
+            <div>
+              <h3 className="font-semibold mb-2">🎁 {t('support.sponsorPerks')}</h3>
+              <ul className="space-y-2 text-sm">
+                <li>🥉 $5/month - Bronze: Name in supporters list</li>
+                <li>🥈 $15/month - Silver: Priority feature requests</li>
+                <li>🥇 $50/month - Gold: Logo in footer, priority support</li>
+                <li>💎 $100/month - Platinum: Custom features, consulting</li>
+              </ul>
+            </div>
+          </div>
+        </CardContent>
+      </Card>
+
+      <Card>
+        <CardHeader>
+          <CardTitle>💡 {t('support.transparency')}</CardTitle>
+        </CardHeader>
+        <CardContent>
+          <p className="text-sm mb-4">
+            {t('support.transparencyDescription')}
+          </p>
+          <div className="space-y-2 text-sm">
+            <div className="flex justify-between">
+              <span>{t('support.hostingServers')}</span>
+              <span className="font-mono">~$20/month</span>
+            </div>
+            <div className="flex justify-between">
+              <span>{t('support.domainSSL')}</span>
+              <span className="font-mono">~$15/year</span>
+            </div>
+            <div className="flex justify-between">
+              <span>{t('support.aiApiCosts')}</span>
+              <span className="font-mono">~$30/month</span>
+            </div>
+            <div className="flex justify-between border-t pt-2">
+              <span className="font-semibold">{t('support.totalExpenses')}</span>
+              <span className="font-mono font-semibold">~$50/month</span>
+            </div>
+          </div>
+          <p className="text-xs text-muted-foreground mt-4">
+            Any amount beyond these costs goes directly into improving Memento
+            and funding new features. Thank you for your support! 💚
+          </p>
+        </CardContent>
+      </Card>
+
+      <div className="mt-10 text-center">
+        <h2 className="text-2xl font-bold mb-4">{t('support.otherWaysTitle')}</h2>
+        <div className="flex flex-wrap justify-center gap-4">
+          <Button variant="outline" asChild>
+            <a href="https://github.com/yourusername/memento" target="_blank" rel="noopener noreferrer">
+              ⭐ {t('support.starGithub')}
+            </a>
+          </Button>
+          <Button variant="outline" asChild>
+            <a href="https://github.com/yourusername/memento/issues" target="_blank" rel="noopener noreferrer">
+              🐛 {t('support.reportBug')}
+            </a>
+          </Button>
+          <Button variant="outline" asChild>
+            <a href="https://github.com/yourusername/memento" target="_blank" rel="noopener noreferrer">
+              📝 {t('support.contributeCode')}
+            </a>
+          </Button>
+          <Button variant="outline" asChild>
+            <a href="https://twitter.com/intent/tweet?text=Check%20out%20Memento%20-%20a%20great%20open-source%20note-taking%20app!%20https://github.com/yourusername/memento" target="_blank" rel="noopener noreferrer">
+              🐦 {t('support.shareTwitter')}
+            </a>
+          </Button>
+        </div>
+      </div>
+    </div>
+  );
+}

memento-note/app/(main)/trash/page.tsx

@@ -0,0 +1,21 @@
+import { getTrashedNotes } from '@/app/actions/notes'
+import { MasonryGrid } from '@/components/masonry-grid'
+import { TrashHeader } from '@/components/trash-header'
+import { TrashEmptyState } from './trash-empty-state'
+
+export const dynamic = 'force-dynamic'
+
+export default async function TrashPage() {
+  const notes = await getTrashedNotes()
+
+  return (
+    <main className="container mx-auto px-4 py-8 max-w-7xl">
+      <TrashHeader noteCount={notes.length} />
+      {notes.length > 0 ? (
+        <MasonryGrid notes={notes} isTrashView />
+      ) : (
+        <TrashEmptyState />
+      )}
+    </main>
+  )
+}

memento-note/app/(main)/trash/trash-empty-state.tsx

@@ -0,0 +1,20 @@
+'use client'
+
+import { Trash2 } from 'lucide-react'
+import { useLanguage } from '@/lib/i18n'
+
+export function TrashEmptyState() {
+  const { t } = useLanguage()
+
+  return (
+    <div className="flex flex-col items-center justify-center min-h-[60vh] text-center text-gray-500">
+      <div className="bg-gray-100 dark:bg-gray-800 p-6 rounded-full mb-4">
+        <Trash2 className="w-12 h-12 text-gray-400" />
+      </div>
+      <h2 className="text-xl font-medium mb-2">{t('trash.empty')}</h2>
+      <p className="max-w-md text-sm opacity-80">
+        {t('trash.emptyDescription')}
+      </p>
+    </div>
+  )
+}

memento-note/app/actions/admin-settings.ts

@@ -0,0 +1,73 @@
+'use server'
+
+import prisma from '@/lib/prisma'
+import { auth } from '@/auth'
+import { sendEmail } from '@/lib/mail'
+import { revalidateTag } from 'next/cache'
+
+async function checkAdmin() {
+  const session = await auth()
+  if (!session?.user?.id || (session.user as any).role !== 'ADMIN') {
+    throw new Error('Unauthorized: Admin access required')
+  }
+  return session
+}
+
+export async function testEmail(provider: 'resend' | 'smtp' = 'smtp') {
+  const session = await checkAdmin()
+  const email = session.user?.email
+
+  if (!email) throw new Error("No admin email found")
+
+  const subject = provider === 'resend'
+    ? "Memento Resend Test"
+    : "Memento SMTP Test"
+
+  const html = provider === 'resend'
+    ? "<p>This is a test email from your Memento instance. <strong>Resend is working!</strong></p>"
+    : "<p>This is a test email from your Memento instance. <strong>SMTP is working!</strong></p>"
+
+  const result = await sendEmail({
+    to: email,
+    subject,
+    html,
+  }, provider)
+
+  return result
+}
+
+export async function getSystemConfig() {
+  await checkAdmin()
+  // Reuse the cached version from lib/config
+  const { getSystemConfig: getCachedConfig } = await import('@/lib/config')
+  return getCachedConfig()
+}
+
+export async function updateSystemConfig(data: Record<string, string>) {
+  await checkAdmin()
+
+  try {
+    // Filter out empty values but keep 'false' as valid
+    const filteredData = Object.fromEntries(
+      Object.entries(data).filter(([key, value]) => value !== '' && value !== null && value !== undefined)
+    )
+
+    const operations = Object.entries(filteredData).map(([key, value]) =>
+      prisma.systemConfig.upsert({
+        where: { key },
+        update: { value },
+        create: { key, value }
+      })
+    )
+
+    await prisma.$transaction(operations)
+
+    // Invalidate cache after update
+    revalidateTag('system-config', '/settings')
+
+    return { success: true }
+  } catch (error) {
+    console.error('Failed to update settings:', error)
+    return { error: 'Failed to update settings' }
+  }
+}

memento-note/app/actions/admin.ts

@@ -0,0 +1,120 @@
+'use server'
+
+import { revalidatePath } from 'next/cache'
+import prisma from '@/lib/prisma'
+import { auth } from '@/auth'
+import bcrypt from 'bcryptjs'
+import { z } from 'zod'
+
+// Schema pour la création d'utilisateur
+const CreateUserSchema = z.object({
+  name: z.string().min(2, "Name must be at least 2 characters"),
+  email: z.string().email("Invalid email address"),
+  password: z.string().min(6, "Password must be at least 6 characters"),
+  role: z.enum(["USER", "ADMIN"]).default("USER"),
+})
+
+async function checkAdmin() {
+  const session = await auth()
+  if (!session?.user?.id || (session.user as any).role !== 'ADMIN') {
+    throw new Error('Unauthorized: Admin access required')
+  }
+  return session
+}
+
+export async function getUsers() {
+  await checkAdmin()
+  try {
+    const users = await prisma.user.findMany({
+      orderBy: { createdAt: 'desc' },
+      select: {
+        id: true,
+        name: true,
+        email: true,
+        role: true,
+        createdAt: true,
+      }
+    })
+    return users
+  } catch (error) {
+    console.error('Failed to fetch users:', error)
+    throw new Error('Failed to fetch users')
+  }
+}
+
+export async function createUser(formData: FormData) {
+  await checkAdmin()
+
+  const rawData = {
+    name: formData.get('name'),
+    email: formData.get('email'),
+    password: formData.get('password'),
+    role: formData.get('role'),
+  }
+
+  const validatedFields = CreateUserSchema.safeParse(rawData)
+
+  if (!validatedFields.success) {
+    return {
+      error: validatedFields.error.flatten().fieldErrors,
+    }
+  }
+
+  const { name, email, password, role } = validatedFields.data
+  const hashedPassword = await bcrypt.hash(password, 10)
+
+  try {
+    await prisma.user.create({
+      data: {
+        name,
+        email: email.toLowerCase(),
+        password: hashedPassword,
+        role,
+      },
+    })
+    revalidatePath('/admin')
+    return { success: true }
+  } catch (error: any) {
+    if (error.code === 'P2002') {
+      return { error: { email: ['Email already exists'] } }
+    }
+    return { error: { _form: ['Failed to create user'] } }
+  }
+}
+
+export async function deleteUser(userId: string) {
+  const session = await checkAdmin()
+  
+  if (session.user?.id === userId) {
+    throw new Error("You cannot delete your own account")
+  }
+
+  try {
+    await prisma.user.delete({
+      where: { id: userId },
+    })
+    revalidatePath('/admin')
+    return { success: true }
+  } catch (error) {
+    throw new Error('Failed to delete user')
+  }
+}
+
+export async function updateUserRole(userId: string, newRole: string) {
+  const session = await checkAdmin()
+
+  if (session.user?.id === userId) {
+    throw new Error("You cannot change your own role")
+  }
+
+  try {
+    await prisma.user.update({
+      where: { id: userId },
+      data: { role: newRole },
+    })
+    revalidatePath('/admin')
+    return { success: true }
+  } catch (error) {
+    throw new Error('Failed to update role')
+  }
+}

memento-note/app/actions/agent-actions.ts

@@ -0,0 +1,235 @@
+'use server'
+
+/**
+ * Agent Server Actions
+ * CRUD operations for agents and execution triggers.
+ */
+
+import { auth } from '@/auth'
+import { prisma } from '@/lib/prisma'
+import { revalidatePath } from 'next/cache'
+
+// --- CRUD ---
+
+export async function createAgent(data: {
+  name: string
+  description?: string
+  type: string
+  role: string
+  sourceUrls?: string[]
+  sourceNotebookId?: string
+  targetNotebookId?: string
+  frequency?: string
+  tools?: string[]
+  maxSteps?: number
+  notifyEmail?: boolean
+  includeImages?: boolean
+}) {
+  const session = await auth()
+  if (!session?.user?.id) {
+    throw new Error('Non autorise')
+  }
+
+  try {
+    const agent = await prisma.agent.create({
+      data: {
+        name: data.name,
+        description: data.description,
+        type: data.type,
+        role: data.role,
+        sourceUrls: data.sourceUrls ? JSON.stringify(data.sourceUrls) : null,
+        sourceNotebookId: data.sourceNotebookId || null,
+        targetNotebookId: data.targetNotebookId || null,
+        frequency: data.frequency || 'manual',
+        tools: data.tools ? JSON.stringify(data.tools) : '[]',
+        maxSteps: data.maxSteps || 10,
+        notifyEmail: data.notifyEmail || false,
+        includeImages: data.includeImages || false,
+        userId: session.user.id,
+      }
+    })
+
+    revalidatePath('/agents')
+    return { success: true, agent }
+  } catch (error) {
+    console.error('Error creating agent:', error)
+    throw new Error('Impossible de creer l\'agent')
+  }
+}
+
+export async function updateAgent(id: string, data: {
+  name?: string
+  description?: string
+  type?: string
+  role?: string
+  sourceUrls?: string[]
+  sourceNotebookId?: string | null
+  targetNotebookId?: string | null
+  frequency?: string
+  isEnabled?: boolean
+  tools?: string[]
+  maxSteps?: number
+  notifyEmail?: boolean
+  includeImages?: boolean
+}) {
+  const session = await auth()
+  if (!session?.user?.id) {
+    throw new Error('Non autorise')
+  }
+
+  try {
+    const existing = await prisma.agent.findUnique({ where: { id } })
+    if (!existing || existing.userId !== session.user.id) {
+      throw new Error('Agent non trouve')
+    }
+
+    const updateData: Record<string, unknown> = {}
+    if (data.name !== undefined) updateData.name = data.name
+    if (data.description !== undefined) updateData.description = data.description
+    if (data.type !== undefined) updateData.type = data.type
+    if (data.role !== undefined) updateData.role = data.role
+    if (data.sourceUrls !== undefined) updateData.sourceUrls = JSON.stringify(data.sourceUrls)
+    if (data.sourceNotebookId !== undefined) updateData.sourceNotebookId = data.sourceNotebookId
+    if (data.targetNotebookId !== undefined) updateData.targetNotebookId = data.targetNotebookId
+    if (data.frequency !== undefined) updateData.frequency = data.frequency
+    if (data.isEnabled !== undefined) updateData.isEnabled = data.isEnabled
+    if (data.tools !== undefined) updateData.tools = JSON.stringify(data.tools)
+    if (data.maxSteps !== undefined) updateData.maxSteps = data.maxSteps
+    if (data.notifyEmail !== undefined) updateData.notifyEmail = data.notifyEmail
+    if (data.includeImages !== undefined) updateData.includeImages = data.includeImages
+
+    const agent = await prisma.agent.update({
+      where: { id },
+      data: updateData
+    })
+
+    revalidatePath('/agents')
+    return { success: true, agent }
+  } catch (error) {
+    console.error('Error updating agent:', error)
+    throw new Error('Impossible de mettre a jour l\'agent')
+  }
+}
+
+export async function deleteAgent(id: string) {
+  const session = await auth()
+  if (!session?.user?.id) {
+    throw new Error('Non autorise')
+  }
+
+  try {
+    const existing = await prisma.agent.findUnique({ where: { id } })
+    if (!existing || existing.userId !== session.user.id) {
+      throw new Error('Agent non trouve')
+    }
+
+    await prisma.agent.delete({ where: { id } })
+    revalidatePath('/agents')
+    return { success: true }
+  } catch (error) {
+    console.error('Error deleting agent:', error)
+    throw new Error('Impossible de supprimer l\'agent')
+  }
+}
+
+export async function getAgents() {
+  const session = await auth()
+  if (!session?.user?.id) {
+    throw new Error('Non autorise')
+  }
+
+  try {
+    const agents = await prisma.agent.findMany({
+      where: { userId: session.user.id },
+      include: {
+        _count: { select: { actions: true } },
+        actions: {
+          orderBy: { createdAt: 'desc' },
+          take: 1,
+        },
+        notebook: {
+          select: { id: true, name: true, icon: true }
+        }
+      },
+      orderBy: { createdAt: 'desc' }
+    })
+
+    return agents
+  } catch (error) {
+    console.error('Error fetching agents:', error)
+    throw new Error('Impossible de charger les agents')
+  }
+}
+
+// --- Execution ---
+
+export async function runAgent(id: string) {
+  const session = await auth()
+  if (!session?.user?.id) {
+    throw new Error('Non autorise')
+  }
+
+  try {
+    const { executeAgent } = await import('@/lib/ai/services/agent-executor.service')
+    const result = await executeAgent(id, session.user.id)
+    revalidatePath('/agents')
+    revalidatePath('/')
+    return result
+  } catch (error) {
+    console.error('Error running agent:', error)
+    return {
+      success: false,
+      actionId: '',
+      error: error instanceof Error ? error.message : 'Erreur inconnue'
+    }
+  }
+}
+
+// --- History ---
+
+export async function getAgentActions(agentId: string) {
+  const session = await auth()
+  if (!session?.user?.id) {
+    throw new Error('Non autorise')
+  }
+
+  try {
+    const actions = await prisma.agentAction.findMany({
+      where: { agentId },
+      orderBy: { createdAt: 'desc' },
+      take: 20,
+      select: {
+        id: true,
+        status: true,
+        result: true,
+        log: true,
+        input: true,
+        toolLog: true,
+        tokensUsed: true,
+        createdAt: true,
+      }
+    })
+    return actions
+  } catch (error) {
+    console.error('Error fetching agent actions:', error)
+    throw new Error('Impossible de charger l\'historique')
+  }
+}
+
+export async function toggleAgent(id: string, isEnabled: boolean) {
+  const session = await auth()
+  if (!session?.user?.id) {
+    throw new Error('Non autorise')
+  }
+
+  try {
+    const agent = await prisma.agent.update({
+      where: { id },
+      data: { isEnabled }
+    })
+    return { success: true, agent }
+  } catch (error) {
+    console.error('Error toggling agent:', error)
+    throw new Error('Impossible de modifier l\'agent')
+  }
+}

memento-note/app/actions/ai-actions.ts

@@ -0,0 +1,382 @@
+'use server'
+
+/**
+ * AI Server Actions Stub File
+ *
+ * This file provides a centralized location for all AI-related server action interfaces
+ * and serves as documentation for the AI server action architecture.
+ *
+ * IMPLEMENTATION STATUS:
+ * - Title Suggestions: ✅ Implemented (see app/actions/title-suggestions.ts)
+ * - Semantic Search: ✅ Implemented (see app/actions/semantic-search.ts)
+ * - Paragraph Reformulation: ✅ Implemented (see app/actions/paragraph-refactor.ts)
+ * - Memory Echo: ⏳ STUB - To be implemented in Epic 5 (Story 5-1)
+ * - Language Detection: ✅ Implemented (see app/actions/detect-language.ts)
+ * - AI Settings: ✅ Implemented (see app/actions/ai-settings.ts)
+ *
+ * NOTE: This file defines TypeScript interfaces and placeholder functions.
+ * Actual implementations are in separate action files (see references above).
+ */
+
+import { auth } from '@/auth'
+import { prisma } from '@/lib/prisma'
+import { revalidatePath } from 'next/cache'
+
+// ============================================================================
+// TYPESCRIPT INTERFACES
+// ============================================================================
+
+/**
+ * Title Suggestions Interfaces
+ * @see app/actions/title-suggestions.ts for implementation
+ */
+export interface GenerateTitlesRequest {
+  noteId: string
+}
+
+export interface GenerateTitlesResponse {
+  suggestions: Array<{
+    title: string
+    confidence: number
+    reasoning?: string
+  }>
+  noteId: string
+}
+
+/**
+ * Semantic Search Interfaces
+ * @see app/actions/semantic-search.ts for implementation
+ */
+export interface SearchResult {
+  noteId: string
+  title: string | null
+  content: string
+  similarity: number
+  matchType: 'exact' | 'related'
+}
+
+export interface SemanticSearchRequest {
+  query: string
+  options?: {
+    limit?: number
+    threshold?: number
+    notebookId?: string
+  }
+}
+
+export interface SemanticSearchResponse {
+  results: SearchResult[]
+  query: string
+  totalResults: number
+}
+
+/**
+ * Paragraph Reformulation Interfaces
+ * @see app/actions/paragraph-refactor.ts for implementation
+ */
+export type RefactorMode = 'clarify' | 'shorten' | 'improve'
+
+export interface RefactorParagraphRequest {
+  noteId: string
+  selectedText: string
+  option: RefactorMode
+}
+
+export interface RefactorParagraphResponse {
+  originalText: string
+  refactoredText: string
+}
+
+/**
+ * Memory Echo Interfaces
+ * STUB - To be implemented in Epic 5 (Story 5-1)
+ *
+ * This feature will analyze all user notes with embeddings to find
+ * connections with cosine similarity > 0.75 and provide proactive insights.
+ */
+export interface GenerateMemoryEchoRequest {
+  // No params - uses current user session
+}
+
+export interface MemoryEchoInsight {
+  note1Id: string
+  note2Id: string
+  similarityScore: number
+}
+
+export interface GenerateMemoryEchoResponse {
+  success: boolean
+  insight: MemoryEchoInsight | null
+}
+
+/**
+ * Language Detection Interfaces
+ * @see app/actions/detect-language.ts for implementation
+ */
+export interface DetectLanguageRequest {
+  content: string
+}
+
+export interface DetectLanguageResponse {
+  language: string
+  confidence: number
+  method: 'tinyld' | 'ai'
+}
+
+/**
+ * AI Settings Interfaces
+ * @see app/actions/ai-settings.ts for implementation
+ */
+export interface AISettingsConfig {
+  titleSuggestions?: boolean
+  semanticSearch?: boolean
+  paragraphRefactor?: boolean
+  memoryEcho?: boolean
+  memoryEchoFrequency?: 'daily' | 'weekly' | 'custom'
+  aiProvider?: 'auto' | 'openai' | 'ollama'
+  preferredLanguage?: 'auto' | 'en' | 'fr' | 'es' | 'de' | 'fa' | 'it' | 'pt' | 'ru' | 'zh' | 'ja' | 'ko' | 'ar' | 'hi' | 'nl' | 'pl'
+  demoMode?: boolean
+}
+
+export interface UpdateAISettingsRequest {
+  settings: Partial<AISettingsConfig>
+}
+
+export interface UpdateAISettingsResponse {
+  success: boolean
+}
+
+// ============================================================================
+// PLACEHOLDER FUNCTIONS
+// ============================================================================
+
+/**
+ * Generate Title Suggestions
+ *
+ * ALREADY IMPLEMENTED: See app/actions/title-suggestions.ts
+ *
+ * This function generates 3 AI-powered title suggestions for a note when it
+ * reaches 50+ words without a title.
+ *
+ * @see generateTitleSuggestions in app/actions/title-suggestions.ts
+ */
+export async function generateTitles(
+  request: GenerateTitlesRequest
+): Promise<GenerateTitlesResponse> {
+  // TODO: Import and use implementation from title-suggestions.ts
+  // import { generateTitleSuggestions } from './title-suggestions'
+  // return generateTitleSuggestions(request.noteId)
+
+  throw new Error('Not implemented in stub: Use app/actions/title-suggestions.ts')
+}
+
+/**
+ * Semantic Search
+ *
+ * ALREADY IMPLEMENTED: See app/actions/semantic-search.ts
+ *
+ * This function performs hybrid semantic + keyword search across user notes.
+ *
+ * @see semanticSearch in app/actions/semantic-search.ts
+ */
+export async function semanticSearch(
+  request: SemanticSearchRequest
+): Promise<SemanticSearchResponse> {
+  // TODO: Import and use implementation from semantic-search.ts
+  // import { semanticSearch } from './semantic-search'
+  // return semanticSearch(request.query, request.options)
+
+  throw new Error('Not implemented in stub: Use app/actions/semantic-search.ts')
+}
+
+/**
+ * Refactor Paragraph
+ *
+ * ALREADY IMPLEMENTED: See app/actions/paragraph-refactor.ts
+ *
+ * This function refactors a paragraph using AI with specific mode (clarify/shorten/improve).
+ *
+ * @see refactorParagraph in app/actions/paragraph-refactor.ts
+ */
+export async function refactorParagraph(
+  request: RefactorParagraphRequest
+): Promise<RefactorParagraphResponse> {
+  // TODO: Import and use implementation from paragraph-refactor.ts
+  // import { refactorParagraph } from './paragraph-refactor'
+  // return refactorParagraph(request.selectedText, request.option)
+
+  throw new Error('Not implemented in stub: Use app/actions/paragraph-refactor.ts')
+}
+
+/**
+ * Generate Memory Echo Insights
+ *
+ * STUB: To be implemented in Epic 5 (Story 5-1)
+ *
+ * This will analyze all user notes with embeddings to find
+ * connections with cosine similarity > 0.75.
+ *
+ * Implementation Plan:
+ * - Fetch all user notes with embeddings
+ * - Calculate pairwise cosine similarities
+ * - Find top connection with similarity > 0.75
+ * - Store in MemoryEchoInsight table
+ * - Return insight or null if none found
+ *
+ * @see Epic 5 Story 5-1 in planning/epics.md
+ */
+export async function generateMemoryEcho(): Promise<GenerateMemoryEchoResponse> {
+  const session = await auth()
+  if (!session?.user?.id) {
+    throw new Error('Unauthorized')
+  }
+
+  // TODO: Implement Memory Echo background processing
+  // - Fetch all user notes with embeddings from prisma.note
+  // - Calculate pairwise cosine similarities using embedding vectors
+  // - Filter for similarity > 0.75
+  // - Select top insight
+  // - Store in prisma.memoryEchoInsight table (if it exists)
+  // - Return { success: true, insight: {...} }
+
+  throw new Error('Not implemented: See Epic 5 Story 5-1')
+}
+
+/**
+ * Detect Language
+ *
+ * ALREADY IMPLEMENTED: See app/actions/detect-language.ts
+ *
+ * This function detects the language of user content.
+ *
+ * @see getInitialLanguage in app/actions/detect-language.ts
+ */
+export async function detectLanguage(
+  request: DetectLanguageRequest
+): Promise<DetectLanguageResponse> {
+  // TODO: Import and use implementation from detect-language.ts
+  // import { detectUserLanguage } from '@/lib/i18n/detect-user-language'
+  // const language = await detectUserLanguage()
+  // return { language, confidence: 0.95, method: 'tinyld' }
+
+  throw new Error('Not implemented in stub: Use app/actions/detect-language.ts')
+}
+
+/**
+ * Update AI Settings
+ *
+ * ALREADY IMPLEMENTED: See app/actions/ai-settings.ts
+ *
+ * This function updates user AI preferences.
+ *
+ * @see updateAISettings in app/actions/ai-settings.ts
+ */
+export async function updateAISettings(
+  request: UpdateAISettingsRequest
+): Promise<UpdateAISettingsResponse> {
+  const session = await auth()
+  if (!session?.user?.id) {
+    throw new Error('Unauthorized')
+  }
+
+  // TODO: Import and use implementation from ai-settings.ts
+  // import { updateAISettings } from './ai-settings'
+  // return updateAISettings(request.settings)
+
+  throw new Error('Not implemented in stub: Use app/actions/ai-settings.ts')
+}
+
+/**
+ * Get AI Settings
+ *
+ * ALREADY IMPLEMENTED: See app/actions/ai-settings.ts
+ *
+ * This function retrieves user AI preferences.
+ *
+ * @see getAISettings in app/actions/ai-settings.ts
+ */
+export async function getAISettings(): Promise<AISettingsConfig> {
+  const session = await auth()
+  if (!session?.user?.id) {
+    throw new Error('Unauthorized')
+  }
+
+  // TODO: Import and use implementation from ai-settings.ts
+  // import { getAISettings } from './ai-settings'
+  // return getAISettings()
+
+  throw new Error('Not implemented in stub: Use app/actions/ai-settings.ts')
+}
+
+// ============================================================================
+// UTILITY FUNCTIONS
+// ============================================================================
+
+/**
+ * Check if a specific AI feature is enabled for the user
+ *
+ * UTILITY: Helper function to check feature flags
+ *
+ * @param feature - The AI feature to check
+ * @returns Promise<boolean> - Whether the feature is enabled
+ */
+export async function isAIFeatureEnabled(
+  feature: keyof AISettingsConfig
+): Promise<boolean> {
+  const session = await auth()
+  if (!session?.user?.id) {
+    return false
+  }
+
+  try {
+    const settings = await prisma.userAISettings.findUnique({
+      where: { userId: session.user.id }
+    })
+
+    if (!settings) {
+      // Default to enabled for new users
+      return true
+    }
+
+    switch (feature) {
+      case 'titleSuggestions':
+        return settings.titleSuggestions ?? true
+      case 'semanticSearch':
+        return settings.semanticSearch ?? true
+      case 'paragraphRefactor':
+        return settings.paragraphRefactor ?? true
+      case 'memoryEcho':
+        return settings.memoryEcho ?? true
+      default:
+        return true
+    }
+  } catch (error) {
+    console.error('Error checking AI feature enabled:', error)
+    return true
+  }
+}
+
+/**
+ * Get user's preferred AI provider
+ *
+ * UTILITY: Helper function to get provider preference
+ *
+ * @returns Promise<'auto' | 'openai' | 'ollama'> - The AI provider
+ */
+export async function getUserAIPreference(): Promise<'auto' | 'openai' | 'ollama'> {
+  const session = await auth()
+  if (!session?.user?.id) {
+    return 'auto'
+  }
+
+  try {
+    const settings = await prisma.userAISettings.findUnique({
+      where: { userId: session.user.id }
+    })
+
+    return (settings?.aiProvider || 'auto') as 'auto' | 'openai' | 'ollama'
+  } catch (error) {
+    console.error('Error getting user AI preference:', error)
+    return 'auto'
+  }
+}

memento-note/app/actions/ai-settings.ts

@@ -0,0 +1,260 @@
+'use server'
+
+import { auth } from '@/auth'
+import { prisma } from '@/lib/prisma'
+import { revalidatePath, updateTag } from 'next/cache'
+
+export type UserAISettingsData = {
+  titleSuggestions?: boolean
+  semanticSearch?: boolean
+  paragraphRefactor?: boolean
+  memoryEcho?: boolean
+  memoryEchoFrequency?: 'daily' | 'weekly' | 'custom'
+  aiProvider?: 'auto' | 'openai' | 'ollama'
+  preferredLanguage?: 'auto' | 'en' | 'fr' | 'es' | 'de' | 'fa' | 'it' | 'pt' | 'ru' | 'zh' | 'ja' | 'ko' | 'ar' | 'hi' | 'nl' | 'pl'
+  demoMode?: boolean
+  showRecentNotes?: boolean
+  notesViewMode?: 'masonry' | 'tabs' | 'list'
+  emailNotifications?: boolean
+  desktopNotifications?: boolean
+  anonymousAnalytics?: boolean
+  fontSize?: 'small' | 'medium' | 'large'
+}
+
+/** Only fields that exist on `UserAISettings` in Prisma (excludes e.g. `theme`, which lives on `User`). */
+const USER_AI_SETTINGS_PRISMA_KEYS = [
+  'titleSuggestions',
+  'semanticSearch',
+  'paragraphRefactor',
+  'memoryEcho',
+  'memoryEchoFrequency',
+  'aiProvider',
+  'preferredLanguage',
+  'fontSize',
+  'demoMode',
+  'showRecentNotes',
+  'notesViewMode',
+  'emailNotifications',
+  'desktopNotifications',
+  'anonymousAnalytics',
+] as const
+
+type UserAISettingsPrismaKey = (typeof USER_AI_SETTINGS_PRISMA_KEYS)[number]
+
+function pickUserAISettingsForDb(input: UserAISettingsData): Partial<Record<UserAISettingsPrismaKey, unknown>> {
+  const out: Partial<Record<UserAISettingsPrismaKey, unknown>> = {}
+  for (const key of USER_AI_SETTINGS_PRISMA_KEYS) {
+    const v = input[key]
+    if (v !== undefined) {
+      out[key] = v
+    }
+  }
+  if (out.notesViewMode === 'list') {
+    out.notesViewMode = 'tabs'
+  }
+  if (
+    out.notesViewMode != null &&
+    out.notesViewMode !== 'masonry' &&
+    out.notesViewMode !== 'tabs'
+  ) {
+    delete out.notesViewMode
+  }
+  return out
+}
+
+/**
+ * Update AI settings for the current user
+ */
+export async function updateAISettings(settings: UserAISettingsData) {
+
+  const session = await auth()
+
+
+  if (!session?.user?.id) {
+    console.error('[updateAISettings] Unauthorized: No session or user ID')
+    throw new Error('Unauthorized')
+  }
+
+  try {
+    const data = pickUserAISettingsForDb(settings)
+    if (Object.keys(data).length === 0) {
+      return { success: true }
+    }
+
+    // Valeurs scalaires uniquement (pickUserAISettingsForDb) — cast pour éviter UpdateOperations vs create.
+    const payload = data as Record<string, string | boolean | undefined>
+
+    // Upsert settings (create if not exists, update if exists)
+    await prisma.userAISettings.upsert({
+      where: { userId: session.user.id },
+      create: {
+        userId: session.user.id,
+        ...payload,
+      },
+      update: payload,
+    })
+
+    revalidatePath('/settings/ai', 'page')
+    revalidatePath('/settings/appearance', 'page')
+    revalidatePath('/', 'layout')
+    updateTag('ai-settings')
+
+    return { success: true }
+  } catch (error) {
+    console.error('Error updating AI settings:', error)
+    const raw = error instanceof Error ? error.message : String(error)
+    const isSchema =
+      /no such column|notesViewMode|Unknown column|does not exist/i.test(raw) ||
+      (typeof raw === 'string' && raw.includes('UserAISettings') && raw.includes('column'))
+    if (isSchema) {
+      throw new Error(
+        'Schéma base de données obsolète : colonne notesViewMode manquante. Dans le dossier memento-note, exécutez : npx prisma db push (ou appliquez les migrations Prisma).'
+      )
+    }
+    throw new Error('Failed to update AI settings')
+  }
+}
+
+/**
+ * Get AI settings for the current user (Cached)
+ */
+import { unstable_cache } from 'next/cache'
+
+// Internal cached function to fetch settings from DB
+const getCachedAISettings = unstable_cache(
+  async (userId: string) => {
+    try {
+      const settings = await prisma.userAISettings.findUnique({
+        where: { userId }
+      })
+
+      if (!settings) {
+        return {
+          titleSuggestions: true,
+          semanticSearch: true,
+          paragraphRefactor: true,
+          memoryEcho: true,
+          memoryEchoFrequency: 'daily' as const,
+          aiProvider: 'auto' as const,
+          preferredLanguage: 'auto' as const,
+          demoMode: false,
+          showRecentNotes: false,
+          notesViewMode: 'masonry' as const,
+          emailNotifications: false,
+          desktopNotifications: false,
+          anonymousAnalytics: false,
+          theme: 'light' as const,
+          fontSize: 'medium' as const
+        }
+      }
+
+      const raw = settings.notesViewMode
+      const viewMode =
+        raw === 'masonry'
+          ? ('masonry' as const)
+          : raw === 'list' || raw === 'tabs'
+            ? ('tabs' as const)
+            : ('masonry' as const)
+
+      return {
+        titleSuggestions: settings.titleSuggestions,
+        semanticSearch: settings.semanticSearch,
+        paragraphRefactor: settings.paragraphRefactor,
+        memoryEcho: settings.memoryEcho,
+        memoryEchoFrequency: (settings.memoryEchoFrequency || 'daily') as 'daily' | 'weekly' | 'custom',
+        aiProvider: (settings.aiProvider || 'auto') as 'auto' | 'openai' | 'ollama',
+        preferredLanguage: (settings.preferredLanguage || 'auto') as 'auto' | 'en' | 'fr' | 'es' | 'de' | 'fa' | 'it' | 'pt' | 'ru' | 'zh' | 'ja' | 'ko' | 'ar' | 'hi' | 'nl' | 'pl',
+        demoMode: settings.demoMode,
+        showRecentNotes: settings.showRecentNotes,
+        notesViewMode: viewMode,
+        emailNotifications: settings.emailNotifications,
+        desktopNotifications: settings.desktopNotifications,
+        anonymousAnalytics: settings.anonymousAnalytics,
+        // theme: 'light' as const, // REMOVED: Should not be handled here or hardcoded
+        fontSize: (settings.fontSize || 'medium') as 'small' | 'medium' | 'large'
+      }
+    } catch (error) {
+      console.error('Error getting AI settings:', error)
+      // Return defaults on error
+      return {
+        titleSuggestions: true,
+        semanticSearch: true,
+        paragraphRefactor: true,
+        memoryEcho: true,
+        memoryEchoFrequency: 'daily' as const,
+        aiProvider: 'auto' as const,
+        preferredLanguage: 'auto' as const,
+        demoMode: false,
+        showRecentNotes: false,
+        notesViewMode: 'masonry' as const,
+        emailNotifications: false,
+        desktopNotifications: false,
+        anonymousAnalytics: false,
+        theme: 'light' as const,
+        fontSize: 'medium' as const
+      }
+    }
+  },
+  ['user-ai-settings'],
+  { tags: ['ai-settings'] }
+)
+
+export async function getAISettings(userId?: string) {
+  let id = userId
+
+  if (!id) {
+    const session = await auth()
+    id = session?.user?.id
+  }
+
+  // Return defaults for non-logged-in users
+  if (!id) {
+    return {
+      titleSuggestions: true,
+      semanticSearch: true,
+      paragraphRefactor: true,
+      memoryEcho: true,
+      memoryEchoFrequency: 'daily' as const,
+      aiProvider: 'auto' as const,
+      preferredLanguage: 'auto' as const,
+      demoMode: false,
+      showRecentNotes: false,
+      notesViewMode: 'masonry' as const,
+      emailNotifications: false,
+      desktopNotifications: false,
+      anonymousAnalytics: false,
+      theme: 'light' as const,
+      fontSize: 'medium' as const
+    }
+  }
+
+  return getCachedAISettings(id)
+}
+
+/**
+ * Get user's preferred AI provider
+ */
+export async function getUserAIPreference(): Promise<'auto' | 'openai' | 'ollama'> {
+  const settings = await getAISettings()
+  return settings.aiProvider
+}
+
+/**
+ * Check if a specific AI feature is enabled for the user
+ */
+export async function isAIFeatureEnabled(feature: keyof UserAISettingsData): Promise<boolean> {
+  const settings = await getAISettings()
+
+  switch (feature) {
+    case 'titleSuggestions':
+      return settings.titleSuggestions
+    case 'semanticSearch':
+      return settings.semanticSearch
+    case 'paragraphRefactor':
+      return settings.paragraphRefactor
+    case 'memoryEcho':
+      return settings.memoryEcho
+    default:
+      return true
+  }
+}

memento-note/app/actions/auth-reset.ts

@@ -0,0 +1,90 @@
+'use server'
+
+import prisma from '@/lib/prisma'
+import { sendEmail } from '@/lib/mail'
+import { getSystemConfig } from '@/lib/config'
+import bcrypt from 'bcryptjs'
+import { getEmailTemplate } from '@/lib/email-template'
+
+// Helper simple pour générer un token sans dépendance externe lourde
+function generateToken() {
+  const array = new Uint8Array(32);
+  globalThis.crypto.getRandomValues(array);
+  return Array.from(array, byte => byte.toString(16).padStart(2, '0')).join('');
+}
+
+export async function forgotPassword(email: string) {
+  if (!email) return { error: "Email is required" };
+
+  try {
+    const user = await prisma.user.findUnique({ where: { email: email.toLowerCase() } });
+    if (!user) {
+      // Pour des raisons de sécurité, on ne dit pas si l'email existe ou pas
+      return { success: true }; 
+    }
+
+    const token = generateToken();
+    const expiry = new Date(Date.now() + 3600000); // 1 hour
+
+    await prisma.user.update({
+      where: { id: user.id },
+      data: {
+        resetToken: token,
+        resetTokenExpiry: expiry
+      }
+    });
+
+    const resetLink = `${process.env.NEXTAUTH_URL || 'http://localhost:3000'}/reset-password?token=${token}`;
+
+    const html = getEmailTemplate(
+      "Reset your Password",
+      "<p>You requested a password reset for your Memento account.</p><p>Click the button below to set a new password. This link is valid for 1 hour.</p>",
+      resetLink,
+      "Reset Password"
+    );
+
+    const sysConfig = await getSystemConfig()
+    const emailProvider = (sysConfig.EMAIL_PROVIDER || 'auto') as 'resend' | 'smtp' | 'auto'
+
+    await sendEmail({
+      to: user.email,
+      subject: "Reset your Memento password",
+      html
+    }, emailProvider);
+
+    return { success: true };
+  } catch (error) {
+    console.error('Forgot password error:', error);
+    return { error: "Failed to send reset email" };
+  }
+}
+
+export async function resetPassword(token: string, newPassword: string) {
+  if (!token || !newPassword) return { error: "Missing token or password" };
+
+  try {
+    const user = await prisma.user.findUnique({
+      where: { resetToken: token }
+    });
+
+    if (!user || !user.resetTokenExpiry || user.resetTokenExpiry < new Date()) {
+      return { error: "Invalid or expired token" };
+    }
+
+    const hashedPassword = await bcrypt.hash(newPassword, 10);
+
+    await prisma.user.update({
+      where: { id: user.id },
+      data: {
+        password: hashedPassword,
+        resetToken: null,
+        resetTokenExpiry: null
+      }
+    });
+
+    return { success: true };
+  } catch (error) {
+    console.error('Reset password error:', error);
+    return { error: "Failed to reset password" };
+  }
+}

memento-note/app/actions/auth.ts

@@ -0,0 +1,29 @@
+'use server';
+
+import { signIn } from '@/auth';
+import { AuthError } from 'next-auth';
+
+export async function authenticate(
+  prevState: string | undefined,
+  formData: FormData,
+) {
+  try {
+    await signIn('credentials', {
+      email: formData.get('email'),
+      password: formData.get('password'),
+      redirectTo: '/',
+    });
+  } catch (error) {
+    if (error instanceof AuthError) {
+      console.error('AuthError details:', error.type, error.message);
+      switch (error.type) {
+        case 'CredentialsSignin':
+          return 'Invalid credentials.';
+        default:
+          return `Auth error: ${error.type}`;
+      }
+    }
+    // IMPORTANT: Next.js redirects throw a special error that must be rethrown
+    throw error;
+  }
+}

memento-note/app/actions/canvas-actions.ts

@@ -0,0 +1,111 @@
+'use server'
+
+import { auth } from '@/auth'
+import { prisma } from '@/lib/prisma'
+import { revalidatePath } from 'next/cache'
+
+export async function saveCanvas(id: string | null, name: string, data: string) {
+  const session = await auth()
+  if (!session?.user?.id) throw new Error('Unauthorized')
+
+  if (id) {
+    const canvas = await prisma.canvas.update({
+      where: { id, userId: session.user.id },
+      data: { name, data }
+    })
+    revalidatePath('/lab')
+    return { success: true, canvas }
+  } else {
+    const canvas = await prisma.canvas.create({
+      data: {
+        name,
+        data,
+        userId: session.user.id
+      }
+    })
+    revalidatePath('/lab')
+    return { success: true, canvas }
+  }
+}
+
+export async function getCanvases() {
+  const session = await auth()
+  if (!session?.user?.id) return []
+
+  return prisma.canvas.findMany({
+    where: { userId: session.user.id },
+    orderBy: { createdAt: 'asc' }
+  })
+}
+
+export async function getCanvasDetails(id: string) {
+  const session = await auth()
+  if (!session?.user?.id) return null
+
+  return prisma.canvas.findUnique({
+    where: { id, userId: session.user.id }
+  })
+}
+
+export async function deleteCanvas(id: string) {
+  const session = await auth()
+  if (!session?.user?.id) throw new Error('Unauthorized')
+
+  await prisma.canvas.delete({
+    where: { id, userId: session.user.id }
+  })
+
+  revalidatePath('/lab')
+  return { success: true }
+}
+
+export async function renameCanvas(id: string, name: string) {
+  const session = await auth()
+  if (!session?.user?.id) throw new Error('Unauthorized')
+
+  await prisma.canvas.update({
+    where: { id, userId: session.user.id },
+    data: { name }
+  })
+
+  revalidatePath('/lab')
+  return { success: true }
+}
+
+export async function createCanvas(lang?: string) {
+  const session = await auth()
+  if (!session?.user?.id) throw new Error('Unauthorized')
+
+  const count = await prisma.canvas.count({
+    where: { userId: session.user.id }
+  })
+
+  const defaultNames: Record<string, string> = {
+    en: `Space ${count + 1}`,
+    fr: `Espace ${count + 1}`,
+    fa: `فضای ${count + 1}`,
+    es: `Espacio ${count + 1}`,
+    de: `Bereich ${count + 1}`,
+    it: `Spazio ${count + 1}`,
+    pt: `Espaço ${count + 1}`,
+    ru: `Пространство ${count + 1}`,
+    ja: `スペース ${count + 1}`,
+    ko: `공간 ${count + 1}`,
+    zh: `空间 ${count + 1}`,
+    ar: `مساحة ${count + 1}`,
+    hi: `स्थान ${count + 1}`,
+    nl: `Ruimte ${count + 1}`,
+    pl: `Przestrzeń ${count + 1}`,
+  }
+
+  const newCanvas = await prisma.canvas.create({
+    data: {
+      name: defaultNames[lang || 'en'] || defaultNames.en,
+      data: JSON.stringify({}),
+      userId: session.user.id
+    }
+  })
+
+  revalidatePath('/lab')
+  return newCanvas
+}

memento-note/app/actions/chat-actions.ts

@@ -0,0 +1,74 @@
+'use server'
+
+import { chatService } from '@/lib/ai/services'
+import { auth } from '@/auth'
+import { revalidatePath } from 'next/cache'
+import { prisma } from '@/lib/prisma'
+
+/**
+ * Create a new empty conversation and return its id.
+ * Called before streaming so the client knows the conversationId upfront.
+ */
+export async function createConversation(title: string, notebookId?: string) {
+  const session = await auth()
+  if (!session?.user?.id) throw new Error('Unauthorized')
+
+  const conversation = await prisma.conversation.create({
+    data: {
+      userId: session.user.id,
+      notebookId: notebookId || null,
+      title: title.substring(0, 80) + (title.length > 80 ? '...' : ''),
+    },
+  })
+
+  revalidatePath('/chat')
+  return { id: conversation.id, title: conversation.title }
+}
+
+/**
+ * @deprecated Use the streaming API route /api/chat instead.
+ * Kept for backward compatibility with the debug route.
+ */
+export async function sendChatMessage(
+  message: string,
+  conversationId?: string,
+  notebookId?: string
+) {
+  const session = await auth()
+  if (!session?.user?.id) throw new Error('Unauthorized')
+
+  try {
+    const result = await chatService.chat(message, conversationId, notebookId)
+    revalidatePath('/chat')
+    return { success: true, ...result }
+  } catch (error: any) {
+    console.error('[ChatAction] Error:', error)
+    return { success: false, error: error.message }
+  }
+}
+
+export async function getConversations() {
+  const session = await auth()
+  if (!session?.user?.id) return []
+
+  return chatService.listConversations(session.user.id)
+}
+
+export async function getConversationDetails(id: string) {
+  const session = await auth()
+  if (!session?.user?.id) return null
+
+  return chatService.getHistory(id)
+}
+
+export async function deleteConversation(id: string) {
+  const session = await auth()
+  if (!session?.user?.id) throw new Error('Unauthorized')
+
+  await prisma.conversation.delete({
+    where: { id, userId: session.user.id }
+  })
+
+  revalidatePath('/chat')
+  return { success: true }
+}

memento-note/app/actions/custom-provider.ts

@@ -0,0 +1,114 @@
+'use server'
+
+interface OpenAIModel {
+  id: string
+  object: string
+  created?: number
+  owned_by?: string
+}
+
+interface OpenAIModelsResponse {
+  object: string
+  data: OpenAIModel[]
+}
+
+async function fetchModelsFromEndpoint(
+  endpoint: string,
+  apiKey?: string
+): Promise<{ success: boolean; models: string[]; error?: string }> {
+  try {
+    const headers: Record<string, string> = {
+      'Content-Type': 'application/json',
+    }
+    if (apiKey) {
+      headers['Authorization'] = `Bearer ${apiKey}`
+    }
+
+    const response = await fetch(endpoint, {
+      method: 'GET',
+      headers,
+      signal: AbortSignal.timeout(8000),
+    })
+
+    if (!response.ok) {
+      throw new Error(`API returned ${response.status}: ${response.statusText}`)
+    }
+
+    const data = await response.json() as OpenAIModelsResponse
+
+    const modelIds = (data.data || [])
+      .map((m) => m.id)
+      .filter(Boolean)
+      .sort()
+
+    return { success: true, models: modelIds }
+  } catch (error: any) {
+    console.error('Failed to fetch provider models:', error)
+    return {
+      success: false,
+      models: [],
+      error: error.message || 'Failed to connect to provider',
+    }
+  }
+}
+
+/**
+ * Fetch all models from a custom OpenAI-compatible provider.
+ * Uses GET /v1/models (standard endpoint).
+ */
+export async function getCustomModels(
+  baseUrl: string,
+  apiKey?: string
+): Promise<{ success: boolean; models: string[]; error?: string }> {
+  if (!baseUrl) {
+    return { success: false, models: [], error: 'Base URL is required' }
+  }
+
+  const cleanUrl = baseUrl.replace(/\/$/, '').replace(/\/v1$/, '')
+  return fetchModelsFromEndpoint(`${cleanUrl}/v1/models`, apiKey)
+}
+
+/**
+ * Fetch embedding-specific models from a custom provider.
+ * Tries GET /v1/embeddings/models first (OpenRouter-specific endpoint that returns
+ * only embedding models). Falls back to GET /v1/models filtered by common
+ * embedding model name patterns if the dedicated endpoint is unavailable.
+ */
+export async function getCustomEmbeddingModels(
+  baseUrl: string,
+  apiKey?: string
+): Promise<{ success: boolean; models: string[]; error?: string }> {
+  if (!baseUrl) {
+    return { success: false, models: [], error: 'Base URL is required' }
+  }
+
+  const cleanUrl = baseUrl.replace(/\/$/, '').replace(/\/v1$/, '')
+
+  // Try the OpenRouter-specific embeddings models endpoint first
+  const embeddingsEndpoint = await fetchModelsFromEndpoint(
+    `${cleanUrl}/v1/embeddings/models`,
+    apiKey
+  )
+
+  if (embeddingsEndpoint.success && embeddingsEndpoint.models.length > 0) {
+    return embeddingsEndpoint
+  }
+
+  // Fallback: fetch all models and filter by common embedding name patterns
+  const allModels = await fetchModelsFromEndpoint(`${cleanUrl}/v1/models`, apiKey)
+
+  if (!allModels.success) {
+    return allModels
+  }
+
+  const embeddingKeywords = ['embed', 'embedding', 'ada', 'e5', 'bge', 'gte', 'minilm']
+  const filtered = allModels.models.filter((id) =>
+    embeddingKeywords.some((kw) => id.toLowerCase().includes(kw))
+  )
+
+  // If the filter finds nothing, return all models so the user can still pick
+  return {
+    success: true,
+    models: filtered.length > 0 ? filtered : allModels.models,
+  }
+}

memento-note/app/actions/detect-language.ts

@@ -0,0 +1,12 @@
+'use server'
+
+import { detectUserLanguage } from '@/lib/i18n/detect-user-language'
+import { SupportedLanguage } from '@/lib/i18n/load-translations'
+
+/**
+ * Server action to detect user's preferred language
+ * Called on app load to set initial language
+ */
+export async function getInitialLanguage(): Promise<SupportedLanguage> {
+  return await detectUserLanguage()
+}

memento-note/app/actions/mcp-keys.ts

@@ -0,0 +1,167 @@
+'use server'
+
+import { auth } from '@/auth'
+import { prisma } from '@/lib/prisma'
+import { revalidatePath } from 'next/cache'
+import { createHash, randomBytes } from 'crypto'
+
+const KEY_PREFIX = 'mcp_key_'
+
+function hashKey(rawKey: string): string {
+  return createHash('sha256').update(rawKey).digest('hex')
+}
+
+export type McpKeyInfo = {
+  shortId: string
+  name: string
+  userId: string
+  userName: string
+  active: boolean
+  createdAt: string
+  lastUsedAt: string | null
+}
+
+/**
+ * List all MCP API keys for the current user.
+ */
+export async function listMcpKeys(): Promise<McpKeyInfo[]> {
+  const session = await auth()
+  if (!session?.user?.id) throw new Error('Unauthorized')
+
+  const allKeys = await prisma.systemConfig.findMany({
+    where: { key: { startsWith: KEY_PREFIX } },
+  })
+
+  const keys: McpKeyInfo[] = []
+  for (const entry of allKeys) {
+    try {
+      const info = JSON.parse(entry.value)
+      if (info.userId !== session.user.id) continue
+      keys.push({
+        shortId: info.shortId,
+        name: info.name,
+        userId: info.userId,
+        userName: info.userName,
+        active: info.active,
+        createdAt: info.createdAt,
+        lastUsedAt: info.lastUsedAt,
+      })
+    } catch {
+      // skip invalid JSON
+    }
+  }
+
+  return keys
+}
+
+/**
+ * Generate a new MCP API key for the current user.
+ * Returns the raw key (shown only once) and key info.
+ */
+export async function generateMcpKey(name: string): Promise<{ rawKey: string; info: { shortId: string; name: string } }> {
+  const session = await auth()
+  if (!session?.user?.id) throw new Error('Unauthorized')
+
+  const user = await prisma.user.findUnique({
+    where: { id: session.user.id },
+    select: { id: true, name: true, email: true },
+  })
+  if (!user) throw new Error('User not found')
+
+  const rawBytes = randomBytes(24)
+  const shortId = rawBytes.toString('hex').substring(0, 8)
+  const rawKey = `mcp_sk_${rawBytes.toString('hex')}`
+  const keyHash = hashKey(rawKey)
+
+  const keyInfo = {
+    shortId,
+    name: name || `Key for ${user.name}`,
+    userId: user.id,
+    userName: user.name,
+    userEmail: user.email,
+    keyHash,
+    createdAt: new Date().toISOString(),
+    lastUsedAt: null,
+    active: true,
+  }
+
+  await prisma.systemConfig.create({
+    data: {
+      key: `${KEY_PREFIX}${shortId}`,
+      value: JSON.stringify(keyInfo),
+    },
+  })
+
+  revalidatePath('/settings/mcp')
+
+  return {
+    rawKey,
+    info: { shortId, name: keyInfo.name },
+  }
+}
+
+/**
+ * Revoke (deactivate) an MCP API key. Only the owner can revoke.
+ */
+export async function revokeMcpKey(shortId: string): Promise<boolean> {
+  const session = await auth()
+  if (!session?.user?.id) throw new Error('Unauthorized')
+
+  const configKey = `${KEY_PREFIX}${shortId}`
+  const entry = await prisma.systemConfig.findUnique({ where: { key: configKey } })
+  if (!entry) throw new Error('Key not found')
+
+  const info = JSON.parse(entry.value)
+  if (info.userId !== session.user.id) throw new Error('Forbidden')
+  if (!info.active) return false
+
+  info.active = false
+  info.revokedAt = new Date().toISOString()
+
+  await prisma.systemConfig.update({
+    where: { key: configKey },
+    data: { value: JSON.stringify(info) },
+  })
+
+  revalidatePath('/settings/mcp')
+  return true
+}
+
+/**
+ * Permanently delete an MCP API key. Only the owner can delete.
+ */
+export async function deleteMcpKey(shortId: string): Promise<boolean> {
+  const session = await auth()
+  if (!session?.user?.id) throw new Error('Unauthorized')
+
+  const configKey = `${KEY_PREFIX}${shortId}`
+  const entry = await prisma.systemConfig.findUnique({ where: { key: configKey } })
+  if (!entry) throw new Error('Key not found')
+
+  const info = JSON.parse(entry.value)
+  if (info.userId !== session.user.id) throw new Error('Forbidden')
+
+  try {
+    await prisma.systemConfig.delete({ where: { key: configKey } })
+    revalidatePath('/settings/mcp')
+    return true
+  } catch {
+    return false
+  }
+}
+
+export type McpServerStatus = {
+  mode: 'stdio' | 'sse' | 'unknown'
+  url: string | null
+}
+
+/**
+ * Get MCP server status — mode and URL.
+ */
+export async function getMcpServerStatus(): Promise<McpServerStatus> {
+  // Check if SSE mode is configured via env
+  const mode = process.env.MCP_SERVER_MODE === 'sse' ? 'sse' : 'stdio'
+  const url = process.env.MCP_SERVER_URL || null
+
+  return { mode, url }
+}

memento-note/app/actions/ollama.ts

@@ -0,0 +1,57 @@
+'use server'
+
+interface OllamaModel {
+    name: string
+    modified_at: string
+    size: number
+    digest: string
+    details: {
+        format: string
+        family: string
+        families: string[]
+        parameter_size: string
+        quantization_level: string
+    }
+}
+
+interface OllamaTagsResponse {
+    models: OllamaModel[]
+}
+
+export async function getOllamaModels(baseUrl: string): Promise<{ success: boolean; models: string[]; error?: string }> {
+    if (!baseUrl) {
+        return { success: false, models: [], error: 'Base URL is required' }
+    }
+
+    // Ensure URL doesn't end with slash
+    const cleanUrl = baseUrl.replace(/\/$/, '')
+
+    try {
+        const response = await fetch(`${cleanUrl}/api/tags`, {
+            method: 'GET',
+            headers: {
+                'Content-Type': 'application/json',
+            },
+            // Set a reasonable timeout
+            signal: AbortSignal.timeout(5000)
+        })
+
+        if (!response.ok) {
+            throw new Error(`Ollama API returned ${response.status}: ${response.statusText}`)
+        }
+
+        const data = await response.json() as OllamaTagsResponse
+
+        // Extract model names
+        const modelNames = data.models?.map(m => m.name) || []
+
+        return { success: true, models: modelNames }
+    } catch (error: any) {
+        console.error('Failed to fetch Ollama models:', error)
+        return {
+            success: false,
+            models: [],
+            error: error.message || 'Failed to connect to Ollama'
+        }
+    }
+}

memento-note/app/actions/paragraph-refactor.ts

@@ -0,0 +1,49 @@
+'use server'
+
+import { paragraphRefactorService, RefactorMode, RefactorResult } from '@/lib/ai/services/paragraph-refactor.service'
+
+export interface RefactorResponse {
+  result: RefactorResult
+}
+
+/**
+ * Refactor a paragraph with a specific mode
+ */
+export async function refactorParagraph(
+  content: string,
+  mode: RefactorMode
+): Promise<RefactorResponse> {
+  try {
+    const result = await paragraphRefactorService.refactor(content, mode)
+
+    return { result }
+  } catch (error) {
+    console.error('Error refactoring paragraph:', error)
+    throw error
+  }
+}
+
+/**
+ * Get all 3 refactor options at once
+ */
+export async function refactorParagraphAllModes(
+  content: string
+): Promise<{ results: RefactorResult[] }> {
+  try {
+    const results = await paragraphRefactorService.refactorAllModes(content)
+
+    return { results }
+  } catch (error) {
+    console.error('Error refactoring paragraph in all modes:', error)
+    throw error
+  }
+}
+
+/**
+ * Validate word count before refactoring
+ */
+export async function validateRefactorWordCount(
+  content: string
+): Promise<{ valid: boolean; error?: string }> {
+  return paragraphRefactorService.validateWordCount(content)
+}

memento-note/app/actions/profile-broken.ts

@@ -0,0 +1,232 @@
+'use server'
+
+import { revalidatePath } from 'next/cache'
+import prisma from '@/lib/prisma'
+import { auth } from '@/auth'
+import bcrypt from 'bcryptjs'
+import { z } from 'zod'
+
+const ProfileSchema = z.object({
+  name: z.string().min(2, "Name must be at least 2 characters"),
+  email: z.string().email().optional(), // Email change might require verification logic, keeping it simple for now or read-only
+})
+
+const PasswordSchema = z.object({
+  currentPassword: z.string().min(1, "Current password is required"),
+  newPassword: z.string().min(6, "New password must be at least 6 characters"),
+  confirmPassword: z.string().min(6, "Confirm password must be at least 6 characters"),
+}).refine((data) => data.newPassword === data.confirmPassword, {
+  message: "Passwords don't match",
+  path: ["confirmPassword"],
+})
+
+export async function updateProfile(data: { name: string }) {
+  const session = await auth()
+  if (!session?.user?.id) throw new Error('Unauthorized')
+
+  const validated = ProfileSchema.safeParse(data)
+  if (!validated.success) {
+    return { error: validated.error.flatten().fieldErrors }
+  }
+
+  try {
+    await prisma.user.update({
+      where: { id: session.user.id },
+      data: { name: validated.data.name },
+    })
+    revalidatePath('/settings/profile')
+    return { success: true }
+  } catch (error) {
+    return { error: { _form: ['Failed to update profile'] } }
+  }
+}
+
+export async function changePassword(formData: FormData) {
+  const session = await auth()
+  if (!session?.user?.id) throw new Error('Unauthorized')
+
+  const rawData = {
+    currentPassword: formData.get('currentPassword'),
+    newPassword: formData.get('newPassword'),
+    confirmPassword: formData.get('confirmPassword'),
+  }
+
+  const validated = PasswordSchema.safeParse(rawData)
+  if (!validated.success) {
+    return { error: validated.error.flatten().fieldErrors }
+  }
+
+  const { currentPassword, newPassword } = validated.data
+
+  const user = await prisma.user.findUnique({
+    where: { id: session.user.id },
+  })
+
+  if (!user || !user.password) {
+    return { error: { _form: ['User not found'] } }
+  }
+
+  const passwordsMatch = await bcrypt.compare(currentPassword, user.password)
+  if (!passwordsMatch) {
+    return { error: { currentPassword: ['Incorrect current password'] } }
+  }
+
+  const hashedPassword = await bcrypt.hash(newPassword, 10)
+
+  try {
+    await prisma.user.update({
+      where: { id: session.user.id },
+      data: { password: hashedPassword },
+    })
+    return { success: true }
+  } catch (error) {
+    return { error: { _form: ['Failed to change password'] } }
+  }
+}
+
+export async function updateTheme(theme: string) {
+  const session = await auth()
+  if (!session?.user?.id) return { error: 'Unauthorized' }
+
+  try {
+    await prisma.user.update({
+      where: { id: session.user.id },
+      data: { theme },
+    })
+    revalidatePath('/')
+    revalidatePath('/settings/profile')
+    return { success: true }
+  } catch (error) {
+    return { error: 'Failed to update theme' }
+  }
+}
+
+export async function updateLanguage(language: string) {
+  const session = await auth()
+  if (!session?.user?.id) return { error: 'Unauthorized' }
+
+  try {
+    // Update or create UserAISettings with the preferred language
+    await prisma.userAISettings.upsert({
+      where: { userId: session.user.id },
+      create: {
+        userId: session.user.id,
+        preferredLanguage: language,
+      },
+      update: {
+        preferredLanguage: language,
+      },
+    })
+
+    // Note: The language will be applied on next page load
+    // The client component should handle updating localStorage and reloading
+    revalidatePath('/')
+    revalidatePath('/settings/profile')
+    return { success: true, language }
+  } catch (error) {
+    console.error('Failed to update language:', error)
+    return { error: 'Failed to update language' }
+  }
+}
+
+export async function updateFontSize(fontSize: string) {
+  const session = await auth()
+  if (!session?.user?.id) return { error: 'Unauthorized' }
+
+  try {
+    // Check if UserAISettings exists
+    const existing = await prisma.userAISettings.findUnique({
+      where: { userId: session.user.id }
+    })
+
+    let result
+    if (existing) {
+      // Update existing - only update fontSize field
+      result = await prisma.userAISettings.update({
+        where: { userId: session.user.id },
+        data: { fontSize: fontSize }
+      })
+      } else {
+      // Create new with all required fields
+      result = await prisma.userAISettings.create({
+        data: {
+          userId: session.user.id,
+          fontSize: fontSize,
+          // Set default values for required fields
+          titleSuggestions: true,
+          semanticSearch: true,
+          paragraphRefactor: true,
+          memoryEcho: true,
+          memoryEchoFrequency: 'daily',
+          aiProvider: 'auto',
+          preferredLanguage: 'auto',
+          showRecentNotes: false
+        }
+      })
+      }
+
+    revalidatePath('/')
+    revalidatePath('/settings/profile')
+    return { success: true, fontSize }
+  } catch (error) {
+    console.error('[updateFontSize] Failed to update font size:', error)
+    return { error: 'Failed to update font size' }
+  }
+}
+
+export async function updateShowRecentNotes(showRecentNotes: boolean) {
+  const session = await auth()
+  if (!session?.user?.id) return { error: 'Unauthorized' }
+
+  try {
+    // Use EXACT same pattern as updateFontSize which works
+    const existing = await prisma.userAISettings.findUnique({
+      where: { userId: session.user.id }
+    })
+
+    if (existing) {
+      // Try Prisma client first, fallback to raw SQL if field doesn't exist in client
+      try {
+        await prisma.userAISettings.update({
+          where: { userId: session.user.id },
+          data: { showRecentNotes: showRecentNotes } as any
+        })
+      } catch (prismaError: any) {
+        // If Prisma client doesn't know about showRecentNotes, use raw SQL
+        if (prismaError?.message?.includes('Unknown argument') || prismaError?.code === 'P2009') {
+          const value = showRecentNotes ? 1 : 0
+          await prisma.$executeRaw`
+            UPDATE UserAISettings 
+            SET showRecentNotes = ${value}
+            WHERE userId = ${session.user.id}
+          `
+        } else {
+          throw prismaError
+        }
+      }
+    } else {
+      // Create new - same as updateFontSize
+      await prisma.userAISettings.create({
+        data: {
+          userId: session.user.id,
+          titleSuggestions: true,
+          semanticSearch: true,
+          paragraphRefactor: true,
+          memoryEcho: true,
+          memoryEchoFrequency: 'daily',
+          aiProvider: 'auto',
+          preferredLanguage: 'auto',
+          fontSize: 'medium',
+          showRecentNotes: showRecentNotes
+        } as any
+      })
+    }
+
+    revalidatePath('/')
+    revalidatePath('/settings/profile')
+    return { success: true, showRecentNotes }
+  } catch (error) {
+    console.error('[updateShowRecentNotes] Failed:', error)
+    return { error: 'Failed to update show recent notes setting' }
+  }
+}

memento-note/app/actions/profile-old.ts

@@ -0,0 +1,232 @@
+'use server'
+
+import { revalidatePath } from 'next/cache'
+import prisma from '@/lib/prisma'
+import { auth } from '@/auth'
+import bcrypt from 'bcryptjs'
+import { z } from 'zod'
+
+const ProfileSchema = z.object({
+  name: z.string().min(2, "Name must be at least 2 characters"),
+  email: z.string().email().optional(), // Email change might require verification logic, keeping it simple for now or read-only
+})
+
+const PasswordSchema = z.object({
+  currentPassword: z.string().min(1, "Current password is required"),
+  newPassword: z.string().min(6, "New password must be at least 6 characters"),
+  confirmPassword: z.string().min(6, "Confirm password must be at least 6 characters"),
+}).refine((data) => data.newPassword === data.confirmPassword, {
+  message: "Passwords don't match",
+  path: ["confirmPassword"],
+})
+
+export async function updateProfile(data: { name: string }) {
+  const session = await auth()
+  if (!session?.user?.id) throw new Error('Unauthorized')
+
+  const validated = ProfileSchema.safeParse(data)
+  if (!validated.success) {
+    return { error: validated.error.flatten().fieldErrors }
+  }
+
+  try {
+    await prisma.user.update({
+      where: { id: session.user.id },
+      data: { name: validated.data.name },
+    })
+    revalidatePath('/settings/profile')
+    return { success: true }
+  } catch (error) {
+    return { error: { _form: ['Failed to update profile'] } }
+  }
+}
+
+export async function changePassword(formData: FormData) {
+  const session = await auth()
+  if (!session?.user?.id) throw new Error('Unauthorized')
+
+  const rawData = {
+    currentPassword: formData.get('currentPassword'),
+    newPassword: formData.get('newPassword'),
+    confirmPassword: formData.get('confirmPassword'),
+  }
+
+  const validated = PasswordSchema.safeParse(rawData)
+  if (!validated.success) {
+    return { error: validated.error.flatten().fieldErrors }
+  }
+
+  const { currentPassword, newPassword } = validated.data
+
+  const user = await prisma.user.findUnique({
+    where: { id: session.user.id },
+  })
+
+  if (!user || !user.password) {
+    return { error: { _form: ['User not found'] } }
+  }
+
+  const passwordsMatch = await bcrypt.compare(currentPassword, user.password)
+  if (!passwordsMatch) {
+    return { error: { currentPassword: ['Incorrect current password'] } }
+  }
+
+  const hashedPassword = await bcrypt.hash(newPassword, 10)
+
+  try {
+    await prisma.user.update({
+      where: { id: session.user.id },
+      data: { password: hashedPassword },
+    })
+    return { success: true }
+  } catch (error) {
+    return { error: { _form: ['Failed to change password'] } }
+  }
+}
+
+export async function updateTheme(theme: string) {
+  const session = await auth()
+  if (!session?.user?.id) return { error: 'Unauthorized' }
+
+  try {
+    await prisma.user.update({
+      where: { id: session.user.id },
+      data: { theme },
+    })
+    revalidatePath('/')
+    revalidatePath('/settings/profile')
+    return { success: true }
+  } catch (error) {
+    return { error: 'Failed to update theme' }
+  }
+}
+
+export async function updateLanguage(language: string) {
+  const session = await auth()
+  if (!session?.user?.id) return { error: 'Unauthorized' }
+
+  try {
+    // Update or create UserAISettings with the preferred language
+    await prisma.userAISettings.upsert({
+      where: { userId: session.user.id },
+      create: {
+        userId: session.user.id,
+        preferredLanguage: language,
+      },
+      update: {
+        preferredLanguage: language,
+      },
+    })
+
+    // Note: The language will be applied on next page load
+    // The client component should handle updating localStorage and reloading
+    revalidatePath('/')
+    revalidatePath('/settings/profile')
+    return { success: true, language }
+  } catch (error) {
+    console.error('Failed to update language:', error)
+    return { error: 'Failed to update language' }
+  }
+}
+
+export async function updateFontSize(fontSize: string) {
+  const session = await auth()
+  if (!session?.user?.id) return { error: 'Unauthorized' }
+
+  try {
+    // Check if UserAISettings exists
+    const existing = await prisma.userAISettings.findUnique({
+      where: { userId: session.user.id }
+    })
+
+    let result
+    if (existing) {
+      // Update existing - only update fontSize field
+      result = await prisma.userAISettings.update({
+        where: { userId: session.user.id },
+        data: { fontSize: fontSize }
+      })
+      } else {
+      // Create new with all required fields
+      result = await prisma.userAISettings.create({
+        data: {
+          userId: session.user.id,
+          fontSize: fontSize,
+          // Set default values for required fields
+          titleSuggestions: true,
+          semanticSearch: true,
+          paragraphRefactor: true,
+          memoryEcho: true,
+          memoryEchoFrequency: 'daily',
+          aiProvider: 'auto',
+          preferredLanguage: 'auto',
+          showRecentNotes: false
+        }
+      })
+      }
+
+    revalidatePath('/')
+    revalidatePath('/settings/profile')
+    return { success: true, fontSize }
+  } catch (error) {
+    console.error('[updateFontSize] Failed to update font size:', error)
+    return { error: 'Failed to update font size' }
+  }
+}
+
+export async function updateShowRecentNotes(showRecentNotes: boolean) {
+  const session = await auth()
+  if (!session?.user?.id) return { error: 'Unauthorized' }
+
+  try {
+    // Use EXACT same pattern as updateFontSize which works
+    const existing = await prisma.userAISettings.findUnique({
+      where: { userId: session.user.id }
+    })
+
+    if (existing) {
+      // Try Prisma client first, fallback to raw SQL if field doesn't exist in client
+      try {
+        await prisma.userAISettings.update({
+          where: { userId: session.user.id },
+          data: { showRecentNotes: showRecentNotes } as any
+        })
+      } catch (prismaError: any) {
+        // If Prisma client doesn't know about showRecentNotes, use raw SQL
+        if (prismaError?.message?.includes('Unknown argument') || prismaError?.code === 'P2009') {
+          const value = showRecentNotes ? 1 : 0
+          await prisma.$executeRaw`
+            UPDATE UserAISettings 
+            SET showRecentNotes = ${value}
+            WHERE userId = ${session.user.id}
+          `
+        } else {
+          throw prismaError
+        }
+      }
+    } else {
+      // Create new - same as updateFontSize
+      await prisma.userAISettings.create({
+        data: {
+          userId: session.user.id,
+          titleSuggestions: true,
+          semanticSearch: true,
+          paragraphRefactor: true,
+          memoryEcho: true,
+          memoryEchoFrequency: 'daily',
+          aiProvider: 'auto',
+          preferredLanguage: 'auto',
+          fontSize: 'medium',
+          showRecentNotes: showRecentNotes
+        } as any
+      })
+    }
+
+    revalidatePath('/')
+    revalidatePath('/settings/profile')
+    return { success: true, showRecentNotes }
+  } catch (error) {
+    console.error('[updateShowRecentNotes] Failed:', error)
+    return { error: 'Failed to update show recent notes setting' }
+  }
+}

memento-note/app/actions/profile.ts

@@ -0,0 +1,201 @@
+'use server'
+
+import { revalidatePath } from 'next/cache'
+import prisma from '@/lib/prisma'
+import { auth } from '@/auth'
+import bcrypt from 'bcryptjs'
+import { z } from 'zod'
+
+const ProfileSchema = z.object({
+  name: z.string().min(2, "Name must be at least 2 characters"),
+  email: z.string().email().optional(), // Email change might require verification logic, keeping it simple for now or read-only
+})
+
+const PasswordSchema = z.object({
+  currentPassword: z.string().min(1, "Current password is required"),
+  newPassword: z.string().min(6, "New password must be at least 6 characters"),
+  confirmPassword: z.string().min(6, "Confirm password must be at least 6 characters"),
+}).refine((data) => data.newPassword === data.confirmPassword, {
+  message: "Passwords don't match",
+  path: ["confirmPassword"],
+})
+
+export async function updateProfile(data: { name: string }) {
+  const session = await auth()
+  if (!session?.user?.id) throw new Error('Unauthorized')
+
+  const validated = ProfileSchema.safeParse(data)
+  if (!validated.success) {
+    return { error: validated.error.flatten().fieldErrors }
+  }
+
+  try {
+    await prisma.user.update({
+      where: { id: session.user.id },
+      data: { name: validated.data.name },
+    })
+    revalidatePath('/settings/profile')
+    return { success: true }
+  } catch (error) {
+    return { error: { _form: ['Failed to update profile'] } }
+  }
+}
+
+export async function changePassword(formData: FormData) {
+  const session = await auth()
+  if (!session?.user?.id) throw new Error('Unauthorized')
+
+  const rawData = {
+    currentPassword: formData.get('currentPassword'),
+    newPassword: formData.get('newPassword'),
+    confirmPassword: formData.get('confirmPassword'),
+  }
+
+  const validated = PasswordSchema.safeParse(rawData)
+  if (!validated.success) {
+    return { error: validated.error.flatten().fieldErrors }
+  }
+
+  const { currentPassword, newPassword } = validated.data
+
+  const user = await prisma.user.findUnique({
+    where: { id: session.user.id },
+  })
+
+  if (!user || !user.password) {
+    return { error: { _form: ['User not found'] } }
+  }
+
+  const passwordsMatch = await bcrypt.compare(currentPassword, user.password)
+  if (!passwordsMatch) {
+    return { error: { currentPassword: ['Incorrect current password'] } }
+  }
+
+  const hashedPassword = await bcrypt.hash(newPassword, 10)
+
+  try {
+    await prisma.user.update({
+      where: { id: session.user.id },
+      data: { password: hashedPassword },
+    })
+    return { success: true }
+  } catch (error) {
+    return { error: { _form: ['Failed to change password'] } }
+  }
+}
+
+export async function updateTheme(theme: string) {
+  const session = await auth()
+  if (!session?.user?.id) return { error: 'Unauthorized' }
+
+  try {
+    await prisma.user.update({
+      where: { id: session.user.id },
+      data: { theme },
+    })
+    revalidatePath('/')
+    revalidatePath('/settings/profile')
+    return { success: true }
+  } catch (error) {
+    return { error: 'Failed to update theme' }
+  }
+}
+
+export async function updateLanguage(language: string) {
+  const session = await auth()
+  if (!session?.user?.id) return { error: 'Unauthorized' }
+
+  try {
+    // Update or create UserAISettings with the preferred language
+    await prisma.userAISettings.upsert({
+      where: { userId: session.user.id },
+      create: {
+        userId: session.user.id,
+        preferredLanguage: language,
+      },
+      update: {
+        preferredLanguage: language,
+      },
+    })
+
+    // Note: The language will be applied on next page load
+    // The client component should handle updating localStorage and reloading
+    revalidatePath('/')
+    revalidatePath('/settings/profile')
+    return { success: true, language }
+  } catch (error) {
+    console.error('Failed to update language:', error)
+    return { error: 'Failed to update language' }
+  }
+}
+
+export async function updateFontSize(fontSize: string) {
+  const session = await auth()
+  if (!session?.user?.id) return { error: 'Unauthorized' }
+
+  try {
+    // Check if UserAISettings exists
+    const existing = await prisma.userAISettings.findUnique({
+      where: { userId: session.user.id }
+    })
+
+    let result
+    if (existing) {
+      // Update existing - only update fontSize field
+      result = await prisma.userAISettings.update({
+        where: { userId: session.user.id },
+        data: { fontSize: fontSize }
+      })
+    } else {
+      // Create new with all required fields
+      result = await prisma.userAISettings.create({
+        data: {
+          userId: session.user.id,
+          fontSize: fontSize,
+          // Set default values for required fields
+          titleSuggestions: true,
+          semanticSearch: true,
+          paragraphRefactor: true,
+          memoryEcho: true,
+          memoryEchoFrequency: 'daily',
+          aiProvider: 'auto',
+          preferredLanguage: 'auto',
+          showRecentNotes: false
+        }
+      })
+    }
+
+    revalidatePath('/')
+    revalidatePath('/settings/profile')
+    return { success: true, fontSize }
+  } catch (error) {
+    console.error('[updateFontSize] Failed to update font size:', error)
+    return { error: 'Failed to update font size' }
+  }
+}
+
+export async function updateShowRecentNotes(showRecentNotes: boolean) {
+  const session = await auth()
+  if (!session?.user?.id) return { error: 'Unauthorized' }
+
+  try {
+    await prisma.userAISettings.upsert({
+      where: { userId: session.user.id },
+      create: {
+        userId: session.user.id,
+        showRecentNotes,
+        // Defaults will be used for other fields
+      },
+      update: {
+        showRecentNotes,
+      },
+    })
+
+    revalidatePath('/')
+    revalidatePath('/settings/profile')
+    return { success: true, showRecentNotes }
+  } catch (error) {
+    console.error('[updateShowRecentNotes] Failed:', error)
+    return { error: 'Failed to update show recent notes setting' }
+  }
+}

memento-note/app/actions/register.ts

@@ -0,0 +1,63 @@
+'use server';
+
+import bcrypt from 'bcryptjs';
+import prisma from '@/lib/prisma';
+import { z } from 'zod';
+import { redirect } from 'next/navigation';
+import { getSystemConfig } from '@/lib/config';
+
+const RegisterSchema = z.object({
+  email: z.string().email(),
+  password: z.string().min(6),
+  name: z.string().min(2),
+});
+
+export async function register(prevState: string | undefined, formData: FormData) {
+  // Check if registration is allowed
+  const config = await getSystemConfig();
+  const allowRegister = config.ALLOW_REGISTRATION !== 'false' && process.env.ALLOW_REGISTRATION !== 'false';
+
+  if (!allowRegister) {
+    return 'Registration is currently disabled by the administrator.';
+  }
+
+  const validatedFields = RegisterSchema.safeParse({
+    email: formData.get('email'),
+    password: formData.get('password'),
+    name: formData.get('name'),
+  });
+
+  if (!validatedFields.success) {
+    return 'Invalid fields. Failed to register.';
+  }
+
+  const { email, password, name } = validatedFields.data;
+
+  try {
+    const existingUser = await prisma.user.findUnique({ where: { email: email.toLowerCase() } });
+    if (existingUser) {
+      return 'User already exists.';
+    }
+
+    const hashedPassword = await bcrypt.hash(password, 10);
+
+    await prisma.user.create({
+      data: {
+        email: email.toLowerCase(),
+        password: hashedPassword,
+        name,
+      },
+    });
+    
+    // Attempt to sign in immediately after registration
+    // We cannot import signIn here directly if it causes circular deps or issues, 
+    // but usually it works. If not, redirecting to login is fine.
+    // Let's stick to redirecting to login but with a clear success message?
+    // Or better: lowercase the email to fix the potential bug.
+  } catch (error) {
+    console.error('Registration Error:', error);
+    return 'Database Error: Failed to create user.';
+  }
+
+  redirect('/login');
+}

memento-note/app/actions/scrape.ts

@@ -0,0 +1,59 @@
+'use server'
+
+import * as cheerio from 'cheerio';
+
+export interface LinkMetadata {
+  url: string;
+  title?: string;
+  description?: string;
+  imageUrl?: string;
+  siteName?: string;
+}
+
+export async function fetchLinkMetadata(url: string): Promise<LinkMetadata | null> {
+  try {
+    // Add protocol if missing
+    let targetUrl = url;
+    if (!url.startsWith('http://') && !url.startsWith('https://')) {
+      targetUrl = 'https://' + url;
+    }
+
+    const response = await fetch(targetUrl, {
+      headers: {
+        // Use a real browser User-Agent to avoid 403 Forbidden from strict sites
+        'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36',
+        'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8',
+        'Accept-Language': 'en-US,en;q=0.5'
+      },
+      next: { revalidate: 3600 } // Cache for 1 hour
+    });
+
+    if (!response.ok) {
+      return null;
+    }
+
+    const html = await response.text();
+    const $ = cheerio.load(html);
+
+    const getMeta = (prop: string) => 
+      $(`meta[property="${prop}"]`).attr('content') || 
+      $(`meta[name="${prop}"]`).attr('content');
+
+    // Robust extraction with fallbacks
+    const title = getMeta('og:title') || $('title').text() || getMeta('twitter:title') || url;
+    const description = getMeta('og:description') || getMeta('description') || getMeta('twitter:description') || '';
+    const imageUrl = getMeta('og:image') || getMeta('twitter:image') || $('link[rel="image_src"]').attr('href');
+    const siteName = getMeta('og:site_name') || '';
+
+    return {
+      url: targetUrl,
+      title: title.substring(0, 100),
+      description: description.substring(0, 200),
+      imageUrl,
+      siteName
+    };
+  } catch (error) {
+    console.error(`[Scrape] Error fetching ${url}:`, error);
+    return null;
+  }
+}

memento-note/app/actions/semantic-search.ts

@@ -0,0 +1,63 @@
+'use server'
+
+import { semanticSearchService, SearchResult } from '@/lib/ai/services/semantic-search.service'
+
+export interface SemanticSearchResponse {
+  results: SearchResult[]
+  query: string
+  totalResults: number
+}
+
+/**
+ * Perform hybrid semantic + keyword search
+ * Supports contextual search within notebook (IA5)
+ */
+export async function semanticSearch(
+  query: string,
+  options?: {
+    limit?: number
+    threshold?: number
+    notebookId?: string // NEW: Filter by notebook for contextual search (IA5)
+  }
+): Promise<SemanticSearchResponse> {
+  try {
+    const results = await semanticSearchService.search(query, {
+      limit: options?.limit || 20,
+      threshold: options?.threshold || 0.6,
+      notebookId: options?.notebookId // NEW: Pass notebook filter
+    })
+
+    return {
+      results,
+      query,
+      totalResults: results.length
+    }
+  } catch (error) {
+    console.error('Error in semantic search action:', error)
+    throw error
+  }
+}
+
+/**
+ * Index a note for semantic search (generate embedding)
+ */
+export async function indexNote(noteId: string): Promise<void> {
+  try {
+    await semanticSearchService.indexNote(noteId)
+  } catch (error) {
+    console.error('Error indexing note:', error)
+    throw error
+  }
+}
+
+/**
+ * Batch index notes (for initial setup)
+ */
+export async function batchIndexNotes(noteIds: string[]): Promise<void> {
+  try {
+    await semanticSearchService.indexBatchNotes(noteIds)
+  } catch (error) {
+    console.error('Error batch indexing notes:', error)
+    throw error
+  }
+}

memento-note/app/actions/title-suggestions.ts

@@ -0,0 +1,128 @@
+'use server'
+
+import { auth } from '@/auth'
+import { titleSuggestionService } from '@/lib/ai/services/title-suggestion.service'
+import { prisma } from '@/lib/prisma'
+import { revalidatePath } from 'next/cache'
+
+export interface GenerateTitlesResponse {
+  suggestions: Array<{
+    title: string
+    confidence: number
+    reasoning?: string
+  }>
+  noteId: string
+}
+
+/**
+ * Generate title suggestions for a note
+ * Triggered when note reaches 50+ words without a title
+ */
+export async function generateTitleSuggestions(noteId: string): Promise<GenerateTitlesResponse> {
+  const session = await auth()
+  if (!session?.user?.id) {
+    throw new Error('Unauthorized')
+  }
+
+  try {
+    // Fetch note content
+    const note = await prisma.note.findUnique({
+      where: { id: noteId },
+      select: { id: true, content: true, userId: true }
+    })
+
+    if (!note) {
+      throw new Error('Note not found')
+    }
+
+    if (note.userId !== session.user.id) {
+      throw new Error('Forbidden')
+    }
+
+    if (!note.content || note.content.trim().length === 0) {
+      throw new Error('Note content is empty')
+    }
+
+    // Generate suggestions
+    const suggestions = await titleSuggestionService.generateSuggestions(note.content)
+
+    return {
+      suggestions,
+      noteId
+    }
+  } catch (error) {
+    console.error('Error generating title suggestions:', error)
+    throw error
+  }
+}
+
+/**
+ * Apply selected title to note
+ */
+export async function applyTitleSuggestion(
+  noteId: string,
+  selectedTitle: string
+): Promise<void> {
+  const session = await auth()
+  if (!session?.user?.id) {
+    throw new Error('Unauthorized')
+  }
+
+  try {
+    // Update note with selected title
+    await prisma.note.update({
+      where: {
+        id: noteId,
+        userId: session.user.id
+      },
+      data: {
+        title: selectedTitle,
+        autoGenerated: true,
+        lastAiAnalysis: new Date()
+      }
+    })
+
+    revalidatePath('/')
+    revalidatePath(`/note/${noteId}`)
+  } catch (error) {
+    console.error('Error applying title suggestion:', error)
+    throw error
+  }
+}
+
+/**
+ * Record user feedback on title suggestions
+ * (Phase 3 - for improving future suggestions)
+ */
+export async function recordTitleFeedback(
+  noteId: string,
+  selectedTitle: string,
+  allSuggestions: Array<{ title: string; confidence: number }>
+): Promise<void> {
+  const session = await auth()
+  if (!session?.user?.id) {
+    throw new Error('Unauthorized')
+  }
+
+  try {
+    // Save to AiFeedback table for learning
+    await prisma.aiFeedback.create({
+      data: {
+        noteId,
+        userId: session.user.id,
+        feedbackType: 'thumbs_up', // User chose one of our suggestions
+        feature: 'title_suggestion',
+        originalContent: JSON.stringify(allSuggestions),
+        correctedContent: selectedTitle,
+        metadata: JSON.stringify({
+          timestamp: new Date().toISOString(),
+          provider: 'auto' // Will be dynamic based on user settings
+        })
+      }
+    })
+
+  } catch (error) {
+    console.error('Error recording title feedback:', error)
+    // Don't throw - feedback is optional
+  }
+}

memento-note/app/actions/user-settings.ts

@@ -0,0 +1,86 @@
+'use server'
+
+import { auth } from '@/auth'
+import { prisma } from '@/lib/prisma'
+import { revalidatePath, updateTag } from 'next/cache'
+
+export type UserSettingsData = {
+  theme?: 'light' | 'dark' | 'auto' | 'sepia' | 'midnight' | 'blue'
+  cardSizeMode?: 'variable' | 'uniform'
+}
+
+/**
+ * Update user settings (theme, etc.)
+ */
+export async function updateUserSettings(settings: UserSettingsData) {
+
+  const session = await auth()
+
+  if (!session?.user?.id) {
+    console.error('[updateUserSettings] Unauthorized')
+    throw new Error('Unauthorized')
+  }
+
+  try {
+    const result = await prisma.user.update({
+      where: { id: session.user.id },
+      data: settings
+    })
+
+
+    revalidatePath('/', 'layout')
+    updateTag('user-settings')
+
+    return { success: true }
+  } catch (error) {
+    console.error('Error updating user settings:', error)
+    throw new Error('Failed to update user settings')
+  }
+}
+
+/**
+ * Get user settings for current user (Cached)
+ */
+import { unstable_cache } from 'next/cache'
+
+// Internal cached function
+const getCachedUserSettings = unstable_cache(
+  async (userId: string) => {
+    try {
+      const user = await prisma.user.findUnique({
+        where: { id: userId },
+        select: { theme: true, cardSizeMode: true }
+      })
+
+      return {
+        theme: (user?.theme || 'light') as 'light' | 'dark' | 'auto' | 'sepia' | 'midnight' | 'blue',
+        cardSizeMode: (user?.cardSizeMode || 'variable') as 'variable' | 'uniform'
+      }
+    } catch (error) {
+      console.error('Error getting user settings:', error)
+      return {
+        theme: 'light' as const
+      }
+    }
+  },
+  ['user-settings'],
+  { tags: ['user-settings'] }
+)
+
+export async function getUserSettings(userId?: string) {
+  let id = userId
+
+  if (!id) {
+    const session = await auth()
+    id = session?.user?.id
+  }
+
+  if (!id) {
+    return {
+      theme: 'light' as const,
+      cardSizeMode: 'variable' as const
+    }
+  }
+
+  return getCachedUserSettings(id)
+}

memento-note/app/api/admin/embeddings/validate/route.ts

@@ -0,0 +1,101 @@
+import { NextResponse } from 'next/server'
+import prisma from '@/lib/prisma'
+import { auth } from '@/auth'
+import { validateEmbedding } from '@/lib/utils'
+
+/**
+ * Admin endpoint to validate all embeddings in the database
+ * Returns a list of notes with invalid embeddings
+ */
+export async function GET() {
+  try {
+    const session = await auth()
+    if (!session?.user?.id) {
+      return NextResponse.json({ error: 'Unauthorized' }, { status: 401 })
+    }
+
+    // Check if user is admin
+    const user = await prisma.user.findUnique({
+      where: { id: session.user.id },
+      select: { role: true }
+    })
+
+    if (!user || user.role !== 'ADMIN') {
+      return NextResponse.json({ error: 'Forbidden - Admin only' }, { status: 403 })
+    }
+
+    // Fetch all notes with embeddings
+    const allNotes = await prisma.note.findMany({
+      select: {
+        id: true,
+        title: true,
+        noteEmbedding: true
+      }
+    })
+
+    const invalidNotes: Array<{
+      id: string
+      title: string
+      issues: string[]
+    }> = []
+
+    let validCount = 0
+    let missingCount = 0
+    let invalidCount = 0
+
+    for (const note of allNotes) {
+      // Check if embedding is missing
+      if (!note.noteEmbedding?.embedding) {
+        missingCount++
+        invalidNotes.push({
+          id: note.id,
+          title: note.title || 'Untitled',
+          issues: ['Missing embedding']
+        })
+        continue
+      }
+
+      // Validate embedding
+      try {
+        if (!note.noteEmbedding?.embedding) continue
+        const embedding = JSON.parse(note.noteEmbedding.embedding) as number[]
+        const validation = validateEmbedding(embedding)
+
+        if (!validation.valid) {
+          invalidCount++
+          invalidNotes.push({
+            id: note.id,
+            title: note.title || 'Untitled',
+            issues: validation.issues
+          })
+        } else {
+          validCount++
+        }
+      } catch (error) {
+        invalidCount++
+        invalidNotes.push({
+          id: note.id,
+          title: note.title || 'Untitled',
+          issues: [`Failed to parse embedding: ${error}`]
+        })
+      }
+    }
+
+    return NextResponse.json({
+      success: true,
+      summary: {
+        total: allNotes.length,
+        valid: validCount,
+        missing: missingCount,
+        invalid: invalidCount
+      },
+      invalidNotes
+    })
+  } catch (error) {
+    console.error('[EMBEDDING_VALIDATION] Error:', error)
+    return NextResponse.json(
+      { success: false, error: String(error) },
+      { status: 500 }
+    )
+  }
+}

memento-note/app/api/admin/randomize-labels/route.ts

@@ -0,0 +1,31 @@
+import { NextResponse } from 'next/server';
+import prisma from '@/lib/prisma';
+import { LABEL_COLORS } from '@/lib/types';
+
+export const dynamic = 'force-dynamic';
+
+export async function GET() {
+  try {
+    const labels = await prisma.label.findMany();
+    const colors = Object.keys(LABEL_COLORS).filter(c => c !== 'gray'); // Exclude gray to force colors
+    
+    const updates = labels.map((label: any) => {
+      const randomColor = colors[Math.floor(Math.random() * colors.length)];
+      return prisma.label.update({
+        where: { id: label.id },
+        data: { color: randomColor }
+      });
+    });
+
+    await prisma.$transaction(updates);
+
+    return NextResponse.json({
+      success: true,
+      updated: updates.length,
+      message: "All labels have been assigned a random non-gray color."
+    });
+
+  } catch (error) {
+    return NextResponse.json({ error: String(error) }, { status: 500 });
+  }
+}

memento-note/app/api/admin/sync-labels/route.ts

@@ -0,0 +1,56 @@
+import { NextResponse } from 'next/server';
+import prisma from '@/lib/prisma';
+
+export const dynamic = 'force-dynamic';
+
+export async function GET() {
+  try {
+    // 1. Get all notes
+    const notes = await prisma.note.findMany({
+      select: { labels: true }
+    });
+
+    // 2. Extract all unique labels from JSON
+    const uniqueLabels = new Set<string>();
+    notes.forEach((note: any) => {
+      if (note.labels) {
+        try {
+          if (Array.isArray(note.labels)) {
+            (note.labels as string[]).forEach((l: string) => uniqueLabels.add(l));
+          }
+        } catch (e) {
+          // ignore error
+        }
+      }
+    });
+
+    // 3. Get existing labels in DB
+    const existingDbLabels = await prisma.label.findMany();
+    const existingNames = new Set(existingDbLabels.map((l: any) => l.name));
+
+    // 4. Create missing labels
+    const created = [];
+    for (const name of uniqueLabels) {
+      if (!existingNames.has(name)) {
+        const newLabel = await prisma.label.create({
+          data: {
+            name,
+            color: 'gray' // Default color
+          }
+        });
+        created.push(newLabel);
+      }
+    }
+
+    return NextResponse.json({
+      success: true,
+      foundInNotes: uniqueLabels.size,
+      alreadyInDb: existingNames.size,
+      created: created.length,
+      createdLabels: created
+    });
+
+  } catch (error) {
+    return NextResponse.json({ error: String(error) }, { status: 500 });
+  }
+}

memento-note/app/api/ai/auto-labels/route.ts

@@ -0,0 +1,122 @@
+import { NextRequest, NextResponse } from 'next/server'
+import { auth } from '@/auth'
+import { autoLabelCreationService } from '@/lib/ai/services'
+
+/**
+ * POST /api/ai/auto-labels - Suggest new labels for a notebook
+ */
+export async function POST(request: NextRequest) {
+  try {
+    const session = await auth()
+
+    if (!session?.user?.id) {
+      return NextResponse.json(
+        { success: false, error: 'Unauthorized' },
+        { status: 401 }
+      )
+    }
+
+    const body = await request.json()
+    const { notebookId, language = 'en' } = body
+
+    if (!notebookId || typeof notebookId !== 'string') {
+      return NextResponse.json(
+        { success: false, error: 'Missing required field: notebookId' },
+        { status: 400 }
+      )
+    }
+
+    // Check if notebook belongs to user
+    const { prisma } = await import('@/lib/prisma')
+    const notebook = await prisma.notebook.findFirst({
+      where: {
+        id: notebookId,
+        userId: session.user.id,
+      },
+    })
+
+    if (!notebook) {
+      return NextResponse.json(
+        { success: false, error: 'Notebook not found' },
+        { status: 404 }
+      )
+    }
+
+    // Get label suggestions
+    const suggestions = await autoLabelCreationService.suggestLabels(
+      notebookId,
+      session.user.id,
+      language
+    )
+
+    if (!suggestions) {
+      return NextResponse.json({
+        success: true,
+        data: null,
+        message: 'No suggestions available (notebook may have fewer than 15 notes)',
+      })
+    }
+
+    return NextResponse.json({
+      success: true,
+      data: suggestions,
+    })
+  } catch (error) {
+    return NextResponse.json(
+      {
+        success: false,
+        error: error instanceof Error ? error.message : 'Failed to get label suggestions',
+      },
+      { status: 500 }
+    )
+  }
+}
+
+/**
+ * PUT /api/ai/auto-labels - Create suggested labels
+ */
+export async function PUT(request: NextRequest) {
+  try {
+    const session = await auth()
+
+    if (!session?.user?.id) {
+      return NextResponse.json(
+        { success: false, error: 'Unauthorized' },
+        { status: 401 }
+      )
+    }
+
+    const body = await request.json()
+    const { suggestions, selectedLabels } = body
+
+    if (!suggestions || !Array.isArray(selectedLabels)) {
+      return NextResponse.json(
+        { success: false, error: 'Missing required fields: suggestions, selectedLabels' },
+        { status: 400 }
+      )
+    }
+
+    // Create labels
+    const createdCount = await autoLabelCreationService.createLabels(
+      suggestions.notebookId,
+      session.user.id,
+      suggestions,
+      selectedLabels
+    )
+
+    return NextResponse.json({
+      success: true,
+      data: {
+        createdCount,
+      },
+    })
+  } catch (error) {
+    return NextResponse.json(
+      {
+        success: false,
+        error: error instanceof Error ? error.message : 'Failed to create labels',
+      },
+      { status: 500 }
+    )
+  }
+}

memento-note/app/api/ai/batch-organize/route.ts

@@ -0,0 +1,102 @@
+import { NextRequest, NextResponse } from 'next/server'
+import { auth } from '@/auth'
+import { batchOrganizationService } from '@/lib/ai/services'
+
+/**
+ * POST /api/ai/batch-organize - Create organization plan for notes in Inbox
+ */
+export async function POST(request: NextRequest) {
+  try {
+    const session = await auth()
+
+    if (!session?.user?.id) {
+      return NextResponse.json(
+        { success: false, error: 'Unauthorized' },
+        { status: 401 }
+      )
+    }
+
+    // Get language from request headers or body
+    let language = 'en'
+    try {
+      const body = await request.json()
+      if (body.language) {
+        language = body.language
+      }
+    } catch (e) {
+      // If no body or invalid json, check headers
+      const acceptLanguage = request.headers.get('accept-language')
+      if (acceptLanguage) {
+        language = acceptLanguage.split(',')[0].split('-')[0]
+      }
+    }
+
+    // Create organization plan
+    const plan = await batchOrganizationService.createOrganizationPlan(
+      session.user.id,
+      language
+    )
+
+    return NextResponse.json({
+      success: true,
+      data: plan,
+    })
+  } catch (error) {
+    console.error('[batch-organize POST] Error:', error)
+    return NextResponse.json(
+      {
+        success: false,
+        error: error instanceof Error ? error.message : 'Failed to create organization plan',
+      },
+      { status: 500 }
+    )
+  }
+}
+
+/**
+ * PUT /api/ai/batch-organize - Apply organization plan
+ */
+export async function PUT(request: NextRequest) {
+  try {
+    const session = await auth()
+
+    if (!session?.user?.id) {
+      return NextResponse.json(
+        { success: false, error: 'Unauthorized' },
+        { status: 401 }
+      )
+    }
+
+    const body = await request.json()
+    const { plan, selectedNoteIds } = body
+
+    if (!plan || !Array.isArray(selectedNoteIds)) {
+      return NextResponse.json(
+        { success: false, error: 'Missing required fields: plan, selectedNoteIds' },
+        { status: 400 }
+      )
+    }
+
+    // Apply organization plan
+    const movedCount = await batchOrganizationService.applyOrganizationPlan(
+      session.user.id,
+      plan,
+      selectedNoteIds
+    )
+
+    return NextResponse.json({
+      success: true,
+      data: {
+        movedCount,
+      },
+    })
+  } catch (error) {
+    return NextResponse.json(
+      {
+        success: false,
+        error: error instanceof Error ? error.message : 'Failed to apply organization plan',
+      },
+      { status: 500 }
+    )
+  }
+}

memento-note/app/api/ai/config/route.ts

@@ -0,0 +1,26 @@
+import { NextRequest, NextResponse } from 'next/server'
+import { getSystemConfig } from '@/lib/config'
+
+export async function GET(request: NextRequest) {
+  try {
+    const config = await getSystemConfig()
+
+    return NextResponse.json({
+      AI_PROVIDER_TAGS: config.AI_PROVIDER_TAGS || 'not set',
+      AI_MODEL_TAGS: config.AI_MODEL_TAGS || 'not set',
+      AI_PROVIDER_EMBEDDING: config.AI_PROVIDER_EMBEDDING || 'not set',
+      AI_MODEL_EMBEDDING: config.AI_MODEL_EMBEDDING || 'not set',
+      OPENAI_API_KEY: config.OPENAI_API_KEY ? '***configured***' : '',
+      CUSTOM_OPENAI_API_KEY: config.CUSTOM_OPENAI_API_KEY ? '***configured***' : '',
+      CUSTOM_OPENAI_BASE_URL: config.CUSTOM_OPENAI_BASE_URL || '',
+      OLLAMA_BASE_URL: config.OLLAMA_BASE_URL || 'not set'
+    })
+  } catch (error: any) {
+    return NextResponse.json(
+      {
+        error: error.message || 'Failed to fetch config'
+      },
+      { status: 500 }
+    )
+  }
+}

memento-note/app/api/ai/echo/connections/route.ts

@@ -0,0 +1,85 @@
+import { NextRequest, NextResponse } from 'next/server'
+import { auth } from '@/auth'
+import { memoryEchoService } from '@/lib/ai/services/memory-echo.service'
+
+/**
+ * GET /api/ai/echo/connections?noteId={id}&page={page}&limit={limit}
+ * Fetch all connections for a specific note
+ */
+export async function GET(req: NextRequest) {
+  try {
+    const session = await auth()
+
+    if (!session?.user?.id) {
+      return NextResponse.json(
+        { error: 'Unauthorized' },
+        { status: 401 }
+      )
+    }
+
+    // Get query parameters
+    const { searchParams } = new URL(req.url)
+    const noteId = searchParams.get('noteId')
+    const page = parseInt(searchParams.get('page') || '1')
+    const limit = parseInt(searchParams.get('limit') || '10')
+
+    // Validate noteId
+    if (!noteId) {
+      return NextResponse.json(
+        { error: 'noteId parameter is required' },
+        { status: 400 }
+      )
+    }
+
+    // Validate pagination parameters
+    if (page < 1 || limit < 1 || limit > 50) {
+      return NextResponse.json(
+        { error: 'Invalid pagination parameters. page >= 1, limit between 1 and 50' },
+        { status: 400 }
+      )
+    }
+
+    // Get all connections for the note
+    const allConnections = await memoryEchoService.getConnectionsForNote(noteId, session.user.id)
+
+    // Calculate pagination
+    const total = allConnections.length
+    const startIndex = (page - 1) * limit
+    const endIndex = startIndex + limit
+    const paginatedConnections = allConnections.slice(startIndex, endIndex)
+
+    // Format connections for response
+    const connections = paginatedConnections.map(conn => {
+      // Determine which note is the "other" note (not the target note)
+      const isNote1Target = conn.note1.id === noteId
+      const otherNote = isNote1Target ? conn.note2 : conn.note1
+
+      return {
+        noteId: otherNote.id,
+        title: otherNote.title,
+        content: otherNote.content,
+        createdAt: otherNote.createdAt,
+        similarity: conn.similarityScore,
+        daysApart: conn.daysApart
+      }
+    })
+
+    return NextResponse.json({
+      connections,
+      pagination: {
+        total,
+        page,
+        limit,
+        totalPages: Math.ceil(total / limit),
+        hasNext: endIndex < total,
+        hasPrev: page > 1
+      }
+    })
+
+  } catch (error) {
+    return NextResponse.json(
+      { error: 'Failed to fetch connections' },
+      { status: 500 }
+    )
+  }
+}

memento-note/app/api/ai/echo/dismiss/route.ts

@@ -0,0 +1,60 @@
+import { NextRequest, NextResponse } from 'next/server'
+import { auth } from '@/auth'
+import { prisma } from '@/lib/prisma'
+
+/**
+ * POST /api/ai/echo/dismiss
+ * Dismiss a connection for a specific note
+ * Body: { noteId, connectedNoteId }
+ */
+export async function POST(req: NextRequest) {
+  try {
+    const session = await auth()
+
+    if (!session?.user?.id) {
+      return NextResponse.json(
+        { error: 'Unauthorized' },
+        { status: 401 }
+      )
+    }
+
+    const body = await req.json()
+    const { noteId, connectedNoteId } = body
+
+    if (!noteId || !connectedNoteId) {
+      return NextResponse.json(
+        { error: 'noteId and connectedNoteId are required' },
+        { status: 400 }
+      )
+    }
+
+    // Find and mark matching insights as dismissed
+    // We need to find insights where (note1Id = noteId AND note2Id = connectedNoteId) OR (note1Id = connectedNoteId AND note2Id = noteId)
+    await prisma.memoryEchoInsight.updateMany({
+      where: {
+        userId: session.user.id,
+        OR: [
+          {
+            note1Id: noteId,
+            note2Id: connectedNoteId
+          },
+          {
+            note1Id: connectedNoteId,
+            note2Id: noteId
+          }
+        ]
+      },
+      data: {
+        dismissed: true
+      }
+    })
+
+    return NextResponse.json({ success: true })
+
+  } catch (error) {
+    return NextResponse.json(
+      { error: 'Failed to dismiss connection' },
+      { status: 500 }
+    )
+  }
+}

memento-note/app/api/ai/echo/fusion/route.ts

@@ -0,0 +1,108 @@
+import { NextRequest, NextResponse } from 'next/server'
+import { auth } from '@/auth'
+import { getChatProvider } from '@/lib/ai/factory'
+import { getSystemConfig } from '@/lib/config'
+import prisma from '@/lib/prisma'
+
+/**
+ * POST /api/ai/echo/fusion
+ * Generate intelligent fusion of multiple notes
+ */
+export async function POST(req: NextRequest) {
+  try {
+    const session = await auth()
+
+    if (!session?.user?.id) {
+      return NextResponse.json(
+        { error: 'Unauthorized' },
+        { status: 401 }
+      )
+    }
+
+    const body = await req.json()
+    const { noteIds, prompt } = body
+
+    if (!noteIds || !Array.isArray(noteIds) || noteIds.length < 2) {
+      return NextResponse.json(
+        { error: 'At least 2 note IDs are required' },
+        { status: 400 }
+      )
+    }
+
+    // Fetch the notes
+    const notes = await prisma.note.findMany({
+      where: {
+        id: { in: noteIds },
+        userId: session.user.id
+      },
+      select: {
+        id: true,
+        title: true,
+        content: true,
+        createdAt: true
+      }
+    })
+
+    if (notes.length !== noteIds.length) {
+      return NextResponse.json(
+        { error: 'Some notes not found or access denied' },
+        { status: 404 }
+      )
+    }
+
+    // Get AI provider
+    const config = await getSystemConfig()
+    const provider = getChatProvider(config)
+
+    // Build fusion prompt
+    const notesDescriptions = notes.map((note, index) => {
+      return `Note ${index + 1}: "${note.title || 'Untitled'}"
+${note.content}`
+    }).join('\n\n')
+
+    const fusionPrompt = `You are an expert at synthesizing and merging information from multiple sources.
+
+TASK: Create a unified, well-structured note by intelligently combining the following notes.
+
+${prompt ? `ADDITIONAL INSTRUCTIONS: ${prompt}\n` : ''}
+
+NOTES TO MERGE:
+${notesDescriptions}
+
+REQUIREMENTS:
+1. Create a clear, descriptive title that captures the essence of all notes
+2. Merge and consolidate related information
+3. Remove duplicates while preserving unique details from each note
+4. Organize the content logically (use headers, bullet points, etc.)
+5. Maintain the important details and context from all notes
+6. Keep the tone and style consistent
+7. Use markdown formatting for better readability
+
+Output format:
+# [Fused Title]
+
+[Merged and organized content...]
+
+Begin:`
+
+    try {
+      const fusedContent = await provider.generateText(fusionPrompt)
+
+      return NextResponse.json({
+        fusedNote: fusedContent,
+        notesCount: notes.length
+      })
+    } catch (error) {
+      return NextResponse.json(
+        { error: 'Failed to generate fusion' },
+        { status: 500 }
+      )
+    }
+
+  } catch (error) {
+    return NextResponse.json(
+      { error: 'Failed to process fusion request' },
+      { status: 500 }
+    )
+  }
+}

memento-note/app/api/ai/echo/route.ts

@@ -0,0 +1,92 @@
+import { NextRequest, NextResponse } from 'next/server'
+import { auth } from '@/auth'
+import { memoryEchoService } from '@/lib/ai/services/memory-echo.service'
+
+/**
+ * GET /api/ai/echo
+ * Fetch next Memory Echo insight for current user
+ */
+export async function GET(req: NextRequest) {
+  try {
+    const session = await auth()
+
+    if (!session?.user?.id) {
+      return NextResponse.json(
+        { error: 'Unauthorized' },
+        { status: 401 }
+      )
+    }
+
+    // Get next insight (respects frequency limits)
+    const insight = await memoryEchoService.getNextInsight(session.user.id)
+
+    if (!insight) {
+      return NextResponse.json(
+        {
+          insight: null,
+          message: 'No new insights available at the moment. Memory Echo will notify you when we discover connections between your notes.'
+        }
+      )
+    }
+
+    return NextResponse.json({ insight })
+
+  } catch (error) {
+    return NextResponse.json(
+      { error: 'Failed to fetch Memory Echo insight' },
+      { status: 500 }
+    )
+  }
+}
+
+/**
+ * POST /api/ai/echo
+ * Submit feedback or mark as viewed
+ */
+export async function POST(req: NextRequest) {
+  try {
+    const session = await auth()
+
+    if (!session?.user?.id) {
+      return NextResponse.json(
+        { error: 'Unauthorized' },
+        { status: 401 }
+      )
+    }
+
+    const body = await req.json()
+    const { action, insightId, feedback } = body
+
+    if (action === 'view') {
+      // Mark insight as viewed
+      await memoryEchoService.markAsViewed(insightId)
+
+      return NextResponse.json({ success: true })
+
+    } else if (action === 'feedback') {
+      // Submit feedback (thumbs_up or thumbs_down)
+      if (!feedback || !['thumbs_up', 'thumbs_down'].includes(feedback)) {
+        return NextResponse.json(
+          { error: 'Invalid feedback. Must be thumbs_up or thumbs_down' },
+          { status: 400 }
+        )
+      }
+
+      await memoryEchoService.submitFeedback(insightId, feedback)
+
+      return NextResponse.json({ success: true })
+
+    } else {
+      return NextResponse.json(
+        { error: 'Invalid action. Must be "view" or "feedback"' },
+        { status: 400 }
+      )
+    }
+
+  } catch (error) {
+    return NextResponse.json(
+      { error: 'Failed to process request' },
+      { status: 500 }
+    )
+  }
+}

memento-note/app/api/ai/models/route.ts

@@ -0,0 +1,96 @@
+import { NextRequest, NextResponse } from 'next/server'
+import { getSystemConfig } from '@/lib/config'
+
+// Modèles populaires pour chaque provider (2025)
+const PROVIDER_MODELS = {
+  ollama: {
+    tags: [
+      'llama3:latest',
+      'llama3.2:latest',
+      'granite4:latest',
+      'mistral:latest',
+      'mixtral:latest',
+      'phi3:latest',
+      'gemma2:latest',
+      'qwen2:latest'
+    ],
+    embeddings: [
+      'embeddinggemma:latest',
+      'mxbai-embed-large:latest',
+      'nomic-embed-text:latest'
+    ]
+  },
+  openai: {
+    tags: [
+      'gpt-4o',
+      'gpt-4o-mini',
+      'gpt-4-turbo',
+      'gpt-4',
+      'gpt-3.5-turbo'
+    ],
+    embeddings: [
+      'text-embedding-3-small',
+      'text-embedding-3-large',
+      'text-embedding-ada-002'
+    ]
+  },
+  custom: {
+    tags: [], // Will be loaded dynamically
+    embeddings: [] // Will be loaded dynamically
+  }
+}
+
+export async function GET(request: NextRequest) {
+  try {
+    const config = await getSystemConfig()
+    const provider = (config.AI_PROVIDER || 'ollama').toLowerCase()
+
+    let models = PROVIDER_MODELS[provider as keyof typeof PROVIDER_MODELS] || { tags: [], embeddings: [] }
+
+    // Pour Ollama, essayer de récupérer la liste réelle depuis l'API locale
+    if (provider === 'ollama') {
+      try {
+        const ollamaBaseUrl = config.OLLAMA_BASE_URL || process.env.OLLAMA_BASE_URL || 'http://localhost:11434'
+        const response = await fetch(`${ollamaBaseUrl}/api/tags`, {
+          method: 'GET',
+          headers: { 'Content-Type': 'application/json' }
+        })
+
+        if (response.ok) {
+          const data = await response.json()
+          const allModels = data.models || []
+
+          // Séparer les modèles de tags et d'embeddings
+          const tagModels = allModels
+            .filter((m: any) => !m.name.includes('embed') && !m.name.includes('Embedding'))
+            .map((m: any) => m.name)
+            .slice(0, 20) // Limiter à 20 modèles
+
+          const embeddingModels = allModels
+            .filter((m: any) => m.name.includes('embed') || m.name.includes('Embedding'))
+            .map((m: any) => m.name)
+
+          models = {
+            tags: tagModels.length > 0 ? tagModels : models.tags,
+            embeddings: embeddingModels.length > 0 ? embeddingModels : models.embeddings
+          }
+        }
+      } catch (error) {
+        // Garder les modèles par défaut
+      }
+    }
+
+    return NextResponse.json({
+      provider,
+      models: models || { tags: [], embeddings: [] }
+    })
+  } catch (error: any) {
+    return NextResponse.json(
+      {
+        error: error.message || 'Failed to fetch models',
+        models: { tags: [], embeddings: [] }
+      },
+      { status: 500 }
+    )
+  }
+}

memento-note/app/api/ai/notebook-summary/route.ts

@@ -0,0 +1,73 @@
+import { NextRequest, NextResponse } from 'next/server'
+import { auth } from '@/auth'
+import { notebookSummaryService } from '@/lib/ai/services'
+
+/**
+ * POST /api/ai/notebook-summary - Generate summary for a notebook
+ */
+export async function POST(request: NextRequest) {
+  try {
+    const session = await auth()
+
+    if (!session?.user?.id) {
+      return NextResponse.json(
+        { success: false, error: 'Unauthorized' },
+        { status: 401 }
+      )
+    }
+
+    const body = await request.json()
+    const { notebookId, language = 'en' } = body
+
+    if (!notebookId || typeof notebookId !== 'string') {
+      return NextResponse.json(
+        { success: false, error: 'Missing required field: notebookId' },
+        { status: 400 }
+      )
+    }
+
+    // Check if notebook belongs to user
+    const { prisma } = await import('@/lib/prisma')
+    const notebook = await prisma.notebook.findFirst({
+      where: {
+        id: notebookId,
+        userId: session.user.id,
+      },
+    })
+
+    if (!notebook) {
+      return NextResponse.json(
+        { success: false, error: 'Notebook not found' },
+        { status: 404 }
+      )
+    }
+
+    // Generate summary
+    const summary = await notebookSummaryService.generateSummary(
+      notebookId,
+      session.user.id,
+      language
+    )
+
+    if (!summary) {
+      return NextResponse.json({
+        success: true,
+        data: null,
+        message: 'No summary available (notebook may be empty)',
+      })
+    }
+
+    return NextResponse.json({
+      success: true,
+      data: summary,
+    })
+  } catch (error) {
+    return NextResponse.json(
+      {
+        success: false,
+        error: error instanceof Error ? error.message : 'Failed to generate notebook summary',
+      },
+      { status: 500 }
+    )
+  }
+}

memento-note/app/api/ai/reformulate/route.ts

@@ -0,0 +1,57 @@
+import { NextRequest, NextResponse } from 'next/server'
+import { auth } from '@/auth'
+import { paragraphRefactorService } from '@/lib/ai/services/paragraph-refactor.service'
+
+export async function POST(request: NextRequest) {
+  try {
+    const session = await auth()
+
+    if (!session?.user?.id) {
+      return NextResponse.json({ error: 'Unauthorized' }, { status: 401 })
+    }
+
+    const { text, option } = await request.json()
+
+    // Validation
+    if (!text || typeof text !== 'string') {
+      return NextResponse.json({ error: 'Text is required' }, { status: 400 })
+    }
+
+    // Map option to refactor mode
+    const modeMap: Record<string, 'clarify' | 'shorten' | 'improveStyle'> = {
+      'clarify': 'clarify',
+      'shorten': 'shorten',
+      'improve': 'improveStyle'
+    }
+
+    const mode = modeMap[option]
+    if (!mode) {
+      return NextResponse.json(
+        { error: 'Invalid option. Use: clarify, shorten, or improve' },
+        { status: 400 }
+      )
+    }
+
+    // Validate word count
+    const validation = paragraphRefactorService.validateWordCount(text)
+    if (!validation.valid) {
+      return NextResponse.json({ error: validation.error }, { status: 400 })
+    }
+
+    // Use the ParagraphRefactorService
+    const result = await paragraphRefactorService.refactor(text, mode)
+
+    return NextResponse.json({
+      originalText: result.original,
+      reformulatedText: result.refactored,
+      option: option,
+      language: result.language,
+      wordCountChange: result.wordCountChange
+    })
+  } catch (error: any) {
+    return NextResponse.json(
+      { error: error.message || 'Failed to reformulate text' },
+      { status: 500 }
+    )
+  }
+}

memento-note/app/api/ai/suggest-notebook/route.ts

@@ -0,0 +1,46 @@
+import { NextRequest, NextResponse } from 'next/server'
+import { auth } from '@/auth'
+import { notebookSuggestionService } from '@/lib/ai/services/notebook-suggestion.service'
+
+export async function POST(req: NextRequest) {
+  try {
+    const session = await auth()
+    if (!session?.user?.id) {
+      return NextResponse.json({ error: 'Unauthorized' }, { status: 401 })
+    }
+
+    const body = await req.json()
+    const { noteContent, language = 'en' } = body
+
+    if (!noteContent || typeof noteContent !== 'string') {
+      return NextResponse.json({ error: 'noteContent is required' }, { status: 400 })
+    }
+
+    // Minimum content length for suggestion (20 words as per specs)
+    const wordCount = noteContent.trim().split(/\s+/).length
+    if (wordCount < 20) {
+      return NextResponse.json({
+        suggestion: null,
+        reason: 'content_too_short',
+        message: 'Note content too short for meaningful suggestion'
+      })
+    }
+
+    // Get suggestion from AI service
+    const suggestedNotebook = await notebookSuggestionService.suggestNotebook(
+      noteContent,
+      session.user.id,
+      language
+    )
+
+    return NextResponse.json({
+      suggestion: suggestedNotebook,
+      confidence: suggestedNotebook ? 0.8 : 0 // Placeholder confidence score
+    })
+  } catch (error) {
+    return NextResponse.json(
+      { error: 'Failed to generate suggestion' },
+      { status: 500 }
+    )
+  }
+}

memento-note/app/api/ai/tags/route.ts

@@ -0,0 +1,62 @@
+import { NextRequest, NextResponse } from 'next/server';
+import { auth } from '@/auth';
+import { contextualAutoTagService } from '@/lib/ai/services/contextual-auto-tag.service';
+import { getAIProvider } from '@/lib/ai/factory';
+import { getSystemConfig } from '@/lib/config';
+import { z } from 'zod';
+
+const requestSchema = z.object({
+  content: z.string().min(1, "Le contenu ne peut pas être vide"),
+  notebookId: z.string().optional(),
+  language: z.string().default('en'),
+});
+
+export async function POST(req: NextRequest) {
+  try {
+    const session = await auth();
+    if (!session?.user?.id) {
+      return NextResponse.json({ error: 'Unauthorized' }, { status: 401 });
+    }
+
+    const body = await req.json();
+    const { content, notebookId, language } = requestSchema.parse(body);
+
+    // If notebookId is provided, use contextual suggestions (IA2)
+    if (notebookId) {
+      const suggestions = await contextualAutoTagService.suggestLabels(
+        content,
+        notebookId,
+        session.user.id,
+        language
+      );
+
+      // Convert label → tag to match TagSuggestion interface
+      const convertedTags = suggestions.map(s => ({
+        tag: s.label, // Convert label to tag
+        confidence: s.confidence,
+        // Keep additional properties for client-side use
+        ...(s.reasoning && { reasoning: s.reasoning }),
+        ...(s.isNewLabel !== undefined && { isNewLabel: s.isNewLabel })
+      }));
+
+      return NextResponse.json({ tags: convertedTags });
+    }
+
+    // Otherwise, use legacy auto-tagging (generates new tags)
+    const config = await getSystemConfig();
+    const provider = getAIProvider(config);
+    const tags = await provider.generateTags(content, language);
+
+    return NextResponse.json({ tags });
+  } catch (error: any) {
+
+    if (error instanceof z.ZodError) {
+      return NextResponse.json({ error: error.issues }, { status: 400 });
+    }
+
+    return NextResponse.json(
+      { error: error.message || 'Erreur lors de la génération des tags' },
+      { status: 500 }
+    );
+  }
+}

memento-note/app/api/ai/test-embeddings/route.ts

@@ -0,0 +1,90 @@
+import { NextRequest, NextResponse } from 'next/server'
+import { getEmbeddingsProvider } from '@/lib/ai/factory'
+import { getSystemConfig } from '@/lib/config'
+
+function getProviderDetails(config: Record<string, string>, providerType: string) {
+  const provider = providerType.toLowerCase()
+
+  switch (provider) {
+    case 'ollama':
+      return {
+        provider: 'Ollama',
+        baseUrl: config.OLLAMA_BASE_URL || 'http://localhost:11434',
+        model: config.AI_MODEL_EMBEDDING || 'embeddinggemma:latest'
+      }
+    case 'openai':
+      return {
+        provider: 'OpenAI',
+        baseUrl: 'https://api.openai.com/v1',
+        model: config.AI_MODEL_EMBEDDING || 'text-embedding-3-small'
+      }
+    case 'custom':
+      return {
+        provider: 'Custom OpenAI',
+        baseUrl: config.CUSTOM_OPENAI_BASE_URL || 'Not configured',
+        model: config.AI_MODEL_EMBEDDING || 'text-embedding-3-small'
+      }
+    default:
+      return {
+        provider: provider,
+        baseUrl: 'unknown',
+        model: config.AI_MODEL_EMBEDDING || 'unknown'
+      }
+  }
+}
+
+export async function POST(request: NextRequest) {
+  try {
+    const config = await getSystemConfig()
+    const provider = getEmbeddingsProvider(config)
+
+    const testText = 'test'
+    const startTime = Date.now()
+    const embeddings = await provider.getEmbeddings(testText)
+    const endTime = Date.now()
+
+    if (!embeddings || embeddings.length === 0) {
+      const providerType = config.AI_PROVIDER_EMBEDDING || 'ollama'
+      const details = getProviderDetails(config, providerType)
+      return NextResponse.json(
+        {
+          success: false,
+          error: 'No embeddings returned',
+          provider: providerType,
+          model: config.AI_MODEL_EMBEDDING || 'embeddinggemma:latest',
+          details
+        },
+        { status: 500 }
+      )
+    }
+
+    const providerType = config.AI_PROVIDER_EMBEDDING || 'ollama'
+    const details = getProviderDetails(config, providerType)
+
+    return NextResponse.json({
+      success: true,
+      provider: providerType,
+      model: config.AI_MODEL_EMBEDDING || 'embeddinggemma:latest',
+      embeddingLength: embeddings.length,
+      firstValues: embeddings.slice(0, 5),
+      responseTime: endTime - startTime,
+      details
+    })
+  } catch (error: any) {
+    const config = await getSystemConfig()
+    const providerType = config.AI_PROVIDER_EMBEDDING || 'ollama'
+    const details = getProviderDetails(config, providerType)
+
+    return NextResponse.json(
+      {
+        success: false,
+        error: error.message || 'Unknown error',
+        provider: providerType,
+        model: config.AI_MODEL_EMBEDDING || 'embeddinggemma:latest',
+        details,
+        stack: process.env.NODE_ENV === 'development' ? error.stack : undefined
+      },
+      { status: 500 }
+    )
+  }
+}

memento-note/app/api/ai/test-tags/route.ts

@@ -0,0 +1,49 @@
+import { NextRequest, NextResponse } from 'next/server'
+import { getTagsProvider } from '@/lib/ai/factory'
+import { getSystemConfig } from '@/lib/config'
+
+export async function POST(request: NextRequest) {
+  try {
+    const config = await getSystemConfig()
+    const provider = getTagsProvider(config)
+
+    const testContent = "This is a test note about artificial intelligence and machine learning. It contains keywords like AI, ML, neural networks, and deep learning."
+
+    const startTime = Date.now()
+    const tags = await provider.generateTags(testContent)
+    const endTime = Date.now()
+
+    if (!tags || tags.length === 0) {
+      return NextResponse.json(
+        {
+          success: false,
+          error: 'No tags generated',
+          provider: config.AI_PROVIDER_TAGS || 'ollama',
+          model: config.AI_MODEL_TAGS || 'granite4:latest'
+        },
+        { status: 500 }
+      )
+    }
+
+    return NextResponse.json({
+      success: true,
+      provider: config.AI_PROVIDER_TAGS || 'ollama',
+      model: config.AI_MODEL_TAGS || 'granite4:latest',
+      tags: tags,
+      responseTime: endTime - startTime
+    })
+  } catch (error: any) {
+    const config = await getSystemConfig()
+
+    return NextResponse.json(
+      {
+        success: false,
+        error: error.message || 'Unknown error',
+        provider: config.AI_PROVIDER_TAGS || 'ollama',
+        model: config.AI_MODEL_TAGS || 'granite4:latest',
+        stack: process.env.NODE_ENV === 'development' ? error.stack : undefined
+      },
+      { status: 500 }
+    )
+  }
+}

memento-note/app/api/ai/test/route.ts

@@ -0,0 +1,89 @@
+import { NextRequest, NextResponse } from 'next/server'
+import { getTagsProvider, getEmbeddingsProvider } from '@/lib/ai/factory'
+import { getSystemConfig } from '@/lib/config'
+
+function getProviderDetails(config: Record<string, string>, providerType: string) {
+  const provider = providerType.toLowerCase()
+
+  switch (provider) {
+    case 'ollama':
+      return {
+        provider: 'Ollama',
+        baseUrl: config.OLLAMA_BASE_URL || process.env.OLLAMA_BASE_URL || 'http://localhost:11434',
+        model: config.AI_MODEL_EMBEDDING || 'embeddinggemma:latest'
+      }
+    case 'openai':
+      return {
+        provider: 'OpenAI',
+        baseUrl: 'https://api.openai.com/v1',
+        model: config.AI_MODEL_EMBEDDING || 'text-embedding-3-small'
+      }
+    case 'custom':
+      return {
+        provider: 'Custom OpenAI',
+        baseUrl: config.CUSTOM_OPENAI_BASE_URL || process.env.CUSTOM_OPENAI_BASE_URL || 'Not configured',
+        model: config.AI_MODEL_EMBEDDING || 'text-embedding-3-small'
+      }
+    default:
+      return {
+        provider: provider,
+        baseUrl: 'unknown',
+        model: config.AI_MODEL_EMBEDDING || 'unknown'
+      }
+  }
+}
+
+export async function GET(request: NextRequest) {
+  try {
+    const config = await getSystemConfig()
+    const tagsProvider = getTagsProvider(config)
+    const embeddingsProvider = getEmbeddingsProvider(config)
+
+    const testText = 'test'
+
+    // Test embeddings provider
+    const embeddings = await embeddingsProvider.getEmbeddings(testText)
+
+    if (!embeddings || embeddings.length === 0) {
+      const providerType = config.AI_PROVIDER_EMBEDDING || 'ollama'
+      const details = getProviderDetails(config, providerType)
+      return NextResponse.json(
+        {
+          success: false,
+          tagsProvider: config.AI_PROVIDER_TAGS || 'ollama',
+          embeddingsProvider: providerType,
+          error: 'No embeddings returned',
+          details
+        },
+        { status: 500 }
+      )
+    }
+
+    const tagsProviderType = config.AI_PROVIDER_TAGS || 'ollama'
+    const embeddingsProviderType = config.AI_PROVIDER_EMBEDDING || 'ollama'
+    const details = getProviderDetails(config, embeddingsProviderType)
+
+    return NextResponse.json({
+      success: true,
+      tagsProvider: tagsProviderType,
+      embeddingsProvider: embeddingsProviderType,
+      embeddingLength: embeddings.length,
+      firstValues: embeddings.slice(0, 5),
+      details
+    })
+  } catch (error: any) {
+    const config = await getSystemConfig()
+    const providerType = config.AI_PROVIDER_EMBEDDING || 'ollama'
+    const details = getProviderDetails(config, providerType)
+
+    return NextResponse.json(
+      {
+        success: false,
+        error: error.message || 'Unknown error',
+        stack: process.env.NODE_ENV === 'development' ? error.stack : undefined,
+        details
+      },
+      { status: 500 }
+    )
+  }
+}

memento-note/app/api/ai/title-suggestions/route.ts

@@ -0,0 +1,107 @@
+import { NextRequest, NextResponse } from 'next/server'
+import { getAIProvider } from '@/lib/ai/factory'
+import { getSystemConfig } from '@/lib/config'
+import { z } from 'zod'
+
+const requestSchema = z.object({
+  content: z.string().min(1, "Le contenu ne peut pas être vide"),
+})
+
+export async function POST(req: NextRequest) {
+  try {
+    const body = await req.json()
+    const { content } = requestSchema.parse(body)
+
+    // Vérifier qu'il y a au moins 10 mots
+    const wordCount = content.split(/\s+/).length
+
+    if (wordCount < 10) {
+      return NextResponse.json(
+        { error: 'Le contenu doit avoir au moins 10 mots' },
+        { status: 400 }
+      )
+    }
+
+    const config = await getSystemConfig()
+    const provider = getAIProvider(config)
+
+    // Détecter la langue du contenu (simple détection basée sur les caractères et mots)
+    const hasNonLatinChars = /[\u0400-\u04FF\u0600-\u06FF\u4E00-\u9FFF\u0E00-\u0E7F]/.test(content)
+    const isPersian = /[\u0600-\u06FF]/.test(content)
+    const isChinese = /[\u4E00-\u9FFF]/.test(content)
+    const isRussian = /[\u0400-\u04FF]/.test(content)
+    const isArabic = /[\u0600-\u06FF]/.test(content)
+    
+    // Détection du français par des mots et caractères caractéristiques
+    const frenchWords = /\b(le|la|les|un|une|des|et|ou|mais|donc|pour|dans|sur|avec|sans|très|plus|moins|tout|tous|toute|toutes|ce|cette|ces|mon|ma|mes|ton|ta|tes|son|sa|ses|notre|nos|votre|vos|leur|leurs|je|tu|il|elle|nous|vous|ils|elles|est|sont|été|être|avoir|faire|aller|venir|voir|savoir|pouvoir|vouloir|falloir|comme|que|qui|dont|où|quand|pourquoi|comment|quel|quelle|quels|quelles)\b/i
+    const frenchAccents = /[éèêàâôûùïüç]/i
+    const isFrench = frenchWords.test(content) || frenchAccents.test(content)
+
+    // Déterminer la langue du prompt système
+    let promptLanguage = 'en'
+    let responseLanguage = 'English'
+
+    if (isFrench) {
+      promptLanguage = 'fr'  // Français
+      responseLanguage = 'French'
+    } else if (isPersian) {
+      promptLanguage = 'fa'  // Persan
+      responseLanguage = 'Persian'
+    } else if (isChinese) {
+      promptLanguage = 'zh'  // Chinois
+      responseLanguage = 'Chinese'
+    } else if (isRussian) {
+      promptLanguage = 'ru'  // Russe
+      responseLanguage = 'Russian'
+    } else if (isArabic) {
+      promptLanguage = 'ar'  // Arabe
+      responseLanguage = 'Arabic'
+    }
+
+    // Générer des titres appropriés basés sur le contenu
+    const titlePrompt = promptLanguage === 'en'
+      ? `You are a title generator. Generate 3 concise, descriptive titles for the following content.
+
+IMPORTANT INSTRUCTIONS:
+- Use ONLY the content provided below between the CONTENT_START and CONTENT_END markers
+- Do NOT use any external knowledge or training data
+- Focus on the main topics and themes in THIS SPECIFIC content
+- Be specific to what is actually discussed
+
+CONTENT_START: ${content.substring(0, 500)} CONTENT_END
+
+Respond ONLY with a JSON array: [{"title": "title1", "confidence": 0.95}, {"title": "title2", "confidence": 0.85}, {"title": "title3", "confidence": 0.75}]`
+      : `Tu es un générateur de titres. Génère 3 titres concis et descriptifs pour le contenu suivant en ${responseLanguage}.
+
+INSTRUCTIONS IMPORTANTES :
+- Utilise SEULEMENT le contenu fourni entre les marqueurs CONTENT_START et CONTENT_END
+- N'utilise AUCUNE connaissance externe ou données d'entraînement
+- Concentre-toi sur les sujets principaux et thèmes de CE CONTENU SPÉCIFIQUE
+- Sois spécifique à ce qui est réellement discuté
+
+CONTENT_START: ${content.substring(0, 500)} CONTENT_END
+
+Réponds SEULEMENT avec un tableau JSON: [{"title": "titre1", "confidence": 0.95}, {"title": "titre2", "confidence": 0.85}, {"title": "titre3", "confidence": 0.75}]`
+
+    const titles = await provider.generateTitles(titlePrompt)
+
+    // Créer les suggestions
+    const suggestions = titles.map((t: any) => ({
+      title: t.title,
+      confidence: Math.round(t.confidence * 100),
+      reasoning: `Basé sur le contenu`
+    }))
+
+    return NextResponse.json({ suggestions })
+  } catch (error: any) {
+
+    if (error instanceof z.ZodError) {
+      return NextResponse.json({ error: error.issues }, { status: 400 })
+    }
+
+    return NextResponse.json(
+      { error: error.message || 'Erreur lors de la génération des titres' },
+      { status: 500 }
+    )
+  }
+}

memento-note/app/api/ai/transform-markdown/route.ts

@@ -0,0 +1,90 @@
+import { NextRequest, NextResponse } from 'next/server'
+import { auth } from '@/auth'
+import { getAIProvider } from '@/lib/ai/factory'
+import { getSystemConfig } from '@/lib/config'
+
+export async function POST(request: NextRequest) {
+  try {
+    const session = await auth()
+
+    if (!session?.user?.id) {
+      return NextResponse.json({ error: 'Unauthorized' }, { status: 401 })
+    }
+
+    const { text } = await request.json()
+
+    // Validation
+    if (!text || typeof text !== 'string') {
+      return NextResponse.json({ error: 'Text is required' }, { status: 400 })
+    }
+
+    // Validate word count
+    const wordCount = text.split(/\s+/).length
+    if (wordCount < 10) {
+      return NextResponse.json(
+        { error: 'Text must have at least 10 words to transform' },
+        { status: 400 }
+      )
+    }
+
+    if (wordCount > 500) {
+      return NextResponse.json(
+        { error: 'Text must have maximum 500 words to transform' },
+        { status: 400 }
+      )
+    }
+
+    const config = await getSystemConfig()
+    const provider = getAIProvider(config)
+
+    // Detect language from text
+    const hasFrench = /[àâäéèêëïîôùûüÿç]/i.test(text)
+    const responseLanguage = hasFrench ? 'French' : 'English'
+
+    // Build prompt to transform text to Markdown
+    const prompt = hasFrench
+      ? `Tu es un expert en Markdown. Transforme ce texte ${responseLanguage} en Markdown bien formaté.
+
+IMPORTANT :
+- Ajoute des titres avec ## pour les sections principales
+- Utilise des listes à puces (-) ou numérotées (1.) quand approprié
+- Ajoute de l'emphase (gras **texte**, italique *texte*) pour les mots clés
+- Utilise des blocs de code pour le code ou les commandes
+- Présente l'information de manière claire et structurée
+- GARDE le même sens et le contenu, seul le format change
+
+Texte à transformer :
+${text}
+
+Réponds SEULEMENT avec le texte transformé en Markdown, sans explications.`
+      : `You are a Markdown expert. Transform this ${responseLanguage} text into well-formatted Markdown.
+
+IMPORTANT:
+- Add headings with ## for main sections
+- Use bullet lists (-) or numbered lists (1.) when appropriate
+- Add emphasis (bold **text**, italic *text*) for key terms
+- Use code blocks for code or commands
+- Present information clearly and structured
+- KEEP the same meaning and content, only change the format
+
+Text to transform:
+${text}
+
+Respond ONLY with the transformed Markdown text, no explanations.`
+
+    
+    const transformedText = await provider.generateText(prompt)
+
+    
+    return NextResponse.json({
+      originalText: text,
+      transformedText: transformedText,
+      language: responseLanguage
+    })
+  } catch (error: any) {
+    return NextResponse.json(
+      { error: error.message || 'Failed to transform text to Markdown' },
+      { status: 500 }
+    )
+  }
+}

memento-note/app/api/ai/translate/route.ts

@@ -0,0 +1,30 @@
+import { NextRequest, NextResponse } from 'next/server'
+import { auth } from '@/auth'
+import { getTagsProvider } from '@/lib/ai/factory'
+import { getSystemConfig } from '@/lib/config'
+
+export async function POST(request: NextRequest) {
+  try {
+    const session = await auth()
+    if (!session?.user?.id) {
+      return NextResponse.json({ error: 'Unauthorized' }, { status: 401 })
+    }
+
+    const { text, targetLanguage } = await request.json()
+
+    if (!text || !targetLanguage) {
+      return NextResponse.json({ error: 'text and targetLanguage are required' }, { status: 400 })
+    }
+
+    const config = await getSystemConfig()
+    const provider = getTagsProvider(config)
+
+    const prompt = `Translate the following text to ${targetLanguage}. Return ONLY the translated text, no explanation, no preamble, no quotes:\n\n${text}`
+
+    const translatedText = await provider.generateText(prompt)
+
+    return NextResponse.json({ translatedText: translatedText.trim() })
+  } catch (error: any) {
+    return NextResponse.json({ error: error.message || 'Translation failed' }, { status: 500 })
+  }
+}

memento-note/app/api/auth/[...nextauth]/route.ts

@@ -0,0 +1,2 @@
+import { handlers } from "@/auth"
+export const { GET, POST } = handlers

memento-note/app/api/canvas/route.ts

@@ -0,0 +1,33 @@
+import { NextResponse } from 'next/server'
+import { prisma } from '@/lib/prisma'
+import { auth } from '@/auth'
+import { revalidatePath } from 'next/cache'
+
+export async function POST(req: Request) {
+  try {
+    const session = await auth()
+    if (!session?.user?.id) return NextResponse.json({ error: 'Unauthorized' }, { status: 401 })
+
+    const body = await req.json()
+    const { id, name, data } = body
+
+    if (id) {
+      const canvas = await prisma.canvas.update({
+        where: { id, userId: session.user.id },
+        data: { name, data }
+      })
+      return NextResponse.json({ success: true, canvas })
+    } else {
+      const canvas = await prisma.canvas.create({
+        data: {
+          name,
+          data,
+          userId: session.user.id
+        }
+      })
+      return NextResponse.json({ success: true, canvas })
+    }
+  } catch (error) {
+    return NextResponse.json({ error: 'Internal Server Error' }, { status: 500 })
+  }
+}

memento-note/app/api/chat/route.ts

@@ -0,0 +1,380 @@
+import { streamText, UIMessage } from 'ai'
+import { getChatProvider } from '@/lib/ai/factory'
+import { getSystemConfig } from '@/lib/config'
+import { semanticSearchService } from '@/lib/ai/services/semantic-search.service'
+import { prisma } from '@/lib/prisma'
+import { auth } from '@/auth'
+import { loadTranslations, getTranslationValue, SupportedLanguage } from '@/lib/i18n'
+import { toolRegistry } from '@/lib/ai/tools'
+import { stepCountIs } from 'ai'
+
+export const maxDuration = 60
+
+/**
+ * Extract text content from a UIMessage's parts array.
+ */
+function extractTextFromUIMessage(msg: { parts?: Array<{ type: string; text?: string }>; content?: string }): string {
+  if (typeof msg.content === 'string') return msg.content
+  if (msg.parts && Array.isArray(msg.parts)) {
+    return msg.parts
+      .filter((p) => p.type === 'text' && typeof p.text === 'string')
+      .map((p) => p.text!)
+      .join('')
+  }
+  return ''
+}
+
+/**
+ * Convert an array of UIMessages (from the client) to CoreMessage[] for streamText.
+ */
+function toCoreMessages(uiMessages: UIMessage[]): Array<{ role: 'user' | 'assistant'; content: string }> {
+  return uiMessages
+    .filter((m) => m.role === 'user' || m.role === 'assistant')
+    .map((m) => ({
+      role: m.role as 'user' | 'assistant',
+      content: extractTextFromUIMessage(m),
+    }))
+    .filter((m) => m.content.length > 0)
+}
+
+export async function POST(req: Request) {
+  // 1. Auth check
+  const session = await auth()
+  if (!session?.user?.id) {
+    return new Response('Unauthorized', { status: 401 })
+  }
+  const userId = session.user.id
+
+  // 2. Parse request body — messages arrive as UIMessage[] from DefaultChatTransport
+  const body = await req.json()
+  const { messages: rawMessages, conversationId, notebookId, language, webSearch } = body as {
+    messages: UIMessage[]
+    conversationId?: string
+    notebookId?: string
+    language?: string
+    webSearch?: boolean
+  }
+
+  // Convert UIMessages to CoreMessages for streamText
+  const incomingMessages = toCoreMessages(rawMessages)
+
+  // 3. Manage conversation (create or fetch)
+  let conversation: { id: string; messages: Array<{ role: string; content: string }> }
+
+  if (conversationId) {
+    const existing = await prisma.conversation.findUnique({
+      where: { id: conversationId, userId },
+      include: { messages: { orderBy: { createdAt: 'asc' } } },
+    })
+    if (!existing) {
+      return new Response('Conversation not found', { status: 404 })
+    }
+    conversation = existing
+  } else {
+    const userMessage = incomingMessages[incomingMessages.length - 1]?.content || 'New conversation'
+    const created = await prisma.conversation.create({
+      data: {
+        userId,
+        notebookId: notebookId || null,
+        title: userMessage.substring(0, 50) + (userMessage.length > 50 ? '...' : ''),
+      },
+      include: { messages: true },
+    })
+    conversation = created
+  }
+
+  // 4. RAG retrieval
+  const currentMessage = incomingMessages[incomingMessages.length - 1]?.content || ''
+
+  // Load translations for the requested language
+  const lang = (language || 'en') as SupportedLanguage
+  const translations = await loadTranslations(lang)
+  const untitledText = getTranslationValue(translations, 'notes.untitled') || 'Untitled'
+
+  // If a notebook is selected, fetch its recent notes directly as context
+  // This ensures the AI always has access to the notebook content,
+  // even for vague queries like "what's in this notebook?"
+  let notebookContext = ''
+  if (notebookId) {
+    const notebookNotes = await prisma.note.findMany({
+      where: {
+        notebookId,
+        userId,
+        trashedAt: null,
+      },
+      orderBy: { updatedAt: 'desc' },
+      take: 20,
+      select: { id: true, title: true, content: true, updatedAt: true },
+    })
+    if (notebookNotes.length > 0) {
+      notebookContext = notebookNotes
+        .map(n => `NOTE [${n.title || untitledText}] (updated ${n.updatedAt.toLocaleDateString()}):\n${(n.content || '').substring(0, 1500)}`)
+        .join('\n\n---\n\n')
+    }
+  }
+
+  // Also run semantic search for the specific query
+  const searchResults = await semanticSearchService.search(currentMessage, {
+    notebookId,
+    limit: notebookId ? 10 : 5,
+    threshold: notebookId ? 0.3 : 0.5,
+    defaultTitle: untitledText,
+  })
+
+  const searchNotes = searchResults
+    .map((r) => `NOTE [${r.title || untitledText}]: ${r.content}`)
+    .join('\n\n---\n\n')
+
+  // Combine: full notebook context + semantic search results (deduplicated)
+  const contextNotes = [notebookContext, searchNotes].filter(Boolean).join('\n\n---\n\n')
+
+  // 5. System prompt synthesis with RAG context
+  // Language-aware prompts to avoid forcing French responses
+  // Note: lang is already declared above when loading translations
+  const promptLang: Record<string, { contextWithNotes: string; contextNoNotes: string; system: string }> = {
+    en: {
+      contextWithNotes: `## User's notes\n\n${contextNotes}\n\nWhen using info from the notes above, cite the source note title in parentheses, e.g.: "Deployment is done via Docker (💻 Development Guide)". Don't copy word for word — rephrase. If the notes don't cover the topic, say so and supplement with your general knowledge.`,
+      contextNoNotes: "No relevant notes found for this question. Answer with your general knowledge.",
+      system: `You are the AI assistant of Memento. The user asks you questions about their projects, technical docs, and notes. You must respond in a structured and helpful way.
+
+## Format rules
+- Use markdown freely: headings (##, ###), lists, code blocks, bold, tables — anything that makes the response readable.
+- Structure your response with sections for technical questions or complex topics.
+- For simple, short questions, a direct paragraph is enough.
+
+## Tone rules
+- Natural tone, neither corporate nor too casual.
+- No unnecessary intro phrases ("Here's what I found", "Based on your notes"). Answer directly.
+- No upsell questions at the end ("Would you like me to...", "Do you want..."). If you have useful additional info, just give it.
+- If the user says "Momento" they mean Memento (this app).
+
+## Available tools
+You have access to these tools for deeper research:
+- **note_search**: Search the user's notes by keyword or meaning. Use when the initial context above is insufficient or when the user asks about specific content in their notes. If a notebook is selected, pass its ID to restrict results.
+- **note_read**: Read a specific note by ID. Use when note_search returns a note you need the full content of.
+- **web_search**: Search the web for information. Use when the user asks about something not in their notes.
+- **web_scrape**: Scrape a web page and return its content as markdown. Use when web_search returns a URL you need to read.
+
+## Tool usage rules
+- You already have context from the user's notes above. Only use tools if you need more specific or additional information.
+- Never invent note IDs, URLs, or notebook IDs. Use the IDs provided in the context or from tool results.
+- For simple conversational questions (greetings, opinions, general knowledge), answer directly without using any tools.`,
+    },
+    fr: {
+      contextWithNotes: `## Notes de l'utilisateur\n\n${contextNotes}\n\nQuand tu utilises une info venant des notes ci-dessus, cite le titre de la note source entre parenthèses, ex: "Le déploiement se fait via Docker (💻 Development Guide)". Ne recopie pas mot pour mot — reformule. Si les notes ne couvrent pas le sujet, dis-le et complète avec tes connaissances générales.`,
+      contextNoNotes: "Aucune note pertinente trouvée pour cette question. Réponds avec tes connaissances générales.",
+      system: `Tu es l'assistant IA de Memento. L'utilisateur te pose des questions sur ses projets, sa doc technique, ses notes. Tu dois répondre de façon structurée et utile.
+
+## Règles de format
+- Utilise le markdown librement : titres (##, ###), listes, code blocks, gras, tables — tout ce qui rend la réponse lisible.
+- Structure ta réponse avec des sections quand c'est une question technique ou un sujet complexe.
+- Pour les questions simples et courtes, un paragraphe direct suffit.
+
+## Règles de ton
+- Ton naturel, ni corporate ni trop familier.
+- Pas de phrase d'intro inutile ("Voici ce que j'ai trouvé", "Basé sur vos notes"). Réponds directement.
+- Pas de question upsell à la fin ("Souhaitez-vous que je...", "Acceptez-vous que..."). Si tu as une info complémentaire utile, donne-la.
+- Si l'utilisateur dit "Momento" il parle de Memento (cette application).
+
+## Outils disponibles
+Tu as accès à ces outils pour des recherches approfondies :
+- **note_search** : Cherche dans les notes de l'utilisateur par mot-clé ou sens. Utilise quand le contexte initial ci-dessus est insuffisant ou quand l'utilisateur demande du contenu spécifique dans ses notes. Si un carnet est sélectionné, passe son ID pour restreindre les résultats.
+- **note_read** : Lit une note spécifique par son ID. Utilise quand note_search retourne une note dont tu as besoin du contenu complet.
+- **web_search** : Recherche sur le web. Utilise quand l'utilisateur demande quelque chose qui n'est pas dans ses notes.
+- **web_scrape** : Scrape une page web et retourne son contenu en markdown. Utilise quand web_search retourne une URL que tu veux lire.
+
+## Règles d'utilisation des outils
+- Tu as déjà du contexte des notes de l'utilisateur ci-dessus. Utilise les outils seulement si tu as besoin d'informations plus spécifiques.
+- N'invente jamais d'IDs de notes, d'URLs ou d'IDs de carnet. Utilise les IDs fournis dans le contexte ou les résultats d'outils.
+- Pour les questions conversationnelles simples (salutations, opinions, connaissances générales), réponds directement sans utiliser d'outils.`,
+    },
+    fa: {
+      contextWithNotes: `## یادداشت‌های کاربر\n\n${contextNotes}\n\nهنگام استفاده از اطلاعات یادداشت‌های بالا، عنوان یادداشت منبع را در پرانتز ذکر کنید. کپی نکنید — بازنویسی کنید. اگر یادداشت‌ها موضوع را پوشش نمی‌دهند، بگویید و با دانش عمومی خود تکمیل کنید.`,
+      contextNoNotes: "هیچ یادداشت مرتبطی برای این سؤال یافت نشد. با دانش عمومی خود پاسخ دهید.",
+      system: `شما دستیار هوش مصنوعی Memento هستید. کاربر از شما درباره پروژه‌ها، مستندات فنی و یادداشت‌هایش سؤال می‌کند. باید به شکلی ساختاریافته و مفید پاسخ دهید.
+
+## قوانین قالب‌بندی
+- از مارک‌داون آزادانه استفاده کنید: عناوین (##, ###)، لیست‌ها، بلوک‌های کد، پررنگ، جداول.
+- برای سؤالات فنی یا موضوعات پیچیده، پاسخ خود را بخش‌بندی کنید.
+- برای سؤالات ساده و کوتاه، یک پاراگراف مستقیم کافی است.
+
+## قوانین لحن
+- لحن طبیعی، نه رسمی بیش از حد و نه خیلی غیررسمی.
+- بدون جمله مقدمه اضافی. مستقیم پاسخ دهید.
+- بدون سؤال فروشی در انتها. اگر اطلاعات تکمیلی مفید دارید، مستقیم بدهید.
+- اگر کاربر "Momento" می‌گوید، منظورش Memento (این برنامه) است.
+
+## ابزارهای موجود
+- **note_search**: جستجو در یادداشت‌های کاربر با کلیدواژه یا معنی. زمانی استفاده کنید که زمینه اولیه کافی نباشد. اگر دفترچه انتخاب شده، شناسه آن را ارسال کنید.
+- **note_read**: خواندن یک یادداشت خاص با شناسه. زمانی استفاده کنید که note_search یادداشتی برگرداند که محتوای کامل آن را نیاز دارید.
+- **web_search**: جستجو در وب. زمانی استفاده کنید که کاربر درباره چیزی خارج از یادداشت‌هایش می‌پرسد.
+- **web_scrape**: استخراج محتوای صفحه وب. زمانی استفاده کنید که web_search نشانی‌ای برگرداند که می‌خواهید بخوانید.
+
+## قوانین استفاده از ابزارها
+- شما از قبل زمینه‌ای از یادداشت‌های کاربر دارید. فقط در صورت نیاز به اطلاعات بیشتر از ابزارها استفاده کنید.
+- هرگز شناسه یادداشت، نشانی یا شناسه دفترچه نسازید. از شناسه‌های موجود در زمینه یا نتایج ابزار استفاده کنید.
+- برای سؤالات مکالمه‌ای ساده (سلام، نظرات، دانش عمومی)، مستقیم پاسخ دهید.`,
+    },
+    es: {
+      contextWithNotes: `## Notas del usuario\n\n${contextNotes}\n\nCuando uses información de las notas anteriores, cita el título de la nota fuente entre paréntesis. No copies palabra por palabra — reformula. Si las notas no cubren el tema, dilo y complementa con tu conocimiento general.`,
+      contextNoNotes: "No se encontraron notas relevantes para esta pregunta. Responde con tu conocimiento general.",
+      system: `Eres el asistente de IA de Memento. El usuario te hace preguntas sobre sus proyectos, documentación técnica y notas. Debes responder de forma estructurada y útil.
+
+## Reglas de formato
+- Usa markdown libremente: títulos (##, ###), listas, bloques de código, negritas, tablas.
+- Estructura tu respuesta con secciones para preguntas técnicas o temas complejos.
+- Para preguntas simples y cortas, un párrafo directo es suficiente.
+
+## Reglas de tono
+- Tono natural, ni corporativo ni demasiado informal.
+- Sin frases de introducción innecesarias. Responde directamente.
+- Sin preguntas de venta al final. Si tienes información complementaria útil, dala directamente.
+
+## Herramientas disponibles
+- **note_search**: Busca en las notas del usuario por palabra clave o significado. Úsalo cuando el contexto inicial sea insuficiente. Si hay una libreta seleccionada, pasa su ID para restringir los resultados.
+- **note_read**: Lee una nota específica por su ID. Úsalo cuando note_search devuelva una nota cuyo contenido completo necesites.
+- **web_search**: Busca en la web. Úsalo cuando el usuario pregunte sobre algo que no está en sus notas.
+- **web_scrape**: Extrae el contenido de una página web como markdown. Úsalo cuando web_search devuelva una URL que quieras leer.
+
+## Reglas de uso de herramientas
+- Ya tienes contexto de las notas del usuario arriba. Solo usa herramientas si necesitas información más específica.
+- Nunca inventes IDs de notas, URLs o IDs de libreta. Usa los IDs proporcionados en el contexto o en los resultados de herramientas.
+- Para preguntas conversacionales simples (saludos, opiniones, conocimiento general), responde directamente sin herramientas.`,
+    },
+    de: {
+      contextWithNotes: `## Notizen des Benutzers\n\n${contextNotes}\n\nWenn du Infos aus den obigen Notizen verwendest, zitiere den Titel der Quellnotiz in Klammern. Nicht Wort für Wort kopieren — umformulieren. Wenn die Notizen das Thema nicht abdecken, sag es und ergänze mit deinem Allgemeinwissen.`,
+      contextNoNotes: "Keine relevanten Notizen für diese Frage gefunden. Antworte mit deinem Allgemeinwissen.",
+      system: `Du bist der KI-Assistent von Memento. Der Benutzer stellt dir Fragen zu seinen Projekten, technischen Dokumentationen und Notizen. Du musst strukturiert und hilfreich antworten.
+
+## Formatregeln
+- Verwende Markdown frei: Überschriften (##, ###), Listen, Code-Blöcke, Fettdruck, Tabellen.
+- Strukturiere deine Antwort mit Abschnitten bei technischen Fragen oder komplexen Themen.
+- Bei einfachen, kurzen Fragen reicht ein direkter Absatz.
+
+## Tonregeln
+- Natürlicher Ton, weder zu geschäftsmäßig noch zu umgangssprachlich.
+- Keine unnötigen Einleitungssätze. Antworte direkt.
+- Keine Upsell-Fragen am Ende. Gib nützliche Zusatzinfos einfach direkt.
+
+## Verfügbare Werkzeuge
+- **note_search**: Durchsuche die Notizen des Benutzers nach Schlagwort oder Bedeutung. Verwende es, wenn der obige Kontext unzureichend ist. Wenn ein Notizbuch ausgewählt ist, gib dessen ID an, um die Ergebnisse einzuschränken.
+- **note_read**: Lese eine bestimmte Notiz anhand ihrer ID. Verwende es, wenn note_search eine Notiz zurückgibt, deren vollständigen Inhalt du benötigst.
+- **web_search**: Suche im Web. Verwende es, wenn der Benutzer nach etwas fragt, das nicht in seinen Notizen steht.
+- **web_scrape**: Lese eine Webseite und gib den Inhalt als Markdown zurück. Verwende es, wenn web_search eine URL zurückgibt, die du lesen möchtest.
+
+## Werkzeugregeln
+- Du hast bereits Kontext aus den Notizen des Benutzers oben. Verwende Werkzeuge nur, wenn du spezifischere Informationen benötigst.
+- Erfinde niemals Notiz-IDs, URLs oder Notizbuch-IDs. Verwende die im Kontext oder in Werkzeugergebnissen bereitgestellten IDs.
+- Bei einfachen Gesprächsfragen (Begrüßungen, Meinungen, Allgemeinwissen) antworte direkt ohne Werkzeuge.`,
+    },
+    it: {
+      contextWithNotes: `## Note dell'utente\n\n${contextNotes}\n\nQuando usi informazioni dalle note sopra, cita il titolo della nota fonte tra parentesi. Non copiare parola per parola — riformula. Se le note non coprono l'argomento, dillo e integra con la tua conoscenza generale.`,
+      contextNoNotes: "Nessuna nota rilevante trovata per questa domanda. Rispondi con la tua conoscenza generale.",
+      system: `Sei l'assistente IA di Memento. L'utente ti fa domande sui suoi progetti, documentazione tecnica e note. Devi rispondere in modo strutturato e utile.
+
+## Regole di formato
+- Usa markdown liberamente: titoli (##, ###), elenchi, blocchi di codice, grassetto, tabelle.
+- Struttura la risposta con sezioni per domande tecniche o argomenti complessi.
+- Per domande semplici e brevi, un paragrafo diretto basta.
+
+## Regole di tono
+- Tono naturale, né aziendale né troppo informale.
+- Nessuna frase introduttiva non necessaria. Rispondi direttamente.
+- Nessuna domanda di upsell alla fine. Se hai informazioni aggiuntive utili, dalle direttamente.
+
+## Strumenti disponibili
+- **note_search**: Cerca nelle note dell'utente per parola chiave o significato. Usa quando il contesto iniziale è insufficiente. Se un quaderno è selezionato, passa il suo ID per restringere i risultati.
+- **note_read**: Leggi una nota specifica per ID. Usa quando note_search restituisce una nota di cui hai bisogno del contenuto completo.
+- **web_search**: Cerca sul web. Usa quando l'utente chiede qualcosa che non è nelle sue note.
+- **web_scrape**: Estrai il contenuto di una pagina web come markdown. Usa quando web_search restituisce un URL che vuoi leggere.
+
+## Regole di utilizzo degli strumenti
+- Hai già contesto dalle note dell'utente sopra. Usa gli strumenti solo se hai bisogno di informazioni più specifiche.
+- Non inventare mai ID di note, URL o ID di quaderno. Usa gli ID forniti nel contesto o nei risultati degli strumenti.
+- Per domande conversazionali semplici (saluti, opinioni, conoscenza generale), rispondi direttamente senza strumenti.`,
+    },
+  }
+
+  // Fallback to English if language not supported
+  const prompts = promptLang[lang] || promptLang.en
+  const contextBlock = contextNotes.length > 0
+    ? prompts.contextWithNotes
+    : prompts.contextNoNotes
+
+  const systemPrompt = `${prompts.system}
+
+${contextBlock}
+
+${lang === 'en' ? 'Respond in the user\'s language.' : lang === 'fr' ? 'Réponds dans la langue de l\'utilisateur.' : 'Respond in the user\'s language.'}`
+
+  // 6. Build message history from DB + current messages
+  const dbHistory = conversation.messages.map((m: { role: string; content: string }) => ({
+    role: m.role as 'user' | 'assistant' | 'system',
+    content: m.content,
+  }))
+
+  // Only add the current user message if it's not already in DB history
+  const lastIncoming = incomingMessages[incomingMessages.length - 1]
+  const currentDbMessage = dbHistory[dbHistory.length - 1]
+  const isNewMessage =
+    lastIncoming &&
+    (!currentDbMessage ||
+      currentDbMessage.role !== 'user' ||
+      currentDbMessage.content !== lastIncoming.content)
+
+  const allMessages: Array<{ role: 'user' | 'assistant' | 'system'; content: string }> = isNewMessage
+    ? [...dbHistory, { role: lastIncoming.role, content: lastIncoming.content }]
+    : dbHistory
+
+  // 7. Get chat provider model
+  const config = await getSystemConfig()
+  const provider = getChatProvider(config)
+  const model = provider.getModel()
+
+  // 7b. Build chat tools
+  const chatToolContext = {
+    userId,
+    conversationId: conversation.id,
+    notebookId,
+    webSearch: !!webSearch,
+    config,
+  }
+  const chatTools = toolRegistry.buildToolsForChat(chatToolContext)
+
+  // 8. Save user message to DB before streaming
+  if (isNewMessage && lastIncoming) {
+    await prisma.chatMessage.create({
+      data: {
+        conversationId: conversation.id,
+        role: 'user',
+        content: lastIncoming.content,
+      },
+    })
+  }
+
+  // 9. Stream response
+  const result = streamText({
+    model,
+    system: systemPrompt,
+    messages: allMessages,
+    tools: chatTools,
+    stopWhen: stepCountIs(5),
+    async onFinish({ text }) {
+      // Save assistant message to DB after streaming completes
+      await prisma.chatMessage.create({
+        data: {
+          conversationId: conversation.id,
+          role: 'assistant',
+          content: text,
+        },
+      })
+    },
+  })
+
+  // 10. Return streaming response with conversation ID header
+  return result.toUIMessageStreamResponse({
+    headers: {
+      'X-Conversation-Id': conversation.id,
+    },
+  })
+}

memento-note/app/api/cron/reminders/route.ts

@@ -0,0 +1,63 @@
+import { NextResponse } from 'next/server';
+import prisma from '@/lib/prisma';
+
+export const dynamic = 'force-dynamic'; // No caching
+
+export async function POST(request: Request) {
+  try {
+    const now = new Date();
+
+    // 1. Find all due reminders that haven't been processed
+    const dueNotes = await prisma.note.findMany({
+      where: {
+        reminder: {
+          lte: now, // Less than or equal to now
+        },
+        isReminderDone: false,
+        isArchived: false, // Optional: exclude archived notes
+        trashedAt: null, // Exclude trashed notes
+      },
+      select: {
+        id: true,
+        title: true,
+        content: true,
+        reminder: true,
+        // Add other fields useful for notification
+      },
+    });
+
+    if (dueNotes.length === 0) {
+      return NextResponse.json({ 
+        success: true, 
+        count: 0, 
+        message: 'No due reminders found' 
+      });
+    }
+
+    // 2. Mark them as done (Atomic operation logic would be better but simple batch update is fine here)
+    const noteIds = dueNotes.map((n: any) => n.id);
+    
+    await prisma.note.updateMany({
+      where: {
+        id: { in: noteIds }
+      },
+      data: {
+        isReminderDone: true
+      }
+    });
+
+    // 3. Return the notes to N8N so it can send emails/messages
+    return NextResponse.json({
+      success: true,
+      count: dueNotes.length,
+      reminders: dueNotes
+    });
+
+  } catch (error) {
+    console.error('Error processing cron reminders:', error);
+    return NextResponse.json(
+      { success: false, error: 'Internal Server Error' },
+      { status: 500 }
+    );
+  }
+}

memento-note/app/api/debug/config/route.ts

@@ -0,0 +1,32 @@
+import { NextResponse } from 'next/server';
+import { getSystemConfig } from '@/lib/config';
+
+/**
+ * Debug endpoint to check AI configuration
+ * This helps verify that OpenAI is properly configured
+ */
+export async function GET() {
+  try {
+    const config = await getSystemConfig();
+
+    // Return only AI-related config for debugging
+    const aiConfig = {
+      AI_PROVIDER_TAGS: config.AI_PROVIDER_TAGS || 'not set',
+      AI_PROVIDER_EMBEDDING: config.AI_PROVIDER_EMBEDDING || 'not set',
+      AI_MODEL_TAGS: config.AI_MODEL_TAGS || 'not set',
+      AI_MODEL_EMBEDDING: config.AI_MODEL_EMBEDDING || 'not set',
+      OPENAI_API_KEY: config.OPENAI_API_KEY ? 'set (hidden)' : 'not set',
+      OLLAMA_BASE_URL: config.OLLAMA_BASE_URL || 'not set',
+      OLLAMA_MODEL: config.OLLAMA_MODEL || 'not set',
+      CUSTOM_OPENAI_BASE_URL: config.CUSTOM_OPENAI_BASE_URL || 'not set',
+      CUSTOM_OPENAI_API_KEY: config.CUSTOM_OPENAI_API_KEY ? 'set (hidden)' : 'not set',
+    };
+
+    return NextResponse.json(aiConfig);
+  } catch (error) {
+    return NextResponse.json(
+      { error: 'Failed to get config', details: error },
+      { status: 500 }
+    );
+  }
+}

memento-note/app/api/debug/test-chat/route.ts

@@ -0,0 +1,29 @@
+import { NextResponse } from 'next/server';
+import { chatService } from '@/lib/ai/services/chat.service';
+
+export async function POST(req: Request) {
+  try {
+    const body = await req.json();
+    console.log("TEST ROUTE INCOMING BODY:", body);
+    
+    // Simulate what the server action does
+    const result = await chatService.chat(body.message, body.conversationId, body.notebookId);
+    
+    return NextResponse.json({ success: true, result });
+  } catch (err: any) {
+    console.error("====== TEST ROUTE CHAT ERROR ======");
+    console.error("NAME:", err.name);
+    console.error("MSG:", err.message);
+    if (err.cause) console.error("CAUSE:", JSON.stringify(err.cause, null, 2));
+    if (err.data) console.error("DATA:", JSON.stringify(err.data, null, 2));
+    if (err.stack) console.error("STACK:", err.stack);
+    console.error("===================================");
+    return NextResponse.json({ 
+      success: false, 
+      error: err.message,
+      name: err.name,
+      cause: err.cause,
+      data: err.data
+    }, { status: 500 });
+  }
+}

memento-note/app/api/fix-labels/route.ts

@@ -0,0 +1,118 @@
+import { NextResponse } from 'next/server'
+import prisma from '@/lib/prisma'
+import { revalidatePath } from 'next/cache'
+
+function getHashColor(name: string): string {
+  const colors = ['red', 'blue', 'green', 'yellow', 'purple', 'pink', 'orange', 'gray']
+  let hash = 0
+  for (let i = 0; i < name.length; i++) {
+    hash = name.charCodeAt(i) + ((hash << 5) - hash)
+  }
+  return colors[Math.abs(hash) % colors.length]
+}
+
+export async function POST() {
+  try {
+    const result = { created: 0, deleted: 0, missing: [] as string[] }
+
+    // Get ALL users
+    const users = await prisma.user.findMany({
+      select: { id: true, email: true }
+    })
+
+
+    for (const user of users) {
+      const userId = user.id
+
+      // 1. Get all labels from notes
+      const allNotes = await prisma.note.findMany({
+        where: { userId },
+        select: { labels: true }
+      })
+
+      const labelsInNotes = new Set<string>()
+      allNotes.forEach(note => {
+        if (note.labels) {
+          try {
+            const parsed: string[] = Array.isArray(note.labels) ? (note.labels as string[]) : []
+            if (Array.isArray(parsed)) {
+              parsed.forEach(l => {
+                if (l && l.trim()) labelsInNotes.add(l.trim())
+              })
+            }
+          } catch (e) {}
+        }
+      })
+
+
+      // 2. Get existing Label records
+      const existingLabels = await prisma.label.findMany({
+        where: { userId },
+        select: { id: true, name: true }
+      })
+
+
+      const existingLabelMap = new Map<string, any>()
+      existingLabels.forEach(label => {
+        existingLabelMap.set(label.name.toLowerCase(), label)
+      })
+
+      // 3. Create missing Label records
+      for (const labelName of labelsInNotes) {
+        if (!existingLabelMap.has(labelName.toLowerCase())) {
+          try {
+            await prisma.label.create({
+              data: {
+                userId,
+                name: labelName,
+                color: getHashColor(labelName)
+              }
+            })
+            result.created++
+          } catch (e: any) {
+            console.error(`[FIX] ✗ Failed to create "${labelName}":`, e.message, e.code)
+            result.missing.push(labelName)
+          }
+        }
+      }
+
+      // 4. Delete orphan Label records
+      const usedLabelsSet = new Set<string>()
+      allNotes.forEach(note => {
+        if (note.labels) {
+          try {
+            const parsed: string[] = Array.isArray(note.labels) ? (note.labels as string[]) : []
+            if (Array.isArray(parsed)) {
+              parsed.forEach(l => usedLabelsSet.add(l.toLowerCase()))
+            }
+          } catch (e) {}
+        }
+      })
+
+      for (const label of existingLabels) {
+        if (!usedLabelsSet.has(label.name.toLowerCase())) {
+          try {
+            await prisma.label.delete({
+              where: { id: label.id }
+            })
+            result.deleted++
+          } catch (e) {}
+        }
+      }
+    }
+
+    revalidatePath('/')
+
+    return NextResponse.json({
+      success: true,
+      ...result,
+      message: `Created ${result.created} labels, deleted ${result.deleted} orphans`
+    })
+  } catch (error) {
+    console.error('[FIX] Error:', error)
+    return NextResponse.json(
+      { success: false, error: String(error) },
+      { status: 500 }
+    )
+  }
+}

memento-note/app/api/labels/[id]/route.ts

@@ -0,0 +1,252 @@
+import { NextRequest, NextResponse } from 'next/server'
+import prisma from '@/lib/prisma'
+import { revalidatePath } from 'next/cache'
+import { auth } from '@/auth'
+
+// GET /api/labels/[id] - Get a specific label
+export async function GET(
+  request: NextRequest,
+  { params }: { params: Promise<{ id: string }> }
+) {
+  const session = await auth()
+  if (!session?.user?.id) {
+    return NextResponse.json({ error: 'Unauthorized' }, { status: 401 })
+  }
+
+  try {
+    const { id } = await params
+    const label = await prisma.label.findUnique({
+      where: { id },
+      include: {
+        notebook: {
+          select: { id: true, name: true }
+        }
+      }
+    })
+
+    if (!label) {
+      return NextResponse.json(
+        { success: false, error: 'Label not found' },
+        { status: 404 }
+      )
+    }
+
+    // Verify ownership
+    if (label.notebookId) {
+      const notebook = await prisma.notebook.findUnique({
+        where: { id: label.notebookId },
+        select: { userId: true }
+      })
+      if (notebook?.userId !== session.user.id) {
+        return NextResponse.json({ error: 'Forbidden' }, { status: 403 })
+      }
+    } else if (label.userId !== session.user.id) {
+      return NextResponse.json({ error: 'Forbidden' }, { status: 403 })
+    }
+
+    return NextResponse.json({
+      success: true,
+      data: label
+    })
+  } catch (error) {
+    console.error('Error fetching label:', error)
+    return NextResponse.json(
+      { success: false, error: 'Failed to fetch label' },
+      { status: 500 }
+    )
+  }
+}
+
+// PUT /api/labels/[id] - Update a label
+export async function PUT(
+  request: NextRequest,
+  { params }: { params: Promise<{ id: string }> }
+) {
+  const session = await auth()
+  if (!session?.user?.id) {
+    return NextResponse.json({ error: 'Unauthorized' }, { status: 401 })
+  }
+
+  try {
+    const { id } = await params
+    const body = await request.json()
+    const { name, color } = body
+
+    // Get the current label first
+    const currentLabel = await prisma.label.findUnique({
+      where: { id },
+      include: {
+        notebook: {
+          select: { id: true, userId: true }
+        }
+      }
+    })
+
+    if (!currentLabel) {
+      return NextResponse.json(
+        { success: false, error: 'Label not found' },
+        { status: 404 }
+      )
+    }
+
+    // Verify ownership
+    if (currentLabel.notebookId) {
+      if (currentLabel.notebook?.userId !== session.user.id) {
+        return NextResponse.json({ error: 'Forbidden' }, { status: 403 })
+      }
+    } else if (currentLabel.userId !== session.user.id) {
+      return NextResponse.json({ error: 'Forbidden' }, { status: 403 })
+    }
+
+    const newName = name ? name.trim() : currentLabel.name
+
+    // For backward compatibility, update old label field in notes if renaming
+    const targetUserIdPut = currentLabel.userId || currentLabel.notebook?.userId || session.user.id;
+    if (name && name.trim() !== currentLabel.name && targetUserIdPut) {
+      const allNotes = await prisma.note.findMany({
+        where: {
+          userId: targetUserIdPut,
+          labels: { not: null }
+        },
+        select: { id: true, labels: true }
+      })
+
+      for (const note of allNotes) {
+        if (note.labels) {
+          try {
+            const noteLabels: string[] = Array.isArray(note.labels) ? (note.labels as string[]) : []
+            const updatedLabels = noteLabels.map(l =>
+              l.toLowerCase() === currentLabel.name.toLowerCase() ? newName : l
+            )
+
+            if (JSON.stringify(updatedLabels) !== JSON.stringify(noteLabels)) {
+              await prisma.note.update({
+                where: { id: note.id },
+                data: {
+                  labels: updatedLabels as any
+                }
+              })
+            }
+          } catch (e) {
+          }
+        }
+      }
+    }
+
+    // Now update the label record
+    const label = await prisma.label.update({
+      where: { id },
+      data: {
+        ...(name && { name: newName }),
+        ...(color && { color })
+      }
+    })
+
+    // Revalidate to refresh UI
+    revalidatePath('/')
+
+    return NextResponse.json({
+      success: true,
+      data: label
+    })
+  } catch (error) {
+    console.error('Error updating label:', error)
+    return NextResponse.json(
+      { success: false, error: 'Failed to update label' },
+      { status: 500 }
+    )
+  }
+}
+
+// DELETE /api/labels/[id] - Delete a label
+export async function DELETE(
+  request: NextRequest,
+  { params }: { params: Promise<{ id: string }> }
+) {
+  const session = await auth()
+  if (!session?.user?.id) {
+    return NextResponse.json({ error: 'Unauthorized' }, { status: 401 })
+  }
+
+  try {
+    const { id } = await params
+
+    // First, get the label to know its name and userId
+    const label = await prisma.label.findUnique({
+      where: { id },
+      include: {
+        notebook: {
+          select: { id: true, userId: true }
+        }
+      }
+    })
+
+    if (!label) {
+      return NextResponse.json(
+        { success: false, error: 'Label not found' },
+        { status: 404 }
+      )
+    }
+
+    // Verify ownership
+    if (label.notebookId) {
+      if (label.notebook?.userId !== session.user.id) {
+        return NextResponse.json({ error: 'Forbidden' }, { status: 403 })
+      }
+    } else if (label.userId !== session.user.id) {
+      return NextResponse.json({ error: 'Forbidden' }, { status: 403 })
+    }
+
+    // For backward compatibility, remove from old label field in notes
+    const targetUserIdDel = label.userId || label.notebook?.userId || session.user.id;
+    if (targetUserIdDel) {
+      const allNotes = await prisma.note.findMany({
+        where: {
+          userId: targetUserIdDel,
+          labels: { not: null }
+        },
+        select: { id: true, labels: true }
+      })
+
+      for (const note of allNotes) {
+        if (note.labels) {
+          try {
+            const noteLabels: string[] = Array.isArray(note.labels) ? (note.labels as string[]) : []
+            const filteredLabels = noteLabels.filter(
+              l => l.toLowerCase() !== label.name.toLowerCase()
+            )
+
+            if (filteredLabels.length !== noteLabels.length) {
+              await prisma.note.update({
+                where: { id: note.id },
+                data: {
+                  labels: (filteredLabels.length > 0 ? filteredLabels : null) as any
+                }
+              })
+            }
+          } catch (e) {
+          }
+        }
+      }
+    }
+
+    // Now delete the label record
+    await prisma.label.delete({
+      where: { id }
+    })
+
+    // Revalidate to refresh UI
+    revalidatePath('/')
+
+    return NextResponse.json({
+      success: true,
+      message: `Label "${label.name}" deleted successfully`
+    })
+  } catch (error) {
+    console.error('Error deleting label:', error)
+    return NextResponse.json(
+      { success: false, error: 'Failed to delete label' },
+      { status: 500 }
+    )
+  }
+}

memento-note/app/api/labels/route.ts

@@ -0,0 +1,131 @@
+import { NextRequest, NextResponse } from 'next/server'
+import prisma from '@/lib/prisma'
+import { auth } from '@/auth'
+
+const COLORS = ['red', 'orange', 'yellow', 'green', 'teal', 'blue', 'purple', 'pink', 'gray'];
+
+// GET /api/labels - Get all labels (supports optional notebookId filter)
+export async function GET(request: NextRequest) {
+  const session = await auth();
+  if (!session?.user?.id) {
+    return NextResponse.json({ error: 'Unauthorized' }, { status: 401 });
+  }
+
+  try {
+    const searchParams = request.nextUrl.searchParams
+    const notebookId = searchParams.get('notebookId')
+
+    // Build where clause
+    const where: any = {}
+
+    if (notebookId === 'null' || notebookId === '') {
+      // Get labels without a notebook (backward compatibility)
+      where.notebookId = null
+    } else if (notebookId) {
+      // Get labels for a specific notebook
+      where.notebookId = notebookId
+    } else {
+      // Get all labels for the user (both old and new system)
+      where.OR = [
+        { notebookId: { not: null } },
+        { userId: session.user.id }
+      ]
+    }
+
+    const labels = await prisma.label.findMany({
+      where,
+      include: {
+        notebook: {
+          select: { id: true, name: true }
+        }
+      },
+      orderBy: { name: 'asc' }
+    })
+
+    return NextResponse.json({
+      success: true,
+      data: labels
+    })
+  } catch (error) {
+    console.error('Error fetching labels:', error)
+    return NextResponse.json(
+      { success: false, error: 'Failed to fetch labels' },
+      { status: 500 }
+    )
+  }
+}
+
+// POST /api/labels - Create a new label
+export async function POST(request: NextRequest) {
+  const session = await auth();
+  if (!session?.user?.id) {
+    return NextResponse.json({ error: 'Unauthorized' }, { status: 401 });
+  }
+
+  try {
+    const body = await request.json()
+    const { name, color, notebookId } = body
+
+    if (!name || typeof name !== 'string') {
+      return NextResponse.json(
+        { success: false, error: 'Label name is required' },
+        { status: 400 }
+      )
+    }
+
+    if (!notebookId || typeof notebookId !== 'string') {
+      return NextResponse.json(
+        { success: false, error: 'notebookId is required' },
+        { status: 400 }
+      )
+    }
+
+    // Verify notebook ownership
+    const notebook = await prisma.notebook.findUnique({
+      where: { id: notebookId },
+      select: { userId: true }
+    })
+
+    if (!notebook || notebook.userId !== session.user.id) {
+      return NextResponse.json(
+        { success: false, error: 'Notebook not found or unauthorized' },
+        { status: 403 }
+      )
+    }
+
+    // Check if label already exists in this notebook
+    const existing = await prisma.label.findFirst({
+      where: {
+        name: name.trim(),
+        notebookId: notebookId
+      }
+    })
+
+    if (existing) {
+      return NextResponse.json(
+        { success: false, error: 'Label already exists in this notebook' },
+        { status: 409 }
+      )
+    }
+
+    const label = await prisma.label.create({
+      data: {
+        name: name.trim(),
+        color: color || COLORS[Math.floor(Math.random() * COLORS.length)],
+        notebookId: notebookId,
+        userId: session.user.id // Keep for backward compatibility
+      }
+    })
+
+    return NextResponse.json({
+      success: true,
+      data: label
+    }, { status: 201 })
+  } catch (error) {
+    console.error('Error creating label:', error)
+    return NextResponse.json(
+      { success: false, error: 'Failed to create label' },
+      { status: 500 }
+    )
+  }
+}

memento-note/app/api/notebooks/[id]/route.ts

@@ -0,0 +1,135 @@
+import { NextRequest, NextResponse } from 'next/server'
+import prisma from '@/lib/prisma'
+import { auth } from '@/auth'
+import { revalidatePath } from 'next/cache'
+
+// PATCH /api/notebooks/[id] - Update a notebook
+export async function PATCH(
+  request: NextRequest,
+  { params }: { params: Promise<{ id: string }> }
+) {
+  const session = await auth()
+  if (!session?.user?.id) {
+    return NextResponse.json({ error: 'Unauthorized' }, { status: 401 })
+  }
+
+  try {
+    const { id } = await params
+    const body = await request.json()
+    const { name, icon, color, order } = body
+
+    // Verify ownership
+    const existing = await prisma.notebook.findUnique({
+      where: { id },
+      select: { userId: true }
+    })
+
+    if (!existing) {
+      return NextResponse.json(
+        { success: false, error: 'Notebook not found' },
+        { status: 404 }
+      )
+    }
+
+    if (existing.userId !== session.user.id) {
+      return NextResponse.json(
+        { success: false, error: 'Forbidden' },
+        { status: 403 }
+      )
+    }
+
+    // Build update data
+    const updateData: any = {}
+    if (name !== undefined) updateData.name = name.trim()
+    if (icon !== undefined) updateData.icon = icon
+    if (color !== undefined) updateData.color = color
+    if (order !== undefined) updateData.order = order
+
+    // Update notebook
+    const notebook = await prisma.notebook.update({
+      where: { id },
+      data: updateData,
+      include: {
+        labels: true,
+        _count: {
+          select: { notes: true }
+        }
+      }
+    })
+
+    revalidatePath('/')
+
+    return NextResponse.json({
+      success: true,
+      ...notebook,
+      notesCount: notebook._count.notes
+    })
+  } catch (error) {
+    console.error('Error updating notebook:', error)
+    return NextResponse.json(
+      { success: false, error: 'Failed to update notebook' },
+      { status: 500 }
+    )
+  }
+}
+
+// DELETE /api/notebooks/[id] - Delete a notebook
+export async function DELETE(
+  request: NextRequest,
+  { params }: { params: Promise<{ id: string }> }
+) {
+  const session = await auth()
+  if (!session?.user?.id) {
+    return NextResponse.json({ error: 'Unauthorized' }, { status: 401 })
+  }
+
+  try {
+    const { id } = await params
+
+    // Verify ownership and get notebook info
+    const notebook = await prisma.notebook.findUnique({
+      where: { id },
+      select: {
+        userId: true,
+        name: true,
+        _count: {
+          select: { notes: true, labels: true }
+        }
+      }
+    })
+
+    if (!notebook) {
+      return NextResponse.json(
+        { success: false, error: 'Notebook not found' },
+        { status: 404 }
+      )
+    }
+
+    if (notebook.userId !== session.user.id) {
+      return NextResponse.json(
+        { success: false, error: 'Forbidden' },
+        { status: 403 }
+      )
+    }
+
+    // Delete notebook (cascade will handle labels and notes)
+    await prisma.notebook.delete({
+      where: { id }
+    })
+
+    revalidatePath('/')
+
+    return NextResponse.json({
+      success: true,
+      message: `Notebook "${notebook.name}" deleted`,
+      notesCount: notebook._count.notes,
+      labelsCount: notebook._count.labels
+    })
+  } catch (error) {
+    console.error('Error deleting notebook:', error)
+    return NextResponse.json(
+      { success: false, error: 'Failed to delete notebook' },
+      { status: 500 }
+    )
+  }
+}

memento-note/app/api/notebooks/reorder/route.ts

@@ -0,0 +1,62 @@
+import { NextRequest, NextResponse } from 'next/server'
+import prisma from '@/lib/prisma'
+import { auth } from '@/auth'
+import { revalidatePath } from 'next/cache'
+
+// POST /api/notebooks/reorder - Reorder notebooks
+export async function POST(request: NextRequest) {
+  const session = await auth()
+  if (!session?.user?.id) {
+    return NextResponse.json({ error: 'Unauthorized' }, { status: 401 })
+  }
+
+  try {
+    const body = await request.json()
+    const { notebookIds } = body
+
+    if (!Array.isArray(notebookIds)) {
+      return NextResponse.json(
+        { success: false, error: 'notebookIds must be an array' },
+        { status: 400 }
+      )
+    }
+
+    // Verify all notebooks belong to the user
+    const notebooks = await prisma.notebook.findMany({
+      where: {
+        id: { in: notebookIds },
+        userId: session.user.id
+      },
+      select: { id: true }
+    })
+
+    if (notebooks.length !== notebookIds.length) {
+      return NextResponse.json(
+        { success: false, error: 'One or more notebooks not found or unauthorized' },
+        { status: 403 }
+      )
+    }
+
+    // Update order for each notebook
+    const updates = notebookIds.map((id, index) =>
+      prisma.notebook.update({
+        where: { id },
+        data: { order: index }
+      })
+    )
+
+    await prisma.$transaction(updates)
+
+    revalidatePath('/')
+
+    return NextResponse.json({
+      success: true,
+      message: 'Notebooks reordered successfully'
+    })
+  } catch (error) {
+    return NextResponse.json(
+      { success: false, error: 'Failed to reorder notebooks' },
+      { status: 500 }
+    )
+  }
+}