revision 1, 30 minutes, dropping in the bluesky_hose.ex module and letting claude 3.7 sonnet thinking do the rest

.cursorrules

···
   - Use functional programming patterns and leverage immutability.
   - Prefer higher-order functions and recursion over imperative loops.
   - Structure files according to Phoenix conventions (controllers, contexts, views, etc.).
+  - Req for requests
 
 Naming Conventions
   - Use snake_case for file names, function names, and variables.
···
   - Use Phoenix LiveView for dynamic, real-time interactions.
   - Implement responsive design with Tailwind CSS.
   - Implement subtle javascript microinteractions as appropriate using Tailwind + Phoenix.LiveView.JS
-  
+
 Performance Optimization
   - Use database indexing effectively.
-  - Implement caching strategies using Nebulex
   - Use Ecto's preload to avoid N+1 queries.
   - Optimize database queries using preload, joins, or select.
-  
+
 Testing
   - Write comprehensive tests using ExUnit.
   - Follow TDD practices.
   - Use ExMachina for test data generation.
-  
+
 Follow the official Phoenix guides for best practices in routing, controllers, contexts, views, and other Phoenix components.
 
 Reuse code as appropriate, but also remember that premature abstraction and DRY can be problematic in their own right.  If we are going to reuse code, we should do our best to not need to modify existing interfaces

.iex.exs

···
+Logger.configure(level: :error)
+

config/dev.exs

···
 
 # Configure your database
 config :bookmarker, Bookmarker.Repo,
-  username: "postgres",
-  password: "postgres",
+  username: "robertgrayson",
+  password: "",
   hostname: "localhost",
   database: "bookmarker_dev",
   stacktrace: true,

lib/bluesky_hose.ex

···
+defmodule BlueskyHose do
+  use WebSockex
+  require Logger
+
+  alias Bookmarker.Bookmarks
+  alias Bookmarker.Accounts
+  alias Phoenix.PubSub
+
+  @table_name :reddit_links
+  @topic "bookmarks"
+
+  def start_link(opts \\ []) do
+    # Create ETS table if it doesn't exist
+    :ets.new(@table_name, [:named_table, :ordered_set, :public, read_concurrency: true])
+
+    WebSockex.start_link(
+      "wss://bsky-relay.c.theo.io/subscribe?wantedCollections=app.bsky.feed.post",
+      __MODULE__,
+      %{processed_links: MapSet.new()},  # Track processed links to avoid duplicates
+      opts
+    )
+  rescue
+    ArgumentError ->
+      # Table already exists
+      WebSockex.start_link(
+        "wss://bsky-relay.c.theo.io/subscribe?wantedCollections=app.bsky.feed.post",
+        __MODULE__,
+        %{processed_links: MapSet.new()},
+        opts
+      )
+  end
+
+  def handle_connect(_conn, state) do
+    Logger.info("Connected to Bluesky relay!")
+    IO.puts("#{DateTime.utc_now()}")
+    {:ok, state}
+  end
+
+  def handle_frame({:text, msg}, state) do
+    msg = Jason.decode!(msg)
+
+    case msg do
+      %{"commit" => record = %{"record" => %{"text" => skeet}}} = _msg ->
+        # Check if this post has an external link
+        case record do
+          %{
+            "record" => %{
+              "embed" => %{
+                "external" => %{
+                  "uri" => uri
+                }
+              }
+            }
+          } when is_binary(uri) ->
+            # Only process if we haven't seen this link before
+            if not MapSet.member?(state.processed_links, uri) do
+              Logger.info("Found link in Bluesky post: #{uri}")
+
+              # Extract title from the embed
+              title =
+                record
+                |> Map.get("record", %{})
+                |> Map.get("embed", %{})
+                |> Map.get("external", %{})
+                |> Map.get("title", "Untitled Bluesky Share")
+
+              # Extract description if available
+              description =
+                record
+                |> Map.get("record", %{})
+                |> Map.get("embed", %{})
+                |> Map.get("external", %{})
+                |> Map.get("description", skeet)
+
+              # Create tags based on the post content
+              tags = extract_tags_from_text(skeet)
+
+              # Get a demo user for posting the bookmark
+              user = get_or_create_demo_user()
+
+              # Create the bookmark in our system
+              bookmark_attrs = %{
+                url: uri,
+                title: title,
+                description: description,
+                user_id: user.id
+              }
+
+              case Bookmarks.create_bookmark(bookmark_attrs, tags) do
+                {:ok, bookmark} ->
+                  Logger.info("Created bookmark: #{bookmark.title}")
+                  # Broadcast is handled in Bookmarks.create_bookmark
+
+                  # Update state to track this link
+                  updated_state = %{state | processed_links: MapSet.put(state.processed_links, uri)}
+                  {:ok, updated_state}
+
+                {:error, changeset} ->
+                  Logger.error("Failed to create bookmark: #{inspect(changeset.errors)}")
+                  {:ok, state}
+              end
+            else
+              # Already processed this link
+              {:ok, state}
+            end
+
+          _ ->
+            # No external link in this post
+            {:ok, state}
+        end
+
+      _ ->
+        # Not a post we're interested in
+        {:ok, state}
+    end
+  end
+
+  # Extract potential tags from the text of a post
+  defp extract_tags_from_text(text) do
+    # Extract hashtags (words starting with #)
+    hashtags =
+      ~r/#([a-zA-Z0-9_]+)/
+      |> Regex.scan(text)
+      |> Enum.map(fn [_, tag] -> tag end)
+
+    # Combine and ensure uniqueness
+    hashtags
+    |> Enum.uniq()
+    |> Enum.reject(&is_nil/1)
+    |> Enum.map(&String.downcase/1)
+  end
+
+  # Get a demo user for posting bookmarks
+  defp get_or_create_demo_user do
+    case Accounts.get_user_by_username("bluesky_bot") do
+      nil ->
+        {:ok, user} = Accounts.create_user(%{
+          username: "bluesky_bot",
+          email: "[e-mail]",
+          display_name: "Bluesky Bot"
+        })
+        user
+      user ->
+        user
+    end
+  end
+
+  def handle_disconnect(%{reason: {:local, reason}}, state) do
+    Logger.info("Local close with reason: #{inspect(reason)}")
+    {:ok, state}
+  end
+
+  def handle_disconnect(disconnect_map, state) do
+    Logger.warning("Disconnected from Bluesky: #{inspect(disconnect_map)}")
+    # Reconnect after a delay
+    Process.send_after(self(), :reconnect, 5000)
+    {:ok, state}
+  end
+
+  def handle_info(:reconnect, state) do
+    Logger.info("Attempting to reconnect to Bluesky...")
+    {:reconnect, state}
+  end
+end

lib/bookmarker/accounts.ex

···
+defmodule Bookmarker.Accounts do
+  @moduledoc """
+  The Accounts context.
+  """
+
+  import Ecto.Query, warn: false
+  alias Bookmarker.Repo
+
+  alias Bookmarker.Accounts.User
+
+  @doc """
+  Returns the list of users.
+
+  ## Examples
+
+      iex> list_users()
+      [%User{}, ...]
+
+  """
+  def list_users do
+    Repo.all(User)
+  end
+
+  @doc """
+  Gets a single user.
+
+  Raises `Ecto.NoResultsError` if the User does not exist.
+
+  ## Examples
+
+      iex> get_user!(123)
+      %User{}
+
+      iex> get_user!(456)
+      ** (Ecto.NoResultsError)
+
+  """
+  def get_user!(id), do: Repo.get!(User, id)
+
+  @doc """
+  Gets a single user by username.
+
+  Returns nil if the User does not exist.
+
+  ## Examples
+
+      iex> get_user_by_username("johndoe")
+      %User{}
+
+      iex> get_user_by_username("nonexistent")
+      nil
+
+  """
+  def get_user_by_username(username) when is_binary(username) do
+    Repo.get_by(User, username: username)
+  end
+
+  @doc """
+  Creates a user.
+
+  ## Examples
+
+      iex> create_user(%{field: value})
+      {:ok, %User{}}
+
+      iex> create_user(%{field: bad_value})
+      {:error, %Ecto.Changeset{}}
+
+  """
+  def create_user(attrs \\ %{}) do
+    %User{}
+    |> User.changeset(attrs)
+    |> Repo.insert()
+  end
+
+  @doc """
+  Updates a user.
+
+  ## Examples
+
+      iex> update_user(user, %{field: new_value})
+      {:ok, %User{}}
+
+      iex> update_user(user, %{field: bad_value})
+      {:error, %Ecto.Changeset{}}
+
+  """
+  def update_user(%User{} = user, attrs) do
+    user
+    |> User.changeset(attrs)
+    |> Repo.update()
+  end
+
+  @doc """
+  Deletes a user.
+
+  ## Examples
+
+      iex> delete_user(user)
+      {:ok, %User{}}
+
+      iex> delete_user(user)
+      {:error, %Ecto.Changeset{}}
+
+  """
+  def delete_user(%User{} = user) do
+    Repo.delete(user)
+  end
+
+  @doc """
+  Returns an `%Ecto.Changeset{}` for tracking user changes.
+
+  ## Examples
+
+      iex> change_user(user)
+      %Ecto.Changeset{data: %User{}}
+
+  """
+  def change_user(%User{} = user, attrs \\ %{}) do
+    User.changeset(user, attrs)
+  end
+end

lib/bookmarker/accounts/user.ex

···
+defmodule Bookmarker.Accounts.User do
+  use Ecto.Schema
+  import Ecto.Changeset
+
+  schema "users" do
+    field :username, :string
+    field :email, :string
+    field :display_name, :string
+
+    has_many :bookmarks, Bookmarker.Bookmarks.Bookmark
+    has_many :comments, Bookmarker.Comments.Comment
+
+    timestamps()
+  end
+
+  @doc false
+  def changeset(user, attrs) do
+    user
+    |> cast(attrs, [:username, :email, :display_name])
+    |> validate_required([:username, :email])
+    |> validate_format(:email, ~r/^[^\s]+@[^\s]+$/, message: "must have the @ sign and no spaces")
+    |> validate_length(:username, min: 3, max: 30)
+    |> validate_length(:email, max: 160)
+    |> unique_constraint(:username)
+    |> unique_constraint(:email)
+  end
+end

lib/bookmarker/application.ex

···
       {Phoenix.PubSub, name: Bookmarker.PubSub},
       # Start the Finch HTTP client for sending emails
       {Finch, name: Bookmarker.Finch},
-      # Start a worker by calling: Bookmarker.Worker.start_link(arg)
-      # {Bookmarker.Worker, arg},
+      # Start the ETS cache for bookmarks
+      {Bookmarker.Cache, []},
+      # Start the Bluesky connection for simulating bookmark traffic
+      {BlueskyHose, []},
       # Start to serve requests, typically the last entry
       BookmarkerWeb.Endpoint
     ]

lib/bookmarker/bookmarks.ex

···
+defmodule Bookmarker.Bookmarks do
+  @moduledoc """
+  The Bookmarks context.
+  """
+
+  import Ecto.Query, warn: false
+  alias Bookmarker.Repo
+  alias Bookmarker.Bookmarks.Bookmark
+  alias Bookmarker.Tags
+  alias Phoenix.PubSub
+
+  @topic "bookmarks"
+
+  @doc """
+  Returns the list of bookmarks.
+
+  ## Examples
+
+      iex> list_bookmarks()
+      [%Bookmark{}, ...]
+
+  """
+  def list_bookmarks do
+    Repo.all(Bookmark)
+    |> Repo.preload([:user, :tags])
+  end
+
+  @doc """
+  Returns the list of recent bookmarks, ordered by insertion date.
+
+  ## Examples
+
+      iex> list_recent_bookmarks(20)
+      [%Bookmark{}, ...]
+
+  """
+  def list_recent_bookmarks(limit \\ 20) do
+    Bookmark
+    |> order_by([b], desc: b.inserted_at)
+    |> limit(^limit)
+    |> Repo.all()
+    |> Repo.preload([:user, :tags])
+  end
+
+  @doc """
+  Gets a single bookmark.
+
+  Raises `Ecto.NoResultsError` if the Bookmark does not exist.
+
+  ## Examples
+
+      iex> get_bookmark!(123)
+      %Bookmark{}
+
+      iex> get_bookmark!(456)
+      ** (Ecto.NoResultsError)
+
+  """
+  def get_bookmark!(id) do
+    Bookmark
+    |> Repo.get!(id)
+    |> Repo.preload([:user, :tags, comments: [:user]])
+  end
+
+  @doc """
+  Creates a bookmark.
+
+  ## Examples
+
+      iex> create_bookmark(%{field: value}, ["tag1", "tag2"])
+      {:ok, %Bookmark{}}
+
+      iex> create_bookmark(%{field: bad_value}, [])
+      {:error, %Ecto.Changeset{}}
+
+  """
+  def create_bookmark(attrs \\ %{}, tag_names \\ []) do
+    tags = Tags.get_or_create_tags(tag_names)
+
+    result =
+      %Bookmark{}
+      |> Bookmark.changeset(attrs, tags)
+      |> Repo.insert()
+
+    case result do
+      {:ok, bookmark} ->
+        bookmark = Repo.preload(bookmark, [:user, :tags])
+        broadcast({:bookmark_created, bookmark})
+        {:ok, bookmark}
+
+      error ->
+        error
+    end
+  end
+
+  @doc """
+  Updates a bookmark.
+
+  ## Examples
+
+      iex> update_bookmark(bookmark, %{field: new_value}, ["tag1", "tag2"])
+      {:ok, %Bookmark{}}
+
+      iex> update_bookmark(bookmark, %{field: bad_value}, [])
+      {:error, %Ecto.Changeset{}}
+
+  """
+  def update_bookmark(%Bookmark{} = bookmark, attrs, tag_names \\ []) do
+    tags = Tags.get_or_create_tags(tag_names)
+
+    result =
+      bookmark
+      |> Bookmark.changeset(attrs, tags)
+      |> Repo.update()
+
+    case result do
+      {:ok, bookmark} ->
+        bookmark = Repo.preload(bookmark, [:user, :tags])
+        broadcast({:bookmark_updated, bookmark})
+        {:ok, bookmark}
+
+      error ->
+        error
+    end
+  end
+
+  @doc """
+  Deletes a bookmark.
+
+  ## Examples
+
+      iex> delete_bookmark(bookmark)
+      {:ok, %Bookmark{}}
+
+      iex> delete_bookmark(bookmark)
+      {:error, %Ecto.Changeset{}}
+
+  """
+  def delete_bookmark(%Bookmark{} = bookmark) do
+    result = Repo.delete(bookmark)
+
+    case result do
+      {:ok, bookmark} ->
+        broadcast({:bookmark_deleted, bookmark})
+        {:ok, bookmark}
+
+      error ->
+        error
+    end
+  end
+
+  @doc """
+  Returns an `%Ecto.Changeset{}` for tracking bookmark changes.
+
+  ## Examples
+
+      iex> change_bookmark(bookmark)
+      %Ecto.Changeset{data: %Bookmark{}}
+
+  """
+  def change_bookmark(%Bookmark{} = bookmark, attrs \\ %{}) do
+    Bookmark.changeset(bookmark, attrs)
+  end
+
+  @doc """
+  Returns the list of bookmarks for a specific user.
+
+  ## Examples
+
+      iex> list_user_bookmarks(user_id)
+      [%Bookmark{}, ...]
+
+  """
+  def list_user_bookmarks(user_id) do
+    Bookmark
+    |> where([b], b.user_id == ^user_id)
+    |> order_by([b], desc: b.inserted_at)
+    |> Repo.all()
+    |> Repo.preload([:user, :tags])
+  end
+
+  @doc """
+  Returns the list of bookmarks with a specific tag.
+
+  ## Examples
+
+      iex> list_bookmarks_by_tag("elixir")
+      [%Bookmark{}, ...]
+
+  """
+  def list_bookmarks_by_tag(tag_name) when is_binary(tag_name) do
+    tag = Tags.get_tag_by_name(tag_name)
+
+    if tag do
+      Bookmark
+      |> join(:inner, [b], bt in "bookmark_tags", on: b.id == bt.bookmark_id)
+      |> where([_, bt], bt.tag_id == ^tag.id)
+      |> order_by([b], desc: b.inserted_at)
+      |> Repo.all()
+      |> Repo.preload([:user, :tags])
+    else
+      []
+    end
+  end
+
+  @doc """
+  Returns the list of bookmarks with all of the specified tags.
+
+  ## Examples
+
+      iex> list_bookmarks_by_tags(["elixir", "phoenix"])
+      [%Bookmark{}, ...]
+
+  """
+  def list_bookmarks_by_tags(tag_names) when is_list(tag_names) and length(tag_names) > 0 do
+    # Get tag IDs
+    tag_ids =
+      tag_names
+      |> Enum.map(&Tags.get_tag_by_name/1)
+      |> Enum.reject(&is_nil/1)
+      |> Enum.map(& &1.id)
+
+    if Enum.empty?(tag_ids) do
+      []
+    else
+      # Count how many of the requested tags each bookmark has
+      tag_count_query =
+        from bt in "bookmark_tags",
+          where: bt.tag_id in ^tag_ids,
+          group_by: bt.bookmark_id,
+          select: {bt.bookmark_id, count(bt.tag_id)}
+
+      # Only select bookmarks that have all the requested tags
+      Bookmark
+      |> join(:inner, [b], tc in subquery(tag_count_query), on: b.id == tc.bookmark_id)
+      |> where([_, tc], tc.count == ^length(tag_ids))
+      |> order_by([b], desc: b.inserted_at)
+      |> Repo.all()
+      |> Repo.preload([:user, :tags])
+    end
+  end
+
+  def list_bookmarks_by_tags(_), do: []
+
+  @doc """
+  Subscribe to bookmark events.
+  """
+  def subscribe do
+    PubSub.subscribe(Bookmarker.PubSub, @topic)
+  end
+
+  @doc """
+  Subscribe to bookmark events for a specific tag.
+  """
+  def subscribe_to_tag(tag_name) when is_binary(tag_name) do
+    PubSub.subscribe(Bookmarker.PubSub, "#{@topic}:tag:#{tag_name}")
+  end
+
+  # Broadcast a bookmark event.
+  defp broadcast({_event, bookmark} = message) do
+    PubSub.broadcast(Bookmarker.PubSub, @topic, message)
+
+    # Also broadcast to tag-specific topics
+    Enum.each(bookmark.tags, fn tag ->
+      PubSub.broadcast(
+        Bookmarker.PubSub,
+        "#{@topic}:tag:#{tag.name}",
+        message
+      )
+    end)
+
+    :ok
+  end
+end

lib/bookmarker/bookmarks/bookmark.ex

···
+defmodule Bookmarker.Bookmarks.Bookmark do
+  use Ecto.Schema
+  import Ecto.Changeset
+
+  schema "bookmarks" do
+    field :url, :string
+    field :title, :string
+    field :description, :string
+
+    belongs_to :user, Bookmarker.Accounts.User
+    many_to_many :tags, Bookmarker.Tags.Tag,
+      join_through: Bookmarker.Bookmarks.BookmarkTag,
+      on_replace: :delete
+    has_many :comments, Bookmarker.Comments.Comment
+
+    timestamps()
+  end
+
+  @doc false
+  def changeset(bookmark, attrs, tags \\ []) do
+    bookmark
+    |> cast(attrs, [:url, :title, :description, :user_id])
+    |> validate_required([:url, :title, :user_id])
+    |> validate_length(:title, min: 1, max: 255)
+    |> validate_length(:url, min: 5, max: 2048)
+    |> foreign_key_constraint(:user_id)
+    |> put_assoc(:tags, tags)
+  end
+end

lib/bookmarker/bookmarks/bookmark_tag.ex

···
+defmodule Bookmarker.Bookmarks.BookmarkTag do
+  use Ecto.Schema
+  import Ecto.Changeset
+
+  @primary_key false
+  schema "bookmark_tags" do
+    belongs_to :bookmark, Bookmarker.Bookmarks.Bookmark
+    belongs_to :tag, Bookmarker.Tags.Tag
+
+    timestamps()
+  end
+
+  @doc false
+  def changeset(bookmark_tag, attrs) do
+    bookmark_tag
+    |> cast(attrs, [:bookmark_id, :tag_id])
+    |> validate_required([:bookmark_id, :tag_id])
+    |> unique_constraint([:bookmark_id, :tag_id])
+  end
+end

lib/bookmarker/cache.ex

···
+defmodule Bookmarker.Cache do
+  @moduledoc """
+  ETS-based cache for bookmarks and related data.
+  """
+
+  use GenServer
+  alias Bookmarker.Bookmarks
+  alias Bookmarker.Tags
+  alias Phoenix.PubSub
+
+  @bookmarks_table :bookmarks_cache
+  @tags_table :tags_cache
+  @tag_bookmarks_table :tag_bookmarks_cache
+
+  # Client API
+
+  def start_link(_opts) do
+    GenServer.start_link(__MODULE__, :ok, name: __MODULE__)
+  end
+
+  @doc """
+  Get recent bookmarks from the cache.
+  """
+  def get_recent_bookmarks(limit \\ 20) do
+    case :ets.lookup(@bookmarks_table, :recent) do
+      [{:recent, bookmarks}] -> Enum.take(bookmarks, limit)
+      [] -> []
+    end
+  end
+
+  @doc """
+  Get bookmarks for a specific tag from the cache.
+  """
+  def get_bookmarks_by_tag(tag_name) do
+    case :ets.lookup(@tag_bookmarks_table, tag_name) do
+      [{^tag_name, bookmarks}] -> bookmarks
+      [] -> []
+    end
+  end
+
+  @doc """
+  Get all tags from the cache.
+  """
+  def get_all_tags do
+    case :ets.lookup(@tags_table, :all) do
+      [{:all, tags}] -> tags
+      [] -> []
+    end
+  end
+
+  # Server callbacks
+
+  @impl true
+  def init(:ok) do
+    # Create ETS tables
+    :ets.new(@bookmarks_table, [:set, :named_table, :public, read_concurrency: true])
+    :ets.new(@tags_table, [:set, :named_table, :public, read_concurrency: true])
+    :ets.new(@tag_bookmarks_table, [:set, :named_table, :public, read_concurrency: true])
+
+    # Initialize cache with data from the database
+    initialize_cache()
+
+    # Subscribe to bookmark events
+    PubSub.subscribe(Bookmarker.PubSub, "bookmarks")
+
+    {:ok, %{}}
+  end
+
+  @impl true
+  def handle_info({:bookmark_created, bookmark}, state) do
+    update_bookmarks_cache(bookmark, :add)
+    update_tag_bookmarks_cache(bookmark, :add)
+    {:noreply, state}
+  end
+
+  @impl true
+  def handle_info({:bookmark_updated, bookmark}, state) do
+    update_bookmarks_cache(bookmark, :update)
+    update_tag_bookmarks_cache(bookmark, :update)
+    {:noreply, state}
+  end
+
+  @impl true
+  def handle_info({:bookmark_deleted, bookmark}, state) do
+    update_bookmarks_cache(bookmark, :remove)
+    update_tag_bookmarks_cache(bookmark, :remove)
+    {:noreply, state}
+  end
+
+  @impl true
+  def handle_info(_, state), do: {:noreply, state}
+
+  # Private functions
+
+  defp initialize_cache do
+    # Cache recent bookmarks
+    bookmarks = Bookmarks.list_recent_bookmarks(100)
+    :ets.insert(@bookmarks_table, {:recent, bookmarks})
+
+    # Cache all tags
+    tags = Tags.list_tags()
+    :ets.insert(@tags_table, {:all, tags})
+
+    # Cache bookmarks by tag
+    Enum.each(tags, fn tag ->
+      bookmarks = Bookmarks.list_bookmarks_by_tag(tag.name)
+      :ets.insert(@tag_bookmarks_table, {tag.name, bookmarks})
+    end)
+  end
+
+  defp update_bookmarks_cache(bookmark, action) do
+    case :ets.lookup(@bookmarks_table, :recent) do
+      [{:recent, bookmarks}] ->
+        updated_bookmarks =
+          case action do
+            :add ->
+              [bookmark | bookmarks]
+              |> Enum.sort_by(& &1.inserted_at, {:desc, NaiveDateTime})
+              |> Enum.take(100)
+
+            :update ->
+              bookmarks
+              |> Enum.map(fn b -> if b.id == bookmark.id, do: bookmark, else: b end)
+              |> Enum.sort_by(& &1.inserted_at, {:desc, NaiveDateTime})
+
+            :remove ->
+              bookmarks
+              |> Enum.reject(fn b -> b.id == bookmark.id end)
+          end
+
+        :ets.insert(@bookmarks_table, {:recent, updated_bookmarks})
+
+      [] ->
+        :ets.insert(@bookmarks_table, {:recent, [bookmark]})
+    end
+  end
+
+  defp update_tag_bookmarks_cache(bookmark, action) do
+    # For each tag in the bookmark, update the tag's bookmarks list
+    Enum.each(bookmark.tags, fn tag ->
+      case :ets.lookup(@tag_bookmarks_table, tag.name) do
+        [{tag_name, bookmarks}] ->
+          updated_bookmarks =
+            case action do
+              :add ->
+                [bookmark | bookmarks]
+                |> Enum.sort_by(& &1.inserted_at, {:desc, NaiveDateTime})
+
+              :update ->
+                bookmarks
+                |> Enum.map(fn b -> if b.id == bookmark.id, do: bookmark, else: b end)
+                |> Enum.sort_by(& &1.inserted_at, {:desc, NaiveDateTime})
+
+              :remove ->
+                bookmarks
+                |> Enum.reject(fn b -> b.id == bookmark.id end)
+            end
+
+          :ets.insert(@tag_bookmarks_table, {tag_name, updated_bookmarks})
+
+        [] ->
+          :ets.insert(@tag_bookmarks_table, {tag.name, [bookmark]})
+      end
+    end)
+
+    # If this is an update or remove, we need to check if any tags were removed
+    if action in [:update, :remove] do
+      # Get the bookmark from the database to compare tags
+      case action do
+        :update ->
+          old_bookmark = Bookmarks.get_bookmark!(bookmark.id)
+          old_tags = MapSet.new(old_bookmark.tags, & &1.name)
+          new_tags = MapSet.new(bookmark.tags, & &1.name)
+          removed_tags = MapSet.difference(old_tags, new_tags)
+
+          # For each removed tag, update its bookmarks list
+          Enum.each(removed_tags, fn tag_name ->
+            case :ets.lookup(@tag_bookmarks_table, tag_name) do
+              [{^tag_name, bookmarks}] ->
+                updated_bookmarks = Enum.reject(bookmarks, fn b -> b.id == bookmark.id end)
+                :ets.insert(@tag_bookmarks_table, {tag_name, updated_bookmarks})
+              [] -> :ok
+            end
+          end)
+
+        :remove ->
+          # For a delete, we've already handled the tags in the bookmark
+          :ok
+      end
+    end
+  end
+end

lib/bookmarker/comments.ex

···
+defmodule Bookmarker.Comments do
+  @moduledoc """
+  The Comments context.
+  """
+
+  import Ecto.Query, warn: false
+  alias Bookmarker.Repo
+  alias Bookmarker.Comments.Comment
+  alias Phoenix.PubSub
+
+  @topic "comments"
+
+  @doc """
+  Returns the list of comments.
+
+  ## Examples
+
+      iex> list_comments()
+      [%Comment{}, ...]
+
+  """
+  def list_comments do
+    Repo.all(Comment)
+    |> Repo.preload([:user, :bookmark])
+  end
+
+  @doc """
+  Gets a single comment.
+
+  Raises `Ecto.NoResultsError` if the Comment does not exist.
+
+  ## Examples
+
+      iex> get_comment!(123)
+      %Comment{}
+
+      iex> get_comment!(456)
+      ** (Ecto.NoResultsError)
+
+  """
+  def get_comment!(id) do
+    Comment
+    |> Repo.get!(id)
+    |> Repo.preload([:user, :bookmark])
+  end
+
+  @doc """
+  Creates a comment.
+
+  ## Examples
+
+      iex> create_comment(%{field: value})
+      {:ok, %Comment{}}
+
+      iex> create_comment(%{field: bad_value})
+      {:error, %Ecto.Changeset{}}
+
+  """
+  def create_comment(attrs \\ %{}) do
+    result =
+      %Comment{}
+      |> Comment.changeset(attrs)
+      |> Repo.insert()
+
+    case result do
+      {:ok, comment} ->
+        comment = Repo.preload(comment, [:user, :bookmark])
+        broadcast({:comment_created, comment})
+        broadcast_to_bookmark(comment.bookmark_id, {:comment_created, comment})
+        {:ok, comment}
+
+      error ->
+        error
+    end
+  end
+
+  @doc """
+  Updates a comment.
+
+  ## Examples
+
+      iex> update_comment(comment, %{field: new_value})
+      {:ok, %Comment{}}
+
+      iex> update_comment(comment, %{field: bad_value})
+      {:error, %Ecto.Changeset{}}
+
+  """
+  def update_comment(%Comment{} = comment, attrs) do
+    result =
+      comment
+      |> Comment.changeset(attrs)
+      |> Repo.update()
+
+    case result do
+      {:ok, comment} ->
+        comment = Repo.preload(comment, [:user, :bookmark])
+        broadcast({:comment_updated, comment})
+        broadcast_to_bookmark(comment.bookmark_id, {:comment_updated, comment})
+        {:ok, comment}
+
+      error ->
+        error
+    end
+  end
+
+  @doc """
+  Deletes a comment.
+
+  ## Examples
+
+      iex> delete_comment(comment)
+      {:ok, %Comment{}}
+
+      iex> delete_comment(comment)
+      {:error, %Ecto.Changeset{}}
+
+  """
+  def delete_comment(%Comment{} = comment) do
+    bookmark_id = comment.bookmark_id
+    result = Repo.delete(comment)
+
+    case result do
+      {:ok, comment} ->
+        broadcast({:comment_deleted, comment})
+        broadcast_to_bookmark(bookmark_id, {:comment_deleted, comment})
+        {:ok, comment}
+
+      error ->
+        error
+    end
+  end
+
+  @doc """
+  Returns an `%Ecto.Changeset{}` for tracking comment changes.
+
+  ## Examples
+
+      iex> change_comment(comment)
+      %Ecto.Changeset{data: %Comment{}}
+
+  """
+  def change_comment(%Comment{} = comment, attrs \\ %{}) do
+    Comment.changeset(comment, attrs)
+  end
+
+  @doc """
+  Returns the list of comments for a specific bookmark.
+
+  ## Examples
+
+      iex> list_bookmark_comments(bookmark_id)
+      [%Comment{}, ...]
+
+  """
+  def list_bookmark_comments(bookmark_id) do
+    Comment
+    |> where([c], c.bookmark_id == ^bookmark_id)
+    |> order_by([c], asc: c.inserted_at)
+    |> Repo.all()
+    |> Repo.preload([:user])
+  end
+
+  @doc """
+  Subscribe to comment events.
+  """
+  def subscribe do
+    PubSub.subscribe(Bookmarker.PubSub, @topic)
+  end
+
+  @doc """
+  Subscribe to comment events for a specific bookmark.
+  """
+  def subscribe_to_bookmark(bookmark_id) do
+    PubSub.subscribe(Bookmarker.PubSub, "#{@topic}:bookmark:#{bookmark_id}")
+  end
+
+  # Broadcast a comment event.
+  defp broadcast(message) do
+    PubSub.broadcast(Bookmarker.PubSub, @topic, message)
+    :ok
+  end
+
+  # Broadcast a comment event to a specific bookmark topic.
+  defp broadcast_to_bookmark(bookmark_id, message) do
+    PubSub.broadcast(Bookmarker.PubSub, "#{@topic}:bookmark:#{bookmark_id}", message)
+    :ok
+  end
+end

lib/bookmarker/comments/comment.ex

···
+defmodule Bookmarker.Comments.Comment do
+  use Ecto.Schema
+  import Ecto.Changeset
+
+  schema "comments" do
+    field :content, :string
+
+    belongs_to :user, Bookmarker.Accounts.User
+    belongs_to :bookmark, Bookmarker.Bookmarks.Bookmark
+
+    timestamps()
+  end
+
+  @doc false
+  def changeset(comment, attrs) do
+    comment
+    |> cast(attrs, [:content, :user_id, :bookmark_id])
+    |> validate_required([:content, :user_id, :bookmark_id])
+    |> validate_length(:content, min: 1, max: 2000)
+    |> foreign_key_constraint(:user_id)
+    |> foreign_key_constraint(:bookmark_id)
+  end
+end

lib/bookmarker/tags.ex

···
+defmodule Bookmarker.Tags do
+  @moduledoc """
+  The Tags context.
+  """
+
+  import Ecto.Query, warn: false
+  alias Bookmarker.Repo
+
+  alias Bookmarker.Tags.Tag
+
+  @doc """
+  Returns the list of tags.
+
+  ## Examples
+
+      iex> list_tags()
+      [%Tag{}, ...]
+
+  """
+  def list_tags do
+    Repo.all(Tag)
+  end
+
+  @doc """
+  Gets a single tag.
+
+  Raises `Ecto.NoResultsError` if the Tag does not exist.
+
+  ## Examples
+
+      iex> get_tag!(123)
+      %Tag{}
+
+      iex> get_tag!(456)
+      ** (Ecto.NoResultsError)
+
+  """
+  def get_tag!(id), do: Repo.get!(Tag, id)
+
+  @doc """
+  Gets a single tag by name.
+
+  Returns nil if the Tag does not exist.
+
+  ## Examples
+
+      iex> get_tag_by_name("elixir")
+      %Tag{}
+
+      iex> get_tag_by_name("nonexistent")
+      nil
+
+  """
+  def get_tag_by_name(name) when is_binary(name) do
+    Repo.get_by(Tag, name: String.downcase(name))
+  end
+
+  @doc """
+  Creates a tag if it doesn't exist.
+
+  ## Examples
+
+      iex> create_or_get_tag("elixir")
+      {:ok, %Tag{}}
+
+  """
+  def create_or_get_tag(name) when is_binary(name) do
+    name = String.downcase(name)
+    case get_tag_by_name(name) do
+      nil ->
+        create_tag(%{name: name})
+      tag ->
+        {:ok, tag}
+    end
+  end
+
+  @doc """
+  Creates a tag.
+
+  ## Examples
+
+      iex> create_tag(%{field: value})
+      {:ok, %Tag{}}
+
+      iex> create_tag(%{field: bad_value})
+      {:error, %Ecto.Changeset{}}
+
+  """
+  def create_tag(attrs \\ %{}) do
+    %Tag{}
+    |> Tag.changeset(attrs)
+    |> Repo.insert()
+  end
+
+  @doc """
+  Updates a tag.
+
+  ## Examples
+
+      iex> update_tag(tag, %{field: new_value})
+      {:ok, %Tag{}}
+
+      iex> update_tag(tag, %{field: bad_value})
+      {:error, %Ecto.Changeset{}}
+
+  """
+  def update_tag(%Tag{} = tag, attrs) do
+    tag
+    |> Tag.changeset(attrs)
+    |> Repo.update()
+  end
+
+  @doc """
+  Deletes a tag.
+
+  ## Examples
+
+      iex> delete_tag(tag)
+      {:ok, %Tag{}}
+
+      iex> delete_tag(tag)
+      {:error, %Ecto.Changeset{}}
+
+  """
+  def delete_tag(%Tag{} = tag) do
+    Repo.delete(tag)
+  end
+
+  @doc """
+  Returns an `%Ecto.Changeset{}` for tracking tag changes.
+
+  ## Examples
+
+      iex> change_tag(tag)
+      %Ecto.Changeset{data: %Tag{}}
+
+  """
+  def change_tag(%Tag{} = tag, attrs \\ %{}) do
+    Tag.changeset(tag, attrs)
+  end
+
+  @doc """
+  Creates tags from a list of names and returns them.
+
+  ## Examples
+
+      iex> get_or_create_tags(["elixir", "phoenix"])
+      [%Tag{}, %Tag{}]
+
+  """
+  def get_or_create_tags(tag_names) when is_list(tag_names) do
+    tag_names
+    |> Enum.map(&String.trim/1)
+    |> Enum.reject(&(&1 == ""))
+    |> Enum.map(fn name ->
+      {:ok, tag} = create_or_get_tag(name)
+      tag
+    end)
+  end
+
+  @doc """
+  Returns the list of tags with bookmark counts.
+  The result includes the tag and a count of how many bookmarks are associated with it.
+
+  ## Examples
+
+      iex> list_tags_with_counts()
+      [%{tag: %Tag{}, count: 5}, %{tag: %Tag{}, count: 2}, ...]
+
+  """
+  def list_tags_with_counts do
+    query = from t in Tag,
+      left_join: bt in "bookmark_tags",
+      on: t.id == bt.tag_id,
+      group_by: t.id,
+      select: {t, count(bt.bookmark_id)}
+
+    Repo.all(query)
+    |> Enum.map(fn {tag, count} -> %{tag: tag, count: count} end)
+  end
+end

lib/bookmarker/tags/tag.ex

···
+defmodule Bookmarker.Tags.Tag do
+  use Ecto.Schema
+  import Ecto.Changeset
+
+  schema "tags" do
+    field :name, :string
+
+    many_to_many :bookmarks, Bookmarker.Bookmarks.Bookmark,
+      join_through: Bookmarker.Bookmarks.BookmarkTag
+
+    timestamps()
+  end
+
+  @doc false
+  def changeset(tag, attrs) do
+    tag
+    |> cast(attrs, [:name])
+    |> validate_required([:name])
+    |> validate_length(:name, min: 1, max: 50)
+    |> unique_constraint(:name)
+    |> update_change(:name, &String.downcase/1)
+  end
+end

lib/bookmarker_web.ex

···
       import Phoenix.HTML
       # Core UI components
       import BookmarkerWeb.CoreComponents
+      # Form helpers
+      import Phoenix.HTML.Form
 
       # Shortcut for generating JS commands
       alias Phoenix.LiveView.JS

lib/bookmarker_web/channels/bookmark_channel.ex

···
+defmodule BookmarkerWeb.BookmarkChannel do
+  use BookmarkerWeb, :channel
+
+  alias Bookmarker.Bookmarks
+  alias Bookmarker.Cache
+
+  @impl true
+  def join("bookmarks:all", _payload, socket) do
+    # Send initial data to the client
+    bookmarks = Cache.get_recent_bookmarks(20)
+
+    # Subscribe to bookmark events
+    Bookmarks.subscribe()
+
+    {:ok, %{bookmarks: bookmarks}, socket}
+  end
+
+  @impl true
+  def join("bookmarks:tag:" <> tag_name, _payload, socket) do
+    # Send initial data to the client
+    bookmarks = Cache.get_bookmarks_by_tag(tag_name)
+
+    # Subscribe to tag-specific bookmark events
+    Bookmarks.subscribe_to_tag(tag_name)
+
+    {:ok, %{bookmarks: bookmarks}, assign(socket, :tag, tag_name)}
+  end
+
+  @impl true
+  def join("bookmarks:user:" <> user_id, _payload, socket) do
+    {user_id, _} = Integer.parse(user_id)
+    bookmarks = Bookmarks.list_user_bookmarks(user_id)
+
+    {:ok, %{bookmarks: bookmarks}, assign(socket, :user_id, user_id)}
+  end
+
+  # Handle incoming messages from clients
+  @impl true
+  def handle_in("new_bookmark", %{"url" => url, "title" => title, "description" => description, "tags" => tags, "user_id" => user_id}, socket) do
+    case Bookmarks.create_bookmark(%{url: url, title: title, description: description, user_id: user_id}, tags) do
+      {:ok, bookmark} ->
+        {:reply, {:ok, %{bookmark: bookmark}}, socket}
+      {:error, changeset} ->
+        {:reply, {:error, %{errors: changeset}}, socket}
+    end
+  end
+
+  # Handle PubSub events
+  @impl true
+  def handle_info({:bookmark_created, bookmark}, socket) do
+    push(socket, "bookmark_created", %{bookmark: bookmark})
+    {:noreply, socket}
+  end
+
+  @impl true
+  def handle_info({:bookmark_updated, bookmark}, socket) do
+    push(socket, "bookmark_updated", %{bookmark: bookmark})
+    {:noreply, socket}
+  end
+
+  @impl true
+  def handle_info({:bookmark_deleted, bookmark}, socket) do
+    push(socket, "bookmark_deleted", %{bookmark: bookmark})
+    {:noreply, socket}
+  end
+end

lib/bookmarker_web/channels/user_socket.ex

···
+defmodule BookmarkerWeb.UserSocket do
+  use Phoenix.Socket
+
+  # A Socket handler
+  #
+  # It's possible to control the websocket connection and
+  # assign values that can be accessed by your channel topics.
+
+  ## Channels
+  channel "bookmarks:*", BookmarkerWeb.BookmarkChannel
+
+  # Socket params are passed from the client and can
+  # be used to verify and authenticate a user. After
+  # verification, you can put default assigns into
+  # the socket that will be set for all channels, ie
+  #
+  #     {:ok, assign(socket, :user_id, verified_user_id)}
+  #
+  # To deny connection, return `:error` or `{:error, term}`. To control the
+  # response the client receives in that case, use `{:error, view, options}`.
+  #
+  # See `Phoenix.Token` documentation for examples in
+  # performing token verification on connect.
+  @impl true
+  def connect(_params, socket, _connect_info) do
+    # For simplicity, we're not implementing authentication
+    # In a real app, you would authenticate the user here
+    {:ok, socket}
+  end
+
+  # Socket id's are topics that allow you to identify all sockets for a given user:
+  #
+  #     def id(socket), do: "user_socket:#{socket.assigns.user_id}"
+  #
+  # Would allow you to broadcast a "disconnect" event and terminate
+  # all active sockets and channels for a given user:
+  #
+  #     Elixir.BookmarkerWeb.Endpoint.broadcast("user_socket:#{user.id}", "disconnect", %{})
+  #
+  # Returning `nil` makes this socket anonymous.
+  @impl true
+  def id(_socket), do: nil
+end

lib/bookmarker_web/components/core_components.ex

···
   Translates an error message using gettext.
   """
   def translate_error({msg, opts}) do
-    # When using gettext, we typically pass the strings we want
-    # to translate as a static argument:
-    #
-    #     # Translate the number of files with plural rules
-    #     dngettext("errors", "1 file", "%{count} files", count)
-    #
-    # However the error messages in our forms and APIs are generated
-    # dynamically, so we need to translate them by calling Gettext
-    # with our gettext backend as first argument. Translations are
-    # available in the errors.po file (as we use the "errors" domain).
     if count = opts[:count] do
       Gettext.dngettext(BookmarkerWeb.Gettext, "errors", msg, msg, count, opts)
     else
···
   """
   def translate_errors(errors, field) when is_list(errors) do
     for {^field, {msg, opts}} <- errors, do: translate_error({msg, opts})
+  end
+
+  @doc """
+  Renders an error message for the given field.
+
+  ## Examples
+
+      <.error_tag field={@form[:email]} />
+
+  """
+  attr :field, Phoenix.HTML.FormField, required: true
+
+  def error_tag(assigns) do
+    ~H"""
+    <%= for error <- Enum.map(@field.errors, &translate_error(&1)) do %>
+      <span class="invalid-feedback block mt-1 text-sm text-red-600" phx-feedback-for={@field.name}>
+        <%= error %>
+      </span>
+    <% end %>
+    """
+  end
+
+  # Renders a text input field
+  attr :form, :any, required: true
+  attr :field, :atom, required: true
+  attr :rest, :global
+
+  def text_input(assigns) do
+    ~H"""
+    <input
+      type="text"
+      name={Phoenix.HTML.Form.input_name(@form, @field)}
+      id={Phoenix.HTML.Form.input_id(@form, @field)}
+      value={Phoenix.HTML.Form.input_value(@form, @field)}
+      class="rounded-md border-0 bg-white/5 px-3.5 py-2 shadow-sm ring-1 ring-inset ring-white/10 focus:ring-2 focus:ring-inset focus:ring-indigo-500 sm:text-sm sm:leading-6"
+      {@rest}
+    />
+    """
+  end
+
+  # Renders a textarea field
+  attr :form, :any, required: true
+  attr :field, :atom, required: true
+  attr :rest, :global
+
+  def textarea(assigns) do
+    ~H"""
+    <textarea
+      name={Phoenix.HTML.Form.input_name(@form, @field)}
+      id={Phoenix.HTML.Form.input_id(@form, @field)}
+      class="min-h-[6rem] w-full rounded-lg border-2 border-zinc-300 p-3 leading-snug placeholder:text-zinc-500 focus:border-zinc-500 focus:outline-none"
+      {@rest}
+    ><%= Phoenix.HTML.Form.input_value(@form, @field) %></textarea>
+    """
+  end
+
+  # Renders a form field label
+  attr :form, :any, required: true
+  attr :field, :atom, required: true
+  attr :text, :string, required: true
+  attr :rest, :global, default: %{}
+
+  def form_label(assigns) do
+    ~H"""
+    <label for={Phoenix.HTML.Form.input_id(@form, @field)} {@rest}>
+      <%= @text %>
+    </label>
+    """
+  end
+
+  # Renders a submit button
+  attr :text, :string, required: true
+  attr :rest, :global, default: %{}
+
+  def submit(assigns) do
+    ~H"""
+    <button type="submit" {@rest}>
+      <%= @text %>
+    </button>
+    """
   end
 end

lib/bookmarker_web/components/layouts/app.html.heex

···
         <img src={~p"/images/logo.svg"} width="36" />
       </a>
       <p class="bg-brand/5 text-brand rounded-full px-2 font-medium leading-6">
-        v{Application.spec(:phoenix, :vsn)}
+        Bookmarker
       </p>
     </div>
     <div class="flex items-center gap-4 font-semibold leading-6 text-zinc-900">
-      <a href="https://twitter.com/elixirphoenix" class="hover:text-zinc-700">
-        @elixirphoenix
+      <a href={~p"/"} class="hover:text-zinc-700">
+        Home
       </a>
-      <a href="https://github.com/phoenixframework/phoenix" class="hover:text-zinc-700">
-        GitHub
+      <a href={~p"/tags"} class="hover:text-zinc-700">
+        Tag Cloud
       </a>
       <a
-        href="https://hexdocs.pm/phoenix/overview.html"
-        class="rounded-lg bg-zinc-100 px-2 py-1 hover:bg-zinc-200/80"
+        href={~p"/bookmarks/new"}
+        class="rounded-lg bg-indigo-500 text-white px-3 py-1 hover:bg-indigo-600"
       >
-        Get Started <span aria-hidden="true">&rarr;</span>
+        Add Bookmark <span aria-hidden="true">&rarr;</span>
       </a>
     </div>
   </div>
 </header>
-<main class="px-4 py-20 sm:px-6 lg:px-8">
-  <div class="mx-auto max-w-2xl">
+<main class="px-4 py-10 sm:px-6 lg:px-8">
+  <div class="mx-auto max-w-4xl">
     <.flash_group flash={@flash} />
     {@inner_content}
   </div>

lib/bookmarker_web/endpoint.ex

···
     same_site: "Lax"
   ]
 
+  socket "/socket", BookmarkerWeb.UserSocket,
+    websocket: true,
+    longpoll: false
+
   socket "/live", Phoenix.LiveView.Socket,
     websocket: [connect_info: [session: @session_options]],
     longpoll: [connect_info: [session: @session_options]]

lib/bookmarker_web/live/bookmark_live/new.ex

···
+defmodule BookmarkerWeb.BookmarkLive.New do
+  use BookmarkerWeb, :live_view
+
+  alias Bookmarker.Bookmarks
+  alias Bookmarker.Bookmarks.Bookmark
+  alias Bookmarker.Accounts
+
+  @impl true
+  def mount(_params, _session, socket) do
+    # For demo purposes, let's get the first user or create one
+    user = get_or_create_demo_user()
+
+    {:ok,
+     socket
+     |> assign(:current_user, user)
+     |> assign(:changeset, Bookmarks.change_bookmark(%Bookmark{}))
+     |> assign(:tag_input, "")
+     |> assign(:page_title, "Add Bookmark")}
+  end
+
+  @impl true
+  def handle_event("validate", %{"bookmark" => bookmark_params, "tag_input" => tag_input}, socket) do
+    changeset =
+      %Bookmark{}
+      |> Bookmarks.change_bookmark(bookmark_params)
+      |> Map.put(:action, :validate)
+
+    {:noreply,
+     socket
+     |> assign(:changeset, changeset)
+     |> assign(:tag_input, tag_input)}
+  end
+
+  @impl true
+  def handle_event("save", %{"bookmark" => bookmark_params, "tag_input" => tag_input}, socket) do
+    # Add the current user's ID to the bookmark params
+    bookmark_params = Map.put(bookmark_params, "user_id", socket.assigns.current_user.id)
+
+    # Parse tags from the tag input (comma-separated)
+    tags =
+      tag_input
+      |> String.split(",")
+      |> Enum.map(&String.trim/1)
+      |> Enum.reject(&(&1 == ""))
+
+    case Bookmarks.create_bookmark(bookmark_params, tags) do
+      {:ok, bookmark} ->
+        {:noreply,
+         socket
+         |> put_flash(:info, "Bookmark created successfully")
+         |> push_navigate(to: ~p"/bookmarks/#{bookmark}")}
+
+      {:error, %Ecto.Changeset{} = changeset} ->
+        {:noreply, assign(socket, changeset: changeset)}
+    end
+  end
+
+  defp get_or_create_demo_user do
+    case Accounts.get_user_by_username("demo_user") do
+      nil ->
+        {:ok, user} = Accounts.create_user(%{
+          username: "demo_user",
+          email: "[e-mail]",
+          display_name: "Demo User"
+        })
+        user
+      user ->
+        user
+    end
+  end
+end

lib/bookmarker_web/live/bookmark_live/new.html.heex

···
+<div class="max-w-7xl mx-auto px-4 sm:px-6 lg:px-8 py-8">
+  <div class="mb-8">
+    <.link navigate={~p"/"} class="text-indigo-600 hover:text-indigo-900 flex items-center">
+      <svg xmlns="http://www.w3.org/2000/svg" class="h-5 w-5 mr-1" viewBox="0 0 20 20" fill="currentColor">
+        <path fill-rule="evenodd" d="M9.707 16.707a1 1 0 01-1.414 0l-6-6a1 1 0 010-1.414l6-6a1 1 0 011.414 1.414L5.414 9H17a1 1 0 110 2H5.414l4.293 4.293a1 1 0 010 1.414z" clip-rule="evenodd" />
+      </svg>
+      Back to bookmarks
+    </.link>
+  </div>
+
+  <div class="bg-white shadow overflow-hidden sm:rounded-lg">
+    <div class="px-4 py-5 sm:px-6">
+      <h1 class="text-2xl font-bold text-gray-900">Add Bookmark</h1>
+    </div>
+    <div class="border-t border-gray-200 px-4 py-5 sm:px-6">
+      <.form :let={f} for={@changeset} phx-change="validate" phx-submit="save" class="space-y-6">
+        <div>
+          <.input
+            field={f[:url]}
+            type="text"
+            label="URL"
+            placeholder="https://example.com"
+            class="shadow-sm focus:ring-indigo-500 focus:border-indigo-500 block w-full sm:text-sm border-gray-300 rounded-md"
+          />
+        </div>
+
+        <div>
+          <.input
+            field={f[:title]}
+            type="text"
+            label="Title"
+            placeholder="Title of the bookmark"
+            class="shadow-sm focus:ring-indigo-500 focus:border-indigo-500 block w-full sm:text-sm border-gray-300 rounded-md"
+          />
+        </div>
+
+        <div>
+          <.input
+            field={f[:description]}
+            type="textarea"
+            label="Description"
+            placeholder="Optional description"
+            rows={3}
+            class="shadow-sm focus:ring-indigo-500 focus:border-indigo-500 block w-full sm:text-sm border-gray-300 rounded-md"
+          />
+        </div>
+
+        <div>
+          <label for="tag_input" class="block text-sm font-medium text-gray-700">Tags</label>
+          <div class="mt-1">
+            <input type="text" name="tag_input" id="tag_input" value={@tag_input} class="shadow-sm focus:ring-indigo-500 focus:border-indigo-500 block w-full sm:text-sm border-gray-300 rounded-md" placeholder="Comma-separated tags (e.g. elixir, phoenix, programming)">
+          </div>
+          <p class="mt-1 text-sm text-gray-500">Separate tags with commas</p>
+        </div>
+
+        <div>
+          <.button type="submit" class="inline-flex items-center px-4 py-2 border border-transparent text-sm font-medium rounded-md shadow-sm text-white bg-indigo-600 hover:bg-indigo-700 focus:outline-none focus:ring-2 focus:ring-offset-2 focus:ring-indigo-500">
+            Save Bookmark
+          </.button>
+        </div>
+      </.form>
+    </div>
+  </div>
+</div>

lib/bookmarker_web/live/bookmark_live/show.ex

···
+defmodule BookmarkerWeb.BookmarkLive.Show do
+  use BookmarkerWeb, :live_view
+
+  alias Bookmarker.Bookmarks
+  alias Bookmarker.Comments
+  alias Bookmarker.Accounts
+
+  @impl true
+  def mount(%{"id" => id}, _session, socket) do
+    if connected?(socket) do
+      Comments.subscribe_to_bookmark(id)
+    end
+
+    bookmark = Bookmarks.get_bookmark!(id)
+
+    # For demo purposes, let's get the first user or create one
+    user = get_or_create_demo_user()
+
+    {:ok,
+     socket
+     |> assign(:bookmark, bookmark)
+     |> assign(:current_user, user)
+     |> assign(:comment_changeset, Comments.change_comment(%Comments.Comment{}))
+     |> assign(:page_title, bookmark.title)}
+  end
+
+  @impl true
+  def handle_event("save_comment", %{"comment" => comment_params}, socket) do
+    comment_params = Map.merge(comment_params, %{
+      "user_id" => socket.assigns.current_user.id,
+      "bookmark_id" => socket.assigns.bookmark.id
+    })
+
+    case Comments.create_comment(comment_params) do
+      {:ok, _comment} ->
+        # The comment will be added via PubSub
+        {:noreply,
+         socket
+         |> put_flash(:info, "Comment added successfully")
+         |> assign(:comment_changeset, Comments.change_comment(%Comments.Comment{}))}
+
+      {:error, changeset} ->
+        {:noreply, assign(socket, :comment_changeset, changeset)}
+    end
+  end
+
+  @impl true
+  def handle_info({:comment_created, _comment}, socket) do
+    # Reload the bookmark to get the updated comments
+    bookmark = Bookmarks.get_bookmark!(socket.assigns.bookmark.id)
+    {:noreply, assign(socket, :bookmark, bookmark)}
+  end
+
+  @impl true
+  def handle_info({:comment_updated, _comment}, socket) do
+    # Reload the bookmark to get the updated comments
+    bookmark = Bookmarks.get_bookmark!(socket.assigns.bookmark.id)
+    {:noreply, assign(socket, :bookmark, bookmark)}
+  end
+
+  @impl true
+  def handle_info({:comment_deleted, _comment}, socket) do
+    # Reload the bookmark to get the updated comments
+    bookmark = Bookmarks.get_bookmark!(socket.assigns.bookmark.id)
+    {:noreply, assign(socket, :bookmark, bookmark)}
+  end
+
+  defp get_or_create_demo_user do
+    case Accounts.get_user_by_username("demo_user") do
+      nil ->
+        {:ok, user} = Accounts.create_user(%{
+          username: "demo_user",
+          email: "[e-mail]",
+          display_name: "Demo User"
+        })
+        user
+      user ->
+        user
+    end
+  end
+end

lib/bookmarker_web/live/bookmark_live/show.html.heex

···
+<div class="max-w-7xl mx-auto px-4 sm:px-6 lg:px-8 py-8">
+  <div class="mb-8">
+    <.link navigate={~p"/"} class="text-indigo-600 hover:text-indigo-900 flex items-center">
+      <svg xmlns="http://www.w3.org/2000/svg" class="h-5 w-5 mr-1" viewBox="0 0 20 20" fill="currentColor">
+        <path fill-rule="evenodd" d="M9.707 16.707a1 1 0 01-1.414 0l-6-6a1 1 0 010-1.414l6-6a1 1 0 011.414 1.414L5.414 9H17a1 1 0 110 2H5.414l4.293 4.293a1 1 0 010 1.414z" clip-rule="evenodd" />
+      </svg>
+      Back to bookmarks
+    </.link>
+  </div>
+
+  <div class="bg-white shadow overflow-hidden sm:rounded-lg mb-8">
+    <div class="px-4 py-5 sm:px-6">
+      <h1 class="text-2xl font-bold text-gray-900"><%= @bookmark.title %></h1>
+      <div class="mt-2 flex items-center text-sm text-gray-500">
+        <.link navigate={~p"/users/#{@bookmark.user.username}"} class="hover:text-gray-700">
+          <%= @bookmark.user.display_name || @bookmark.user.username %>
+        </.link>
+        <span class="mx-2">•</span>
+        <span><%= Calendar.strftime(@bookmark.inserted_at, "%B %d, %Y at %I:%M %p") %></span>
+      </div>
+    </div>
+    <div class="border-t border-gray-200 px-4 py-5 sm:px-6">
+      <div class="mb-4">
+        <a href={@bookmark.url} target="_blank" class="text-indigo-600 hover:text-indigo-900 break-all">
+          <%= @bookmark.url %>
+        </a>
+      </div>
+
+      <%= if @bookmark.description && @bookmark.description != "" do %>
+        <div class="prose max-w-none mb-6">
+          <p><%= @bookmark.description %></p>
+        </div>
+      <% end %>
+
+      <div class="flex flex-wrap gap-2 mb-4">
+        <%= for tag <- @bookmark.tags do %>
+          <.link navigate={~p"/tags/#{tag.name}"} class="inline-flex items-center px-2.5 py-0.5 rounded-full text-xs font-medium bg-indigo-100 text-indigo-800 hover:bg-indigo-200">
+            <%= tag.name %>
+          </.link>
+        <% end %>
+      </div>
+    </div>
+  </div>
+
+  <div class="bg-white shadow overflow-hidden sm:rounded-lg">
+    <div class="px-4 py-5 sm:px-6 border-b border-gray-200">
+      <h2 class="text-lg font-medium text-gray-900">Comments</h2>
+    </div>
+
+    <div class="divide-y divide-gray-200">
+      <%= if Enum.empty?(@bookmark.comments) do %>
+        <div class="px-4 py-5 sm:px-6 text-gray-500">
+          No comments yet. Be the first to comment!
+        </div>
+      <% else %>
+        <%= for comment <- @bookmark.comments do %>
+          <div id={"comment-#{comment.id}"} class="px-4 py-5 sm:px-6">
+            <div class="flex items-start">
+              <div class="flex-1">
+                <div class="flex items-center mb-1">
+                  <h3 class="text-sm font-medium text-gray-900">
+                    <%= comment.user.display_name || comment.user.username %>
+                  </h3>
+                  <span class="ml-2 text-xs text-gray-500">
+                    <%= Calendar.strftime(comment.inserted_at, "%B %d, %Y at %I:%M %p") %>
+                  </span>
+                </div>
+                <div class="text-sm text-gray-700">
+                  <%= comment.content %>
+                </div>
+              </div>
+            </div>
+          </div>
+        <% end %>
+      <% end %>
+    </div>
+
+    <div class="px-4 py-5 sm:px-6 border-t border-gray-200">
+      <h3 class="text-lg font-medium text-gray-900 mb-4">Add a comment</h3>
+      <.form :let={f} for={@comment_changeset} phx-submit="save_comment" class="space-y-4">
+        <div>
+          <.input
+            field={f[:content]}
+            type="textarea"
+            placeholder="Write your comment here..."
+            rows={3}
+            class="shadow-sm focus:ring-indigo-500 focus:border-indigo-500 block w-full sm:text-sm border-gray-300 rounded-md"
+          />
+        </div>
+        <div>
+          <.button type="submit" class="inline-flex items-center px-4 py-2 border border-transparent text-sm font-medium rounded-md shadow-sm text-white bg-indigo-600 hover:bg-indigo-700 focus:outline-none focus:ring-2 focus:ring-offset-2 focus:ring-indigo-500">
+            Post Comment
+          </.button>
+        </div>
+      </.form>
+    </div>
+  </div>
+</div>

lib/bookmarker_web/live/home_live.ex

···
+defmodule BookmarkerWeb.HomeLive do
+  use BookmarkerWeb, :live_view
+
+  alias Bookmarker.Bookmarks
+  alias Bookmarker.Cache
+  alias Bookmarker.Accounts
+  alias Bookmarker.Tags
+
+  @impl true
+  def mount(_params, _session, socket) do
+    if connected?(socket) do
+      Bookmarks.subscribe()
+    end
+
+    # Get recent bookmarks from cache
+    bookmarks = Cache.get_recent_bookmarks(20)
+
+    # Get popular tags for the sidebar
+    tags_with_counts = Tags.list_tags_with_counts()
+      |> Enum.filter(fn %{count: count} -> count > 1 end)
+      |> Enum.sort_by(fn %{count: count} -> count end, :desc)
+      |> Enum.take(20)  # Limit to top 20 tags
+
+    # For demo purposes, let's get the first user or create one
+    user = get_or_create_demo_user()
+
+    {:ok, assign(socket,
+      bookmarks: bookmarks,
+      filtered_bookmarks: bookmarks,
+      page_title: "Recent Bookmarks",
+      current_user: user,
+      tags_with_counts: tags_with_counts,
+      selected_tag: nil
+    )}
+  end
+
+  @impl true
+  def handle_params(_params, _url, socket) do
+    {:noreply, socket}
+  end
+
+  @impl true
+  def handle_event("filter_by_tag", %{"tag" => tag_name}, socket) do
+    filtered_bookmarks =
+      if tag_name == "" do
+        # Clear filter
+        socket.assigns.bookmarks
+      else
+        # Filter bookmarks by selected tag
+        Enum.filter(socket.assigns.bookmarks, fn bookmark ->
+          Enum.any?(bookmark.tags, fn tag -> tag.name == tag_name end)
+        end)
+      end
+
+    {:noreply, assign(socket,
+      filtered_bookmarks: filtered_bookmarks,
+      selected_tag: if(tag_name == "", do: nil, else: tag_name)
+    )}
+  end
+
+  @impl true
+  def handle_info({:bookmark_created, bookmark}, socket) do
+    # Add the new bookmark to the main list
+    updated_bookmarks =
+      [bookmark | socket.assigns.bookmarks]
+      |> Enum.sort_by(& &1.inserted_at, {:desc, NaiveDateTime})
+      |> Enum.take(20)
+
+    # Apply the update to filtered_bookmarks based on current filter
+    updated_filtered_bookmarks =
+      if socket.assigns.selected_tag do
+        # If there's a selected tag, check if the new bookmark has that tag
+        has_selected_tag =
+          Enum.any?(bookmark.tags, fn tag -> tag.name == socket.assigns.selected_tag end)
+
+        if has_selected_tag do
+          # Add the new bookmark to filtered list and sort
+          [bookmark | socket.assigns.filtered_bookmarks]
+          |> Enum.sort_by(& &1.inserted_at, {:desc, NaiveDateTime})
+        else
+          # Keep the filtered list as is
+          socket.assigns.filtered_bookmarks
+        end
+      else
+        # No tag filter, show all bookmarks
+        updated_bookmarks
+      end
+
+    {:noreply, assign(socket,
+      bookmarks: updated_bookmarks,
+      filtered_bookmarks: updated_filtered_bookmarks
+    )}
+  end
+
+  @impl true
+  def handle_info({:bookmark_updated, bookmark}, socket) do
+    # Update the bookmark in the main list
+    updated_bookmarks =
+      socket.assigns.bookmarks
+      |> Enum.map(fn b -> if b.id == bookmark.id, do: bookmark, else: b end)
+
+    # Apply the update to filtered_bookmarks based on current filter
+    updated_filtered_bookmarks =
+      if socket.assigns.selected_tag do
+        has_selected_tag =
+          Enum.any?(bookmark.tags, fn tag -> tag.name == socket.assigns.selected_tag end)
+
+        # Update or remove from filtered list based on tag presence
+        if has_selected_tag do
+          # Update bookmark in filtered list if it's already there
+          if Enum.any?(socket.assigns.filtered_bookmarks, fn b -> b.id == bookmark.id end) do
+            socket.assigns.filtered_bookmarks
+            |> Enum.map(fn b -> if b.id == bookmark.id, do: bookmark, else: b end)
+          else
+            # Add bookmark to filtered list if it wasn't there before but now has the tag
+            [bookmark | socket.assigns.filtered_bookmarks]
+            |> Enum.sort_by(& &1.inserted_at, {:desc, NaiveDateTime})
+          end
+        else
+          # Remove from filtered list if it no longer has the tag
+          socket.assigns.filtered_bookmarks
+          |> Enum.reject(fn b -> b.id == bookmark.id end)
+        end
+      else
+        # No tag filter, show all bookmarks
+        updated_bookmarks
+      end
+
+    {:noreply, assign(socket,
+      bookmarks: updated_bookmarks,
+      filtered_bookmarks: updated_filtered_bookmarks
+    )}
+  end
+
+  @impl true
+  def handle_info({:bookmark_deleted, bookmark}, socket) do
+    # Remove the bookmark from the main list
+    updated_bookmarks =
+      socket.assigns.bookmarks
+      |> Enum.reject(fn b -> b.id == bookmark.id end)
+
+    # Remove the bookmark from the filtered list if it's present
+    updated_filtered_bookmarks =
+      socket.assigns.filtered_bookmarks
+      |> Enum.reject(fn b -> b.id == bookmark.id end)
+
+    {:noreply, assign(socket,
+      bookmarks: updated_bookmarks,
+      filtered_bookmarks: updated_filtered_bookmarks
+    )}
+  end
+
+  defp get_or_create_demo_user do
+    case Accounts.get_user_by_username("demo_user") do
+      nil ->
+        {:ok, user} = Accounts.create_user(%{
+          username: "demo_user",
+          email: "[e-mail]",
+          display_name: "Demo User"
+        })
+        user
+      user ->
+        user
+    end
+  end
+end

lib/bookmarker_web/live/home_live.html.heex

···
+<div class="max-w-7xl mx-auto px-4 sm:px-6 lg:px-8 py-8">
+  <div class="flex justify-between items-center mb-8">
+    <h1 class="text-3xl font-bold text-gray-900">
+      <%= if @selected_tag do %>
+        Bookmarks tagged with <span class="text-indigo-600">#<%= @selected_tag %></span>
+      <% else %>
+        Recent Bookmarks
+      <% end %>
+    </h1>
+    <div>
+      <.link navigate={~p"/bookmarks/new"} class="inline-flex items-center px-4 py-2 border border-transparent text-sm font-medium rounded-md shadow-sm text-white bg-indigo-600 hover:bg-indigo-700 focus:outline-none focus:ring-2 focus:ring-offset-2 focus:ring-indigo-500">
+        <svg xmlns="http://www.w3.org/2000/svg" class="h-5 w-5 mr-2" viewBox="0 0 20 20" fill="currentColor">
+          <path fill-rule="evenodd" d="M10 3a1 1 0 011 1v5h5a1 1 0 110 2h-5v5a1 1 0 11-2 0v-5H4a1 1 0 110-2h5V4a1 1 0 011-1z" clip-rule="evenodd" />
+        </svg>
+        Add Bookmark
+      </.link>
+    </div>
+  </div>
+
+  <div class="flex flex-col md:flex-row gap-8">
+    <!-- Tag Filter Sidebar -->
+    <div class="w-full md:w-64 flex-shrink-0">
+      <div class="bg-white shadow overflow-hidden sm:rounded-md p-4">
+        <h2 class="text-lg font-medium text-gray-900 mb-4">Filter by Tag</h2>
+
+        <div class="space-y-2">
+          <button phx-click="filter_by_tag" phx-value-tag=""
+            class={"flex items-center w-full px-3 py-2 text-left text-sm rounded-md transition-colors duration-150
+              #{if is_nil(@selected_tag), do: "bg-indigo-100 text-indigo-800 font-medium", else: "text-gray-700 hover:bg-gray-100"}"}>
+            <span class="flex-1">All Bookmarks</span>
+            <span class="text-xs text-gray-500"><%= length(@bookmarks) %></span>
+          </button>
+
+          <%= for %{tag: tag, count: count} <- @tags_with_counts do %>
+            <button phx-click="filter_by_tag" phx-value-tag={tag.name}
+              class={"flex items-center w-full px-3 py-2 text-left text-sm rounded-md transition-colors duration-150
+                #{if @selected_tag == tag.name, do: "bg-indigo-100 text-indigo-800 font-medium", else: "text-gray-700 hover:bg-gray-100"}"}>
+              <span class="flex-1">#<%= tag.name %></span>
+              <span class="text-xs text-gray-500"><%= count %></span>
+            </button>
+          <% end %>
+        </div>
+
+        <div class="mt-4 pt-4 border-t border-gray-200">
+          <.link navigate={~p"/tags"} class="text-sm text-indigo-600 hover:text-indigo-900">
+            View Tag Cloud →
+          </.link>
+        </div>
+      </div>
+    </div>
+
+    <!-- Bookmarks List -->
+    <div class="flex-1">
+      <div class="bg-white shadow overflow-hidden sm:rounded-md">
+        <ul role="list" class="divide-y divide-gray-200">
+          <%= if Enum.empty?(@filtered_bookmarks) do %>
+            <li class="px-6 py-4 text-center text-gray-500">
+              <%= if @selected_tag do %>
+                No bookmarks found with tag #<%= @selected_tag %>.
+              <% else %>
+                No bookmarks yet. Be the first to add one!
+              <% end %>
+            </li>
+          <% else %>
+            <%= for bookmark <- @filtered_bookmarks do %>
+              <li id={"bookmark-#{bookmark.id}"} class="px-6 py-4 animate-fade-in">
+                <div class="flex items-center justify-between">
+                  <div class="flex-1 min-w-0">
+                    <.link navigate={~p"/bookmarks/#{bookmark.id}"} class="text-lg font-medium text-indigo-600 hover:text-indigo-900 truncate">
+                      <%= bookmark.title %>
+                    </.link>
+                    <p class="text-sm text-gray-500 truncate">
+                      <a href={bookmark.url} target="_blank" class="hover:underline">
+                        <%= bookmark.url %>
+                      </a>
+                    </p>
+                    <div class="mt-2 flex flex-wrap gap-2">
+                      <%= for tag <- bookmark.tags do %>
+                        <button phx-click="filter_by_tag" phx-value-tag={tag.name}
+                          class={"inline-flex items-center px-2.5 py-0.5 rounded-full text-xs font-medium
+                            #{if @selected_tag == tag.name, do: "bg-indigo-200 text-indigo-800", else: "bg-indigo-100 text-indigo-800 hover:bg-indigo-200"}"}>
+                          <%= tag.name %>
+                        </button>
+                      <% end %>
+                    </div>
+                  </div>
+                  <div class="ml-4 flex-shrink-0 flex items-center">
+                    <.link navigate={~p"/users/#{bookmark.user.username}"} class="text-sm text-gray-500 hover:text-gray-700">
+                      <%= bookmark.user.display_name || bookmark.user.username %>
+                    </.link>
+                    <span class="mx-2 text-gray-300">•</span>
+                    <span class="text-sm text-gray-500">
+                      <%= Calendar.strftime(bookmark.inserted_at, "%b %d, %Y") %>
+                    </span>
+                  </div>
+                </div>
+                <%= if bookmark.description && bookmark.description != "" do %>
+                  <p class="mt-2 text-sm text-gray-600">
+                    <%= bookmark.description %>
+                  </p>
+                <% end %>
+              </li>
+            <% end %>
+          <% end %>
+        </ul>
+      </div>
+    </div>
+  </div>
+</div>
+
+<style>
+  @keyframes fadeIn {
+    from { opacity: 0; transform: translateY(-10px); }
+    to { opacity: 1; transform: translateY(0); }
+  }
+  .animate-fade-in {
+    animation: fadeIn 0.5s ease-out;
+  }
+</style>

lib/bookmarker_web/live/tag_cloud_live.ex

···
+defmodule BookmarkerWeb.TagCloudLive do
+  use BookmarkerWeb, :live_view
+
+  alias Bookmarker.Tags
+
+  @impl true
+  def mount(_params, _session, socket) do
+    # Get all tags with counts
+    all_tags_with_counts = Tags.list_tags_with_counts()
+
+    # Filter to only include tags with more than one occurrence
+    tags_with_counts = all_tags_with_counts
+      |> Enum.filter(fn %{count: count} -> count > 0 end)
+      |> Enum.sort_by(fn %{count: count} -> count end, :desc)
+
+    # Calculate min and max counts for scaling
+    {min_count, max_count} =
+      case tags_with_counts do
+        [] -> {0, 0}
+        _ ->
+          counts = Enum.map(tags_with_counts, & &1.count)
+          {Enum.min(counts), Enum.max(counts)}
+      end
+
+    {:ok, assign(socket,
+      tags_with_counts: tags_with_counts,
+      min_count: min_count,
+      max_count: max_count,
+      page_title: "Tag Cloud",
+      total_tag_count: length(all_tags_with_counts),
+      filtered_tag_count: length(tags_with_counts)
+    )}
+  end
+
+  @impl true
+  def render(assigns) do
+    ~H"""
+    <div class="max-w-4xl mx-auto px-4 py-8">
+      <h1 class="text-3xl font-bold mb-6 text-center">Tag Cloud</h1>
+
+      <div class="bg-white rounded-lg shadow p-6">
+        <%= if @tags_with_counts == [] do %>
+          <p class="text-gray-500 text-center py-8">
+            No tags found.
+            <%= if @total_tag_count > 0 do %>
+              There are <%= @total_tag_count %> tags with only one bookmark each.
+            <% end %>
+          </p>
+        <% else %>
+          <p class="text-sm text-gray-500 mb-4 text-center">
+            Showing <%= @filtered_tag_count %> tags that appear in multiple bookmarks
+            <%= if @total_tag_count > @filtered_tag_count do %>
+              (filtered out <%= @total_tag_count - @filtered_tag_count %> tags that only appear once)
+            <% end %>
+          </p>
+          <div class="flex flex-wrap justify-center gap-4 py-4">
+            <%= for %{tag: tag, count: count} <- @tags_with_counts do %>
+              <.link
+                navigate={~p"/tags/#{tag.name}"}
+                class="inline-block rounded px-3 py-1 transition-all duration-200"
+                style={"font-size: #{tag_size_from_count(count, @min_count, @max_count)}rem; #{tag_color_from_count(count, @min_count, @max_count)}"}
+              >
+                <%= tag.name %>
+                <span class="text-xs text-gray-500 align-top">(<%= count %>)</span>
+              </.link>
+            <% end %>
+          </div>
+        <% end %>
+      </div>
+    </div>
+    """
+  end
+
+  # Calculate font size based on count (minimum 1rem, maximum 3rem)
+  defp tag_size_from_count(count, min_count, max_count) when min_count != max_count do
+    # Linear scaling
+    min_size = 1.0
+    max_size = 3.0
+
+    normalized = (count - min_count) / (max_count - min_count)
+    min_size + normalized * (max_size - min_size)
+  end
+
+  defp tag_size_from_count(_count, _min_count, _max_count), do: 1.5
+
+  # Calculate color gradient based on count
+  defp tag_color_from_count(count, min_count, max_count) when min_count != max_count do
+    # Calculate color gradient from blue (less frequent) to indigo (more frequent)
+    normalized = (count - min_count) / (max_count - min_count)
+
+    # Convert to HSL colors (indigo-100 to indigo-700)
+    hue = 238 # Indigo hue
+    saturation = 60 + (normalized * 30) # 60% to 90%
+    lightness = 90 - (normalized * 45) # 90% to 45%
+
+    "background-color: hsl(#{hue}, #{saturation}%, #{lightness}%); " <>
+    "color: #{if lightness < 65, do: "white", else: "rgb(67, 56, 202)"}; " <>
+    "border: 1px solid hsl(#{hue}, #{saturation}%, #{lightness - 10}%); " <>
+    "box-shadow: 0 1px 2px rgba(0, 0, 0, 0.05); " <>
+    "transform: scale(1); " <>
+    "hover:transform: scale(1.05); " <>
+    "hover:box-shadow: 0 4px 6px rgba(0, 0, 0, 0.1);"
+  end
+
+  defp tag_color_from_count(_count, _min_count, _max_count) do
+    "background-color: rgb(224, 231, 255); color: rgb(67, 56, 202); border: 1px solid rgb(199, 210, 254);"
+  end
+end

lib/bookmarker_web/live/tag_live/show.ex

···
+defmodule BookmarkerWeb.TagLive.Show do
+  use BookmarkerWeb, :live_view
+
+  alias Bookmarker.Bookmarks
+  alias Bookmarker.Cache
+  alias Bookmarker.Accounts
+
+  @impl true
+  def mount(%{"name" => tag_name}, _session, socket) do
+    if connected?(socket) do
+      Bookmarks.subscribe_to_tag(tag_name)
+    end
+
+    # Get bookmarks for this tag from cache
+    bookmarks = Cache.get_bookmarks_by_tag(tag_name)
+
+    # For demo purposes, let's get the first user or create one
+    user = get_or_create_demo_user()
+
+    {:ok,
+     socket
+     |> assign(:tag_name, tag_name)
+     |> assign(:bookmarks, bookmarks)
+     |> assign(:current_user, user)
+     |> assign(:page_title, "Bookmarks tagged with #{tag_name}")}
+  end
+
+  @impl true
+  def handle_info({:bookmark_created, bookmark}, socket) do
+    # Check if the bookmark has the current tag
+    if has_tag?(bookmark, socket.assigns.tag_name) do
+      updated_bookmarks = [bookmark | socket.assigns.bookmarks]
+      |> Enum.sort_by(& &1.inserted_at, {:desc, NaiveDateTime})
+
+      {:noreply, assign(socket, :bookmarks, updated_bookmarks)}
+    else
+      {:noreply, socket}
+    end
+  end
+
+  @impl true
+  def handle_info({:bookmark_updated, bookmark}, socket) do
+    # Check if the bookmark has the current tag
+    if has_tag?(bookmark, socket.assigns.tag_name) do
+      # Update the bookmark in the list
+      updated_bookmarks =
+        socket.assigns.bookmarks
+        |> Enum.map(fn b -> if b.id == bookmark.id, do: bookmark, else: b end)
+        |> Enum.sort_by(& &1.inserted_at, {:desc, NaiveDateTime})
+
+      {:noreply, assign(socket, :bookmarks, updated_bookmarks)}
+    else
+      # The bookmark no longer has this tag, remove it from the list
+      updated_bookmarks =
+        socket.assigns.bookmarks
+        |> Enum.reject(fn b -> b.id == bookmark.id end)
+
+      {:noreply, assign(socket, :bookmarks, updated_bookmarks)}
+    end
+  end
+
+  @impl true
+  def handle_info({:bookmark_deleted, bookmark}, socket) do
+    # Remove the bookmark from the list
+    updated_bookmarks =
+      socket.assigns.bookmarks
+      |> Enum.reject(fn b -> b.id == bookmark.id end)
+
+    {:noreply, assign(socket, :bookmarks, updated_bookmarks)}
+  end
+
+  defp has_tag?(bookmark, tag_name) do
+    Enum.any?(bookmark.tags, fn tag -> tag.name == tag_name end)
+  end
+
+  defp get_or_create_demo_user do
+    case Accounts.get_user_by_username("demo_user") do
+      nil ->
+        {:ok, user} = Accounts.create_user(%{
+          username: "demo_user",
+          email: "[e-mail]",
+          display_name: "Demo User"
+        })
+        user
+      user ->
+        user
+    end
+  end
+end

lib/bookmarker_web/live/tag_live/show.html.heex

···
+<div class="max-w-7xl mx-auto px-4 sm:px-6 lg:px-8 py-8">
+  <div class="mb-8">
+    <.link navigate={~p"/"} class="text-indigo-600 hover:text-indigo-900 flex items-center">
+      <svg xmlns="http://www.w3.org/2000/svg" class="h-5 w-5 mr-1" viewBox="0 0 20 20" fill="currentColor">
+        <path fill-rule="evenodd" d="M9.707 16.707a1 1 0 01-1.414 0l-6-6a1 1 0 010-1.414l6-6a1 1 0 011.414 1.414L5.414 9H17a1 1 0 110 2H5.414l4.293 4.293a1 1 0 010 1.414z" clip-rule="evenodd" />
+      </svg>
+      Back to bookmarks
+    </.link>
+  </div>
+
+  <div class="flex justify-between items-center mb-8">
+    <h1 class="text-3xl font-bold text-gray-900">
+      <span class="inline-flex items-center px-3 py-1 rounded-full text-sm font-medium bg-indigo-100 text-indigo-800">
+        <%= @tag_name %>
+      </span>
+    </h1>
+    <div>
+      <.link navigate={~p"/bookmarks/new"} class="inline-flex items-center px-4 py-2 border border-transparent text-sm font-medium rounded-md shadow-sm text-white bg-indigo-600 hover:bg-indigo-700 focus:outline-none focus:ring-2 focus:ring-offset-2 focus:ring-indigo-500">
+        <svg xmlns="http://www.w3.org/2000/svg" class="h-5 w-5 mr-2" viewBox="0 0 20 20" fill="currentColor">
+          <path fill-rule="evenodd" d="M10 3a1 1 0 011 1v5h5a1 1 0 110 2h-5v5a1 1 0 11-2 0v-5H4a1 1 0 110-2h5V4a1 1 0 011-1z" clip-rule="evenodd" />
+        </svg>
+        Add Bookmark
+      </.link>
+    </div>
+  </div>
+
+  <div class="bg-white shadow overflow-hidden sm:rounded-md">
+    <ul role="list" class="divide-y divide-gray-200">
+      <%= if Enum.empty?(@bookmarks) do %>
+        <li class="px-6 py-4 text-center text-gray-500">
+          No bookmarks with this tag yet. Be the first to add one!
+        </li>
+      <% else %>
+        <%= for bookmark <- @bookmarks do %>
+          <li id={"bookmark-#{bookmark.id}"} class="px-6 py-4 animate-fade-in">
+            <div class="flex items-center justify-between">
+              <div class="flex-1 min-w-0">
+                <.link navigate={~p"/bookmarks/#{bookmark.id}"} class="text-lg font-medium text-indigo-600 hover:text-indigo-900 truncate">
+                  <%= bookmark.title %>
+                </.link>
+                <p class="text-sm text-gray-500 truncate">
+                  <a href={bookmark.url} target="_blank" class="hover:underline">
+                    <%= bookmark.url %>
+                  </a>
+                </p>
+                <div class="mt-2 flex flex-wrap gap-2">
+                  <%= for tag <- bookmark.tags do %>
+                    <.link navigate={~p"/tags/#{tag.name}"} class={"inline-flex items-center px-2.5 py-0.5 rounded-full text-xs font-medium #{if tag.name == @tag_name, do: "bg-indigo-500 text-white", else: "bg-indigo-100 text-indigo-800 hover:bg-indigo-200"}"}>
+                      <%= tag.name %>
+                    </.link>
+                  <% end %>
+                </div>
+              </div>
+              <div class="ml-4 flex-shrink-0 flex items-center">
+                <.link navigate={~p"/users/#{bookmark.user.username}"} class="text-sm text-gray-500 hover:text-gray-700">
+                  <%= bookmark.user.display_name || bookmark.user.username %>
+                </.link>
+                <span class="mx-2 text-gray-300">•</span>
+                <span class="text-sm text-gray-500">
+                  <%= Calendar.strftime(bookmark.inserted_at, "%b %d, %Y") %>
+                </span>
+              </div>
+            </div>
+            <%= if bookmark.description && bookmark.description != "" do %>
+              <p class="mt-2 text-sm text-gray-600">
+                <%= bookmark.description %>
+              </p>
+            <% end %>
+          </li>
+        <% end %>
+      <% end %>
+    </ul>
+  </div>
+</div>
+
+<style>
+  @keyframes fadeIn {
+    from { opacity: 0; transform: translateY(-10px); }
+    to { opacity: 1; transform: translateY(0); }
+  }
+  .animate-fade-in {
+    animation: fadeIn 0.5s ease-out;
+  }
+</style>

lib/bookmarker_web/live/user_live/show.ex

···
+defmodule BookmarkerWeb.UserLive.Show do
+  use BookmarkerWeb, :live_view
+
+  alias Bookmarker.Accounts
+  alias Bookmarker.Bookmarks
+
+  @impl true
+  def mount(%{"username" => username}, _session, socket) do
+    user = Accounts.get_user_by_username(username)
+
+    if user do
+      bookmarks = Bookmarks.list_user_bookmarks(user.id)
+
+      # Get all unique tags used by this user
+      user_tags =
+        bookmarks
+        |> Enum.flat_map(& &1.tags)
+        |> Enum.uniq_by(& &1.id)
+        |> Enum.sort_by(& &1.name)
+
+      {:ok,
+       socket
+       |> assign(:user, user)
+       |> assign(:bookmarks, bookmarks)
+       |> assign(:user_tags, user_tags)
+       |> assign(:page_title, "#{user.display_name || user.username}'s Bookmarks")}
+    else
+      {:ok,
+       socket
+       |> put_flash(:error, "User not found")
+       |> push_navigate(to: ~p"/")}
+    end
+  end
+end

lib/bookmarker_web/live/user_live/show.html.heex

···
+<div class="max-w-7xl mx-auto px-4 sm:px-6 lg:px-8 py-8">
+  <div class="mb-8">
+    <.link navigate={~p"/"} class="text-indigo-600 hover:text-indigo-900 flex items-center">
+      <svg xmlns="http://www.w3.org/2000/svg" class="h-5 w-5 mr-1" viewBox="0 0 20 20" fill="currentColor">
+        <path fill-rule="evenodd" d="M9.707 16.707a1 1 0 01-1.414 0l-6-6a1 1 0 010-1.414l6-6a1 1 0 011.414 1.414L5.414 9H17a1 1 0 110 2H5.414l4.293 4.293a1 1 0 010 1.414z" clip-rule="evenodd" />
+      </svg>
+      Back to bookmarks
+    </.link>
+  </div>
+
+  <div class="bg-white shadow overflow-hidden sm:rounded-lg mb-8">
+    <div class="px-4 py-5 sm:px-6">
+      <h1 class="text-2xl font-bold text-gray-900">
+        <%= @user.display_name || @user.username %>
+      </h1>
+      <p class="mt-1 text-sm text-gray-500">
+        @<%= @user.username %>
+      </p>
+    </div>
+    <div class="border-t border-gray-200 px-4 py-5 sm:px-6">
+      <h2 class="text-lg font-medium text-gray-900 mb-4">Tags</h2>
+      <div class="flex flex-wrap gap-2">
+        <%= if Enum.empty?(@user_tags) do %>
+          <p class="text-gray-500">No tags yet</p>
+        <% else %>
+          <%= for tag <- @user_tags do %>
+            <.link navigate={~p"/tags/#{tag.name}"} class="inline-flex items-center px-2.5 py-0.5 rounded-full text-xs font-medium bg-indigo-100 text-indigo-800 hover:bg-indigo-200">
+              <%= tag.name %>
+              <span class="ml-1 text-indigo-600">
+                <%= Enum.count(Enum.filter(@bookmarks, fn b -> Enum.any?(b.tags, fn t -> t.id == tag.id end) end)) %>
+              </span>
+            </.link>
+          <% end %>
+        <% end %>
+      </div>
+    </div>
+  </div>
+
+  <div class="bg-white shadow overflow-hidden sm:rounded-lg">
+    <div class="px-4 py-5 sm:px-6 border-b border-gray-200">
+      <div class="flex justify-between items-center">
+        <h2 class="text-lg font-medium text-gray-900">Bookmarks</h2>
+        <div>
+          <.link navigate={~p"/bookmarks/new"} class="inline-flex items-center px-4 py-2 border border-transparent text-sm font-medium rounded-md shadow-sm text-white bg-indigo-600 hover:bg-indigo-700 focus:outline-none focus:ring-2 focus:ring-offset-2 focus:ring-indigo-500">
+            <svg xmlns="http://www.w3.org/2000/svg" class="h-5 w-5 mr-2" viewBox="0 0 20 20" fill="currentColor">
+              <path fill-rule="evenodd" d="M10 3a1 1 0 011 1v5h5a1 1 0 110 2h-5v5a1 1 0 11-2 0v-5H4a1 1 0 110-2h5V4a1 1 0 011-1z" clip-rule="evenodd" />
+            </svg>
+            Add Bookmark
+          </.link>
+        </div>
+      </div>
+    </div>
+
+    <ul role="list" class="divide-y divide-gray-200">
+      <%= if Enum.empty?(@bookmarks) do %>
+        <li class="px-6 py-4 text-center text-gray-500">
+          No bookmarks yet
+        </li>
+      <% else %>
+        <%= for bookmark <- @bookmarks do %>
+          <li id={"bookmark-#{bookmark.id}"} class="px-6 py-4">
+            <div class="flex items-center justify-between">
+              <div class="flex-1 min-w-0">
+                <.link navigate={~p"/bookmarks/#{bookmark.id}"} class="text-lg font-medium text-indigo-600 hover:text-indigo-900 truncate">
+                  <%= bookmark.title %>
+                </.link>
+                <p class="text-sm text-gray-500 truncate">
+                  <a href={bookmark.url} target="_blank" class="hover:underline">
+                    <%= bookmark.url %>
+                  </a>
+                </p>
+                <div class="mt-2 flex flex-wrap gap-2">
+                  <%= for tag <- bookmark.tags do %>
+                    <.link navigate={~p"/tags/#{tag.name}"} class="inline-flex items-center px-2.5 py-0.5 rounded-full text-xs font-medium bg-indigo-100 text-indigo-800 hover:bg-indigo-200">
+                      <%= tag.name %>
+                    </.link>
+                  <% end %>
+                </div>
+              </div>
+              <div class="ml-4 flex-shrink-0">
+                <span class="text-sm text-gray-500">
+                  <%= Calendar.strftime(bookmark.inserted_at, "%b %d, %Y") %>
+                </span>
+              </div>
+            </div>
+            <%= if bookmark.description && bookmark.description != "" do %>
+              <p class="mt-2 text-sm text-gray-600">
+                <%= bookmark.description %>
+              </p>
+            <% end %>
+          </li>
+        <% end %>
+      <% end %>
+    </ul>
+  </div>
+</div>

lib/bookmarker_web/router.ex

···
   scope "/", BookmarkerWeb do
     pipe_through :browser
 
-    get "/", PageController, :home
+    live "/", HomeLive
+    live "/bookmarks/new", BookmarkLive.New
+    live "/bookmarks/:id", BookmarkLive.Show
+    live "/tags", TagCloudLive
+    live "/tags/:name", TagLive.Show
+    live "/users/:username", UserLive.Show
   end
 
   # Other scopes may use custom stacks.

mix.exs

···
 defmodule Bookmarker.MixProject do
   use Mix.Project
-
   def project do
     [
       app: :bookmarker,
···
       {:gettext, "~> 0.26"},
       {:jason, "~> 1.2"},
       {:dns_cluster, "~> 0.1.1"},
-      {:bandit, "~> 1.5"}
+      {:bandit, "~> 1.5"},
+      {:req, "~> 0.4"},
+      {:websockex, "~> 0.4"}
     ]
   end
 

mix.lock

···
   "plug": {:hex, :plug, "1.16.1", "40c74619c12f82736d2214557dedec2e9762029b2438d6d175c5074c933edc9d", [:mix], [{:mime, "~> 1.0 or ~> 2.0", [hex: :mime, repo: "hexpm", optional: false]}, {:plug_crypto, "~> 1.1.1 or ~> 1.2 or ~> 2.0", [hex: :plug_crypto, repo: "hexpm", optional: false]}, {:telemetry, "~> 0.4.3 or ~> 1.0", [hex: :telemetry, repo: "hexpm", optional: false]}], "hexpm", "a13ff6b9006b03d7e33874945b2755253841b238c34071ed85b0e86057f8cddc"},
   "plug_crypto": {:hex, :plug_crypto, "2.1.0", "f44309c2b06d249c27c8d3f65cfe08158ade08418cf540fd4f72d4d6863abb7b", [:mix], [], "hexpm", "131216a4b030b8f8ce0f26038bc4421ae60e4bb95c5cf5395e1421437824c4fa"},
   "postgrex": {:hex, :postgrex, "0.20.0", "363ed03ab4757f6bc47942eff7720640795eb557e1935951c1626f0d303a3aed", [:mix], [{:db_connection, "~> 2.1", [hex: :db_connection, repo: "hexpm", optional: false]}, {:decimal, "~> 1.5 or ~> 2.0", [hex: :decimal, repo: "hexpm", optional: false]}, {:jason, "~> 1.0", [hex: :jason, repo: "hexpm", optional: true]}, {:table, "~> 0.1.0", [hex: :table, repo: "hexpm", optional: true]}], "hexpm", "d36ef8b36f323d29505314f704e21a1a038e2dc387c6409ee0cd24144e187c0f"},
+  "req": {:hex, :req, "0.5.8", "50d8d65279d6e343a5e46980ac2a70e97136182950833a1968b371e753f6a662", [:mix], [{:brotli, "~> 0.3.1", [hex: :brotli, repo: "hexpm", optional: true]}, {:ezstd, "~> 1.0", [hex: :ezstd, repo: "hexpm", optional: true]}, {:finch, "~> 0.17", [hex: :finch, repo: "hexpm", optional: false]}, {:jason, "~> 1.0", [hex: :jason, repo: "hexpm", optional: false]}, {:mime, "~> 2.0.6 or ~> 2.1", [hex: :mime, repo: "hexpm", optional: false]}, {:nimble_csv, "~> 1.0", [hex: :nimble_csv, repo: "hexpm", optional: true]}, {:plug, "~> 1.0", [hex: :plug, repo: "hexpm", optional: true]}], "hexpm", "d7fc5898a566477e174f26887821a3c5082b243885520ee4b45555f5d53f40ef"},
   "swoosh": {:hex, :swoosh, "1.18.2", "41279e8449b65d14b571b66afe9ab352c3b0179291af8e5f4ad9207f489ad11a", [:mix], [{:bandit, ">= 1.0.0", [hex: :bandit, repo: "hexpm", optional: true]}, {:cowboy, "~> 1.1 or ~> 2.4", [hex: :cowboy, repo: "hexpm", optional: true]}, {:ex_aws, "~> 2.1", [hex: :ex_aws, repo: "hexpm", optional: true]}, {:finch, "~> 0.6", [hex: :finch, repo: "hexpm", optional: true]}, {:gen_smtp, "~> 0.13 or ~> 1.0", [hex: :gen_smtp, repo: "hexpm", optional: true]}, {:hackney, "~> 1.9", [hex: :hackney, repo: "hexpm", optional: true]}, {:jason, "~> 1.0", [hex: :jason, repo: "hexpm", optional: false]}, {:mail, "~> 0.2", [hex: :mail, repo: "hexpm", optional: true]}, {:mime, "~> 1.1 or ~> 2.0", [hex: :mime, repo: "hexpm", optional: false]}, {:mua, "~> 0.2.3", [hex: :mua, repo: "hexpm", optional: true]}, {:multipart, "~> 0.4", [hex: :multipart, repo: "hexpm", optional: true]}, {:plug, "~> 1.9", [hex: :plug, repo: "hexpm", optional: true]}, {:plug_cowboy, ">= 1.0.0", [hex: :plug_cowboy, repo: "hexpm", optional: true]}, {:req, "~> 0.5 or ~> 1.0", [hex: :req, repo: "hexpm", optional: true]}, {:telemetry, "~> 0.4.2 or ~> 1.0", [hex: :telemetry, repo: "hexpm", optional: false]}], "hexpm", "032fcb2179f6d4e3b90030514ddc8d3946d8b046be939d121db480ca78adbc38"},
   "tailwind": {:hex, :tailwind, "0.3.1", "a89d2835c580748c7a975ad7dd3f2ea5e63216dc16d44f9df492fbd12c094bed", [:mix], [], "hexpm", "98a45febdf4a87bc26682e1171acdedd6317d0919953c353fcd1b4f9f4b676a2"},
   "telemetry": {:hex, :telemetry, "1.3.0", "fedebbae410d715cf8e7062c96a1ef32ec22e764197f70cda73d82778d61e7a2", [:rebar3], [], "hexpm", "7015fc8919dbe63764f4b4b87a95b7c0996bd539e0d499be6ec9d7f3875b79e6"},
···
   "thousand_island": {:hex, :thousand_island, "1.3.11", "b68f3e91f74d564ae20b70d981bbf7097dde084343c14ae8a33e5b5fbb3d6f37", [:mix], [{:telemetry, "~> 0.4 or ~> 1.0", [hex: :telemetry, repo: "hexpm", optional: false]}], "hexpm", "555c18c62027f45d9c80df389c3d01d86ba11014652c00be26e33b1b64e98d29"},
   "websock": {:hex, :websock, "0.5.3", "2f69a6ebe810328555b6fe5c831a851f485e303a7c8ce6c5f675abeb20ebdadc", [:mix], [], "hexpm", "6105453d7fac22c712ad66fab1d45abdf049868f253cf719b625151460b8b453"},
   "websock_adapter": {:hex, :websock_adapter, "0.5.8", "3b97dc94e407e2d1fc666b2fb9acf6be81a1798a2602294aac000260a7c4a47d", [:mix], [{:bandit, ">= 0.6.0", [hex: :bandit, repo: "hexpm", optional: true]}, {:plug, "~> 1.14", [hex: :plug, repo: "hexpm", optional: false]}, {:plug_cowboy, "~> 2.6", [hex: :plug_cowboy, repo: "hexpm", optional: true]}, {:websock, "~> 0.5", [hex: :websock, repo: "hexpm", optional: false]}], "hexpm", "315b9a1865552212b5f35140ad194e67ce31af45bcee443d4ecb96b5fd3f3782"},
+  "websockex": {:hex, :websockex, "0.4.3", "92b7905769c79c6480c02daacaca2ddd49de936d912976a4d3c923723b647bf0", [:mix], [], "hexpm", "95f2e7072b85a3a4cc385602d42115b73ce0b74a9121d0d6dbbf557645ac53e4"},
 }

priv/repo/migrations/20250309190526_create_users.exs

···
+defmodule Bookmarker.Repo.Migrations.CreateUsers do
+  use Ecto.Migration
+
+  def change do
+    create table(:users) do
+      add :username, :string, null: false
+      add :email, :string, null: false
+      add :display_name, :string
+
+      timestamps()
+    end
+
+    create unique_index(:users, [:username])
+    create unique_index(:users, [:email])
+  end
+end

priv/repo/migrations/20250309190622_create_bookmarks.exs

···
+defmodule Bookmarker.Repo.Migrations.CreateBookmarks do
+  use Ecto.Migration
+
+  def change do
+    create table(:bookmarks) do
+      add :url, :string, null: false
+      add :title, :string, null: false
+      add :description, :text
+      add :user_id, references(:users, on_delete: :delete_all), null: false
+
+      timestamps()
+    end
+
+    create index(:bookmarks, [:user_id])
+    create index(:bookmarks, [:inserted_at])
+  end
+end

priv/repo/migrations/20250309190627_create_tags.exs

···
+defmodule Bookmarker.Repo.Migrations.CreateTags do
+  use Ecto.Migration
+
+  def change do
+    create table(:tags) do
+      add :name, :string, null: false
+
+      timestamps()
+    end
+
+    create unique_index(:tags, [:name])
+  end
+end

priv/repo/migrations/20250309190632_create_bookmark_tags.exs

···
+defmodule Bookmarker.Repo.Migrations.CreateBookmarkTags do
+  use Ecto.Migration
+
+  def change do
+    create table(:bookmark_tags, primary_key: false) do
+      add :bookmark_id, references(:bookmarks, on_delete: :delete_all), null: false
+      add :tag_id, references(:tags, on_delete: :delete_all), null: false
+
+      timestamps()
+    end
+
+    create index(:bookmark_tags, [:bookmark_id])
+    create index(:bookmark_tags, [:tag_id])
+    create unique_index(:bookmark_tags, [:bookmark_id, :tag_id])
+  end
+end

priv/repo/migrations/20250309190636_create_comments.exs

···
+defmodule Bookmarker.Repo.Migrations.CreateComments do
+  use Ecto.Migration
+
+  def change do
+    create table(:comments) do
+      add :content, :text, null: false
+      add :user_id, references(:users, on_delete: :delete_all), null: false
+      add :bookmark_id, references(:bookmarks, on_delete: :delete_all), null: false
+
+      timestamps()
+    end
+
+    create index(:comments, [:user_id])
+    create index(:comments, [:bookmark_id])
+    create index(:comments, [:inserted_at])
+  end
+end