diff --git a/Models/FanboxFolder.cs b/Models/FanboxFolder.cs
new file mode 100644
index 0000000..043f584
--- /dev/null
+++ b/Models/FanboxFolder.cs
@@ -0,0 +1,13 @@
+namespace Sakayaki.Models;
+
+public sealed class FanboxFolder
+{
+    public Guid Id { get; set; }
+    public string FolderName { get; set; } = string.Empty;
+    public string Author { get; set; } = string.Empty;
+    public DateTime Date { get; set; }
+    public string Title { get; set; } = string.Empty;
+    public string? Keywords { get; set; }
+    public int? FileCount { get; set; }
+    public DateTime CreatedAt { get; set; }
+}
diff --git a/Pages/Index.cshtml b/Pages/Index.cshtml
index a86a81a..1f71371 100644
--- a/Pages/Index.cshtml
+++ b/Pages/Index.cshtml
@@ -1,7 +1,197 @@
 @page
 @model IndexModel
 @{
-    ViewData["Title"] = "Home page";
+    ViewData["Title"] = "Gallery";
 }
 
+<div class="d-flex flex-wrap gap-2 align-items-end mt-3">
+    <form method="post" asp-page-handler="Update" class="mb-0">
+        <button type="submit" class="btn btn-success">Update</button>
+    </form>
 
+    <form method="get" class="row g-2 align-items-end flex-grow-1 mb-0">
+        <div class="col-12 col-sm-6 col-md-4">
+            <input id="keywordInput"
+                   name="keyword"
+                   class="form-control"
+                   value="@Model.Keyword"
+                   placeholder="Search by keyword"
+                   aria-label="Keyword" />
+        </div>
+        <div class="col-auto">
+            <button type="submit" class="btn btn-primary">Search</button>
+            <a class="btn btn-outline-secondary" href="@Url.Page("Index")">Clear</a>
+        </div>
+    </form>
+</div>
+
+@if (!string.IsNullOrWhiteSpace(Model.StatusMessage))
+{
+    <div class="alert alert-info mt-3">@Model.StatusMessage</div>
+}
+
+<div class="row row-cols-1 row-cols-sm-2 row-cols-lg-3 g-3 mt-3">
+    @if (Model.Folders.Count == 0)
+    {
+        <div class="col">
+            <div class="alert alert-secondary mb-0">No records yet.</div>
+        </div>
+    }
+    else
+    {
+        foreach (var card in Model.Folders)
+        {
+            var item = card.Folder;
+            <div class="col">
+                <button type="button"
+                        class="card h-100 text-start shadow-sm folder-card"
+                        data-folder-id="@item.Id"
+                        data-title="@item.Title"
+                        data-date="@item.Date.ToString("yyyy-MM-dd")"
+                        data-author="@item.Author"
+                        data-count="@(item.FileCount ?? 0)"
+                        data-keywords="@item.Keywords">
+                    @if (!string.IsNullOrWhiteSpace(card.CoverUrl))
+                    {
+                        <img src="@card.CoverUrl" alt="@card.CoverFileName" class="card-img-top" />
+                    }
+                    <div class="card-body d-flex flex-column">
+                        <h5 class="card-title mb-1">@item.Title</h5>
+                        <div class="text-muted small">@item.Date.ToString("yyyy-MM-dd") · @item.Author</div>
+                        @if (!string.IsNullOrWhiteSpace(item.Keywords))
+                        {
+                            <div class="mt-2 text-body-secondary small">@item.Keywords</div>
+                        }
+                        <div class="mt-auto pt-2">
+                            <span class="badge text-bg-light">@((item.FileCount ?? 0).ToString()) files</span>
+                        </div>
+                    </div>
+                </button>
+            </div>
+        }
+    }
+</div>
+
+<div class="modal fade" id="folderModal" tabindex="-1" aria-labelledby="folderModalLabel" aria-hidden="true">
+    <div class="modal-dialog modal-xl modal-dialog-scrollable">
+        <div class="modal-content">
+            <div class="modal-header">
+                <h5 class="modal-title" id="folderModalLabel">Files</h5>
+                <button type="button" class="btn-close" data-bs-dismiss="modal" aria-label="Close"></button>
+            </div>
+            <div class="modal-body">
+                <div id="folderMeta" class="mb-2 text-muted small"></div>
+                <div id="folderKeywords" class="mb-2"></div>
+                <div id="folderLoading" class="alert alert-light border">Loading...</div>
+                <div id="folderEmpty" class="alert alert-secondary d-none">No images found.</div>
+                <div id="folderImages" class="row g-2"></div>
+            </div>
+        </div>
+    </div>
+</div>
+
+@section Scripts {
+    <script>
+        const modalEl = document.getElementById("folderModal");
+        const folderModal = new bootstrap.Modal(modalEl);
+        const titleEl = document.getElementById("folderModalLabel");
+        const metaEl = document.getElementById("folderMeta");
+        const keywordsEl = document.getElementById("folderKeywords");
+        const loadingEl = document.getElementById("folderLoading");
+        const emptyEl = document.getElementById("folderEmpty");
+        const imagesEl = document.getElementById("folderImages");
+
+        function setLoading(isLoading) {
+            loadingEl.classList.toggle("d-none", !isLoading);
+        }
+
+        function setEmpty(isEmpty) {
+            emptyEl.classList.toggle("d-none", !isEmpty);
+        }
+
+        function clearImages() {
+            imagesEl.innerHTML = "";
+        }
+
+        function renderKeywords(raw) {
+            keywordsEl.innerHTML = "";
+            if (!raw) {
+                return;
+            }
+
+            const list = raw.split(",").map(k => k.trim()).filter(k => k.length > 0);
+            if (list.length === 0) {
+                return;
+            }
+
+            const label = document.createElement("span");
+            label.className = "text-muted small me-2";
+            label.textContent = "Keywords:";
+            keywordsEl.appendChild(label);
+
+            for (const keyword of list) {
+                const link = document.createElement("a");
+                link.href = `?keyword=${encodeURIComponent(keyword)}`;
+                link.className = "badge text-bg-light me-1 text-decoration-none";
+                link.textContent = keyword;
+                keywordsEl.appendChild(link);
+            }
+        }
+
+        async function loadImages(folderId) {
+            setLoading(true);
+            setEmpty(false);
+            clearImages();
+
+            try {
+                const response = await fetch(`?handler=Images&id=${encodeURIComponent(folderId)}`);
+                if (!response.ok) {
+                    setEmpty(true);
+                    return;
+                }
+
+                const files = await response.json();
+                if (!files || files.length === 0) {
+                    setEmpty(true);
+                    return;
+                }
+
+                for (const file of files) {
+                    const col = document.createElement("div");
+                    col.className = "col-6 col-md-4 col-lg-3";
+
+                    const img = document.createElement("img");
+                    img.src = file.url;
+                    img.alt = file.fileName || "image";
+                    img.loading = "lazy";
+                    img.className = "img-fluid rounded border";
+
+                    col.appendChild(img);
+                    imagesEl.appendChild(col);
+                }
+            } finally {
+                setLoading(false);
+            }
+        }
+
+        document.querySelectorAll(".folder-card").forEach(card => {
+            card.addEventListener("click", () => {
+                const title = card.dataset.title || "Files";
+                const date = card.dataset.date || "";
+                const author = card.dataset.author || "";
+                const count = card.dataset.count || "0";
+                const keywords = card.dataset.keywords || "";
+
+                titleEl.textContent = title;
+                metaEl.textContent = `${date} · ${author} · ${count} files`;
+                renderKeywords(keywords);
+
+                const folderId = card.dataset.folderId;
+                if (folderId) {
+                    loadImages(folderId);
+                    folderModal.show();
+                }
+            });
+        });
+    </script>
+}
diff --git a/Pages/Index.cshtml.cs b/Pages/Index.cshtml.cs
index 5fd882a..8e16e0c 100644
--- a/Pages/Index.cshtml.cs
+++ b/Pages/Index.cshtml.cs
@@ -1,12 +1,154 @@
 using Microsoft.AspNetCore.Mvc;
 using Microsoft.AspNetCore.Mvc.RazorPages;
+using Microsoft.AspNetCore.StaticFiles;
+using Microsoft.EntityFrameworkCore;
+using Sakayaki.Models;
+using Sakayaki.Services;
 
 namespace Sakayaki.Pages;
 
-public class IndexModel : PageModel
+public class IndexModel(SyncService syncService, AppDbContext dbContext, IConfiguration configuration) : PageModel
 {
-    public void OnGet()
+    private static readonly HashSet<string> ImageExtensions = new(StringComparer.OrdinalIgnoreCase)
     {
+        ".jpg", ".jpeg", ".png", ".gif", ".webp", ".bmp"
+    };
 
+    private readonly SyncService _syncService = syncService;
+    private readonly AppDbContext _dbContext = dbContext;
+    private readonly string? _rootPath = configuration["Fanbox:RootPath"];
+    private readonly string? _author = configuration["Fanbox:Author"];
+
+    [TempData]
+    public string? StatusMessage { get; set; }
+
+    public sealed class FolderCard
+    {
+        public required FanboxFolder Folder { get; init; }
+        public string? CoverUrl { get; init; }
+        public string? CoverFileName { get; init; }
+    }
+
+    public IReadOnlyList<FolderCard> Folders { get; private set; } = Array.Empty<FolderCard>();
+    public string? Keyword { get; private set; }
+
+    public async Task OnGetAsync(string? keyword)
+    {
+        Keyword = string.IsNullOrWhiteSpace(keyword) ? null : keyword.Trim();
+
+        var query = _dbContext.FanboxFolders.AsNoTracking();
+        if (!string.IsNullOrWhiteSpace(Keyword))
+        {
+            var pattern = $"%{Keyword}%";
+            query = query.Where(x => x.Keywords != null && EF.Functions.Like(x.Keywords, pattern));
+        }
+
+        var folders = await query
+            .OrderByDescending(x => x.Date)
+            .ThenByDescending(x => x.CreatedAt)
+            .ToListAsync();
+
+        var cards = new List<FolderCard>(folders.Count);
+        foreach (var folder in folders)
+        {
+            string? coverFile = null;
+            string? coverUrl = null;
+
+            if (!string.IsNullOrWhiteSpace(_rootPath))
+            {
+                var folderPath = Path.Combine(_rootPath, folder.FolderName);
+                if (Directory.Exists(folderPath))
+                {
+                    coverFile = Directory.EnumerateFiles(folderPath)
+                        .Select(Path.GetFileName)
+                        .FirstOrDefault(name =>
+                            !string.IsNullOrWhiteSpace(name) &&
+                            name.StartsWith("0.", StringComparison.OrdinalIgnoreCase) &&
+                            ImageExtensions.Contains(Path.GetExtension(name)));
+                }
+            }
+
+            if (!string.IsNullOrWhiteSpace(coverFile))
+            {
+                coverUrl = Url.Page("Index", "Image", new { id = folder.Id, file = coverFile });
+            }
+
+            cards.Add(new FolderCard
+            {
+                Folder = folder,
+                CoverUrl = coverUrl,
+                CoverFileName = coverFile
+            });
+        }
+
+        Folders = cards;
+    }
+
+    public async Task<IActionResult> OnPostUpdateAsync()
+    {
+        if (string.IsNullOrWhiteSpace(_rootPath) || string.IsNullOrWhiteSpace(_author))
+        {
+            StatusMessage = "Fanbox settings missing (RootPath/Author).";
+            return Page();
+        }
+
+        var inserted = await _syncService.SyncFanboxFoldersAsync(_rootPath, _author, HttpContext.RequestAborted);
+        StatusMessage = $"Inserted {inserted} rows.";
+
+        return RedirectToPage();
+    }
+
+    public async Task<IActionResult> OnGetImagesAsync(Guid id)
+    {
+        if (string.IsNullOrWhiteSpace(_rootPath))
+            return new JsonResult(Array.Empty<object>());
+
+        var folder = await _dbContext.FanboxFolders.AsNoTracking()
+            .FirstOrDefaultAsync(x => x.Id == id);
+        if (folder is null)
+            return new JsonResult(Array.Empty<object>());
+
+        var folderPath = Path.Combine(_rootPath, folder.FolderName);
+        if (!Directory.Exists(folderPath))
+            return new JsonResult(Array.Empty<object>());
+
+        var images = Directory.GetFiles(folderPath)
+            .Where(path => ImageExtensions.Contains(Path.GetExtension(path)))
+            .OrderBy(path => path, StringComparer.OrdinalIgnoreCase)
+            .Select(path => new
+            {
+                fileName = Path.GetFileName(path),
+                url = Url.Page("Index", "Image", new { id = folder.Id, file = Path.GetFileName(path) }) ?? string.Empty
+            })
+            .ToArray();
+
+        return new JsonResult(images);
+    }
+
+    public async Task<IActionResult> OnGetImageAsync(Guid id, string file)
+    {
+        if (string.IsNullOrWhiteSpace(_rootPath) || string.IsNullOrWhiteSpace(file))
+            return NotFound();
+
+        var safeFile = Path.GetFileName(file);
+        if (string.IsNullOrWhiteSpace(safeFile))
+            return NotFound();
+        if (!ImageExtensions.Contains(Path.GetExtension(safeFile)))
+            return NotFound();
+
+        var folder = await _dbContext.FanboxFolders.AsNoTracking()
+            .FirstOrDefaultAsync(x => x.Id == id);
+        if (folder is null)
+            return NotFound();
+
+        var filePath = Path.Combine(_rootPath, folder.FolderName, safeFile);
+        if (!System.IO.File.Exists(filePath))
+            return NotFound();
+
+        var provider = new FileExtensionContentTypeProvider();
+        if (!provider.TryGetContentType(filePath, out var contentType))
+            contentType = "application/octet-stream";
+
+        return PhysicalFile(filePath, contentType);
     }
 }
diff --git a/Pages/Shared/_Layout.cshtml b/Pages/Shared/_Layout.cshtml
index 4f4934a..95871c8 100644
--- a/Pages/Shared/_Layout.cshtml
+++ b/Pages/Shared/_Layout.cshtml
@@ -8,7 +8,7 @@
     <link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/bootstrap@5.3.3/dist/css/bootstrap.min.css" integrity="sha384-QWTKZyjpPEjISv5WaRU9OFeRpok6YctnYmDr5pNlyT2bRjXh0JMhjY6hW+ALEwIH" crossorigin="anonymous" />
 </head>
 <body>
-    <div class="container">
+    <div class="container-fluid m-3">
         <main role="main" class="pb-3">
             @RenderBody()
         </main>
diff --git a/Program.cs b/Program.cs
index a04832b..f8d18ae 100644
--- a/Program.cs
+++ b/Program.cs
@@ -1,7 +1,13 @@
+using Microsoft.EntityFrameworkCore;
+using Sakayaki.Services;
+
 var builder = WebApplication.CreateBuilder(args);
 
 // Add services to the container.
 builder.Services.AddRazorPages();
+builder.Services.AddDbContext<AppDbContext>(options =>
+    options.UseSqlServer(builder.Configuration.GetConnectionString("DefaultConnection")));
+builder.Services.AddScoped<SyncService>();
 
 var app = builder.Build();
 
diff --git a/Properties/launchSettings.json b/Properties/launchSettings.json
index 8fb711f..09f9961 100644
--- a/Properties/launchSettings.json
+++ b/Properties/launchSettings.json
@@ -9,15 +9,6 @@
       "environmentVariables": {
         "ASPNETCORE_ENVIRONMENT": "Development"
       }
-    },
-    "https": {
-      "commandName": "Project",
-      "dotnetRunMessages": true,
-      "launchBrowser": true,
-      "applicationUrl": "https://localhost:7008;http://localhost:5164",
-      "environmentVariables": {
-        "ASPNETCORE_ENVIRONMENT": "Development"
-      }
     }
   }
 }
diff --git a/Sakayaki.csproj b/Sakayaki.csproj
index a3a34b6..76ab7a1 100644
--- a/Sakayaki.csproj
+++ b/Sakayaki.csproj
@@ -6,4 +6,9 @@
     <ImplicitUsings>enable</ImplicitUsings>
   </PropertyGroup>
 
+  <ItemGroup>
+    <PackageReference Include="Microsoft.EntityFrameworkCore" Version="9.0.0" />
+    <PackageReference Include="Microsoft.EntityFrameworkCore.SqlServer" Version="9.0.0" />
+  </ItemGroup>
+
 </Project>
diff --git a/Services/AppDbContext.cs b/Services/AppDbContext.cs
new file mode 100644
index 0000000..8c2da2f
--- /dev/null
+++ b/Services/AppDbContext.cs
@@ -0,0 +1,29 @@
+using Microsoft.EntityFrameworkCore;
+using Sakayaki.Models;
+
+namespace Sakayaki.Services;
+
+public sealed class AppDbContext : DbContext
+{
+    public AppDbContext(DbContextOptions<AppDbContext> options) : base(options)
+    {
+    }
+
+    public DbSet<FanboxFolder> FanboxFolders => Set<FanboxFolder>();
+
+    protected override void OnModelCreating(ModelBuilder modelBuilder)
+    {
+        base.OnModelCreating(modelBuilder);
+
+        var entity = modelBuilder.Entity<FanboxFolder>();
+        entity.ToTable("FanboxFolders");
+        entity.HasKey(x => x.Id);
+        entity.Property(x => x.Id).ValueGeneratedOnAdd();
+        entity.Property(x => x.CreatedAt).ValueGeneratedOnAdd();
+        entity.Property(x => x.FolderName).HasMaxLength(255).IsRequired();
+        entity.Property(x => x.Author).HasMaxLength(100).IsRequired();
+        entity.Property(x => x.Date).HasColumnType("date").IsRequired();
+        entity.Property(x => x.Title).HasMaxLength(255).IsRequired();
+        entity.Property(x => x.Keywords).HasMaxLength(1024);
+    }
+}
diff --git a/Services/SyncService.cs b/Services/SyncService.cs
new file mode 100644
index 0000000..ca6c9b9
--- /dev/null
+++ b/Services/SyncService.cs
@@ -0,0 +1,109 @@
+using System.Globalization;
+using Microsoft.EntityFrameworkCore;
+using Sakayaki.Models;
+
+namespace Sakayaki.Services;
+
+public sealed class SyncService(AppDbContext dbContext)
+{
+    private static readonly string[] DefaultKeywords =
+    {
+        "ユウリ","セレナ","ヒカリ","リーリエ","ミヅキ","メイ","マリィ","ルチア","コトネ",
+        "大苦戦","敗北","拘束","差分","差分セット"
+    };
+
+    private readonly AppDbContext _dbContext = dbContext;
+
+    public async Task<int> SyncFanboxFoldersAsync(
+        string root,
+        string author,
+        CancellationToken cancellationToken = default)
+    {
+        if (string.IsNullOrWhiteSpace(root))
+            throw new ArgumentException("Root path is required.", nameof(root));
+        if (string.IsNullOrWhiteSpace(author))
+            throw new ArgumentException("Author is required.", nameof(author));
+
+        var inserted = 0;
+
+        var pending = new List<FanboxFolder>();
+
+        foreach (var dir in Directory.GetDirectories(root))
+        {
+            cancellationToken.ThrowIfCancellationRequested();
+
+            var folderName = Path.GetFileName(dir);
+            if (folderName.Length < 11 || folderName[10] != '-')
+                continue;
+
+            var datePart = folderName.Substring(0, 10);
+            if (!DateTime.TryParseExact(
+                    datePart,
+                    "yyyy-MM-dd",
+                    CultureInfo.InvariantCulture,
+                    DateTimeStyles.None,
+                    out var date))
+                continue;
+
+            var title = folderName.Substring(11);
+            var keywordsStr = BuildKeywords(title);
+            var fileCount = Directory.GetFiles(dir).Length;
+
+            var exists = await _dbContext.FanboxFolders.AsNoTracking().AnyAsync(
+                x => x.Author == author && x.Date == date && x.Title == title,
+                cancellationToken);
+            if (exists)
+                continue;
+
+            pending.Add(new FanboxFolder
+            {
+                FolderName = folderName,
+                Author = author,
+                Date = date,
+                Title = title,
+                Keywords = keywordsStr,
+                FileCount = fileCount
+            });
+        }
+
+        if (pending.Count == 0)
+            return 0;
+
+        _dbContext.FanboxFolders.AddRange(pending);
+        inserted = await _dbContext.SaveChangesAsync(cancellationToken);
+
+        return inserted;
+    }
+
+    private static string? BuildKeywords(string title)
+    {
+        var hit = new HashSet<string>(StringComparer.Ordinal);
+
+        var cleaned = title
+            .Replace("【", " ")
+            .Replace("】", " ")
+            .Replace("（", " ")
+            .Replace("）", " ")
+            .Replace("(", " ")
+            .Replace(")", " ")
+            .Replace("／", " ")
+            .Replace("/", " ")
+            .Replace(",", " ")
+            .Replace("_", " ")
+            .Replace("-", " ");
+
+        foreach (var w in cleaned.Split(' ', StringSplitOptions.RemoveEmptyEntries))
+        {
+            if (w.Length >= 2)
+                hit.Add(w);
+        }
+
+        foreach (var k in DefaultKeywords)
+        {
+            if (title.Contains(k, StringComparison.Ordinal))
+                hit.Add(k);
+        }
+
+        return hit.Count > 0 ? string.Join(",", hit) : null;
+    }
+}
diff --git a/appsettings.Development.json b/appsettings.Development.json
index 770d3e9..b2e80a1 100644
--- a/appsettings.Development.json
+++ b/appsettings.Development.json
@@ -5,5 +5,9 @@
       "Default": "Information",
       "Microsoft.AspNetCore": "Warning"
     }
+  },
+  "Fanbox": {
+    "RootPath": "C:\\Users\\smdhz\\Downloads\\fanbox\\月代",
+    "Author": "月代"
   }
 }
diff --git a/appsettings.json b/appsettings.json
index 9d8b308..76a1b7b 100644
--- a/appsettings.json
+++ b/appsettings.json
@@ -6,7 +6,11 @@
     }
   },
   "ConnectionStrings": {
-    "DefaultConnection": "Server=10.16.1.100;Database=Note;User Id=sa;Password=monkey2b;TrustServerCertificate=True"
+    "DefaultConnection": "Server=10.16.1.100;Database=Note;User Id=sa;Password=monkeY2b;TrustServerCertificate=True"
+  },
+  "Fanbox": {
+    "RootPath": "/mnt/media/Picture/fanbox/月代",
+    "Author": "月代"
   },
   "AllowedHosts": "*"
 }