Llemmy tutorial

create schema llemmy;

create table llemmy.chat (
    id integer generated by default as identity primary key,
    session uuid not null,
    timestamp timestamp not null,
    name text not null,
    message_type varchar(25) not null,
    message text,
    stack_trace text,
    response_time integer,
    input_tokens integer,
    output_tokens integer,
    total_tokens integer,
    json json,
    deleted boolean default false not null
);

comment on column llemmy.chat.session is 'Identifies the chat session';
comment on column llemmy.chat.name is 'The chat participant name';
comment on column llemmy.chat.response_time is 'The AI response time in milliseonds';
comment on column llemmy.chat.input_tokens is 'The input token count';
comment on column llemmy.chat.output_tokens is 'The output token count';
comment on column llemmy.chat.total_tokens is 'The total token count';
comment on column llemmy.chat.json is 'The message in JSON format';
comment on column llemmy.chat.deleted is 'True if the row has been soft-deleted';

public final class Llemmy extends DomainModel {

  // Identifies this domain model
  public static final DomainType DOMAIN = domainType(Llemmy.class);

  public Llemmy() {
    super(DOMAIN);
    chat();
  }

public final class LlemmyApp extends EntityApplicationPanel<SwingEntityApplicationModel> {

  private LlemmyApp(SwingEntityApplicationModel applicationModel) {
    super(applicationModel,
            // See LlemmyAppModel at the bottom of this class
            List.of(new ChatPanel(((LlemmyAppModel) applicationModel).chatModel())), List.of(),
            // We replace the default application layout factory, which
            // produces a layout arranging the main panels in a tabbed pane,
            // but here we only have a single panel, no need for tabs
            applicationPanel -> () ->
                    // Simply return our single panel, initialized
                    applicationPanel.entityPanel(Chat.TYPE).initialize());
  }

  /**
   * Override the default View menu, to exclude the Look & Feel selection
   * menu item, since {@link ChatEditPanel} contains a Look & Feel combo box.
   * @return the {@link Controls} on which to base the main view menu
   */
  @Override
  protected Optional<Controls> createViewMenuControls() {
    return Optional.of(Controls.builder()
            .caption(FrameworkMessages.view())
            .mnemonic(FrameworkMessages.viewMnemonic())
            // Just include the Always on top control
            .control(createAlwaysOnTopControl())
            .build());
  }

  /**
   * Override the default Help menu, to replace the default
   * Help menu item with a control toggling the help state,
   * showing/hiding the help panel.
   * @return the {@link Controls} on which to base the main Help menu
   */
  @Override
  protected Optional<Controls> createHelpMenuControls() {
    State help = ((ChatPanel) entityPanel(Chat.TYPE)).help();

    return Optional.of(Controls.builder()
            .caption("Help")
            .mnemonic('H')
            // A Control for toggling the help state
            // presented as a check box in the menu
            .control(Control.builder()
                    .toggle(help)
                    .caption("Help")
                    .build())
            .separator()
            // Include the default log and about controls, separated
            .control(createLogControls())
            .separator()
            .control(createAboutControl())
            .build());
  }

  /**
   * Manually instantiate a new {@link LocalEntityConnectionProvider} instance,
   * since we are always running with a in-memory H2 database
   * @param user the user
   * @return a new {@link EntityConnectionProvider} instance
   */
  private static EntityConnectionProvider createConnectionProvider(User user) {
    return LocalEntityConnectionProvider.builder()
            // Returns a Database based on the
            // 'codion.db.url' system property
            .database(Database.instance())
            // Inject the domain model
            .domain(new Llemmy())
            // Supply the user
            .user(user)
            .build();
  }

  public static void start(Supplier<List<ChatLanguageModel>> languageModels) {
    requireNonNull(languageModels, "languageModels is null");
    // Configure the jdbc URL ('codion.db.url')
    Database.DATABASE_URL.set("jdbc:h2:mem:h2db");
    // and the database initialization script
    Database.DATABASE_INIT_SCRIPTS.set("classpath:create_schema.sql");
    // Configure FlatLaf related things, the inspector is not necessary
    // but very helpful when debugging UI related stuff
    FlatInspector.install("ctrl shift alt X");
    // Configure a decent font
    FlatInterFont.install();
    FlatLaf.setPreferredFontFamily(FlatInterFont.FAMILY);
    FlatLaf.setPreferredLightFontFamily(FlatInterFont.FAMILY_LIGHT);
    FlatLaf.setPreferredSemiboldFontFamily(FlatInterFont.FAMILY_SEMIBOLD);
    Locale.setDefault(Locale.of("en", "EN"));
    FilterTableCellRenderer.TEMPORAL_HORIZONTAL_ALIGNMENT.set(LEADING);
    // Display table column selection in a menu, instead of a dialog
    EntityTablePanel.Config.COLUMN_SELECTION.set(MENU);
    EntityApplicationPanel.builder(SwingEntityApplicationModel.class, LlemmyApp.class)
            .applicationName(LlemmyAppModel.APPLICATION_NAME)
            .applicationVersion(LlemmyAppModel.APPLICATION_VERSION)
            .frameTitle(LlemmyAppModel.APPLICATION_NAME + " " + LlemmyAppModel.APPLICATION_VERSION)
            // The H2Database super user
            .user(user("sa"))
            // We provide a factory for the EntityConnectionProvider,
            // since we just manually instantiate a Local one,
            // instead of relying on the ServiceLoader
            .connectionProvider(LlemmyApp::createConnectionProvider)
            // We must supply the language models when instatiating
            // the application model, so here we provide a factory,
            // which receives the EntityConnectionProvider from above
            .applicationModel(connectionProvider ->
                    new LlemmyAppModel(languageModels.get(), connectionProvider))
            // We provide a factory for the panel instantiation,
            // which receives the LlemmyAppModel from above,
            // allowing us to keep the constructor private
            .applicationPanel(LlemmyApp::new)
            // No need, startup should be pretty quick
            .displayStartupDialog(false)
            .defaultLookAndFeel(Dracula.class)
            .start();
  }

  private static final class LlemmyAppModel extends SwingEntityApplicationModel {

    private static final String APPLICATION_NAME = "Llemmy";
    private static final Version APPLICATION_VERSION =
            Version.parse(LlemmyAppModel.class, "/version.properties");

    private LlemmyAppModel(List<ChatLanguageModel> languageModels,
                           EntityConnectionProvider connectionProvider) {
      super(connectionProvider,
              List.of(new ChatModel(languageModels, connectionProvider)),
              APPLICATION_VERSION);
    }

    private ChatModel chatModel() {
      return (ChatModel) entityModels().get(Chat.TYPE);
    }
  }
}

public final class ChatModel extends SwingEntityModel {

  /**
   * Instantiates a new {@link ChatModel} instance
   * @param languageModels the language models
   * @param connectionProvider the connection provider
   */
  public ChatModel(List<ChatLanguageModel> languageModels, EntityConnectionProvider connectionProvider) {
    super(new ChatTableModel(languageModels, connectionProvider));
  }
}

public final class ChatPanel extends EntityPanel {

  private final HelpPanel helpPanel = new HelpPanel();
  private final State help = State.builder()
          .consumer(this::onHelpChanged)
          .build();

  /**
   * Instantiates a new {@link ChatPanel}
   * @param model the {@link ChatModel} on which to base the panel
   */
  public ChatPanel(ChatModel model) {
    super(model,
            new ChatEditPanel((ChatEditModel) model.editModel()),
            new ChatTablePanel((ChatTableModel) model.tableModel()),
            config -> config
                    // Skip the default CRUD operation controls
                    .includeControls(false)
                    // No base panel needed for the edit panel since we
                    // want it to fill the whole width of the parent panel
                    .editBasePanel(editPanel -> editPanel));
    setupKeyEvents();
  }

  /**
   * @return the {@link State} controlling whether the help panel is visible
   */
  public State help() {
    return help;
  }

  @Override
  public void updateUI() {
    super.updateUI();
    // Here we update the UI of components that may
    // not be visible during Look & Feel selection
    Utilities.updateUI(helpPanel);
  }

  private void setupKeyEvents() {
    // Set up some global key events for this panel.
    // Note that calling addKeyEvent() assures that the key event is
    // added to this base panel and to the edit panel as well,
    // since that may be displayed in a separate window.
    ChatEditModel editModel = (ChatEditModel) editModel();
    ChatEditPanel editPanel = (ChatEditPanel) editPanel();
    ChatTablePanel tablePanel = (ChatTablePanel) tablePanel();
    // Set the base parameters, the modifier and the condition
    KeyEvents.Builder keyEvent = KeyEvents.builder()
            .modifiers(ALT_DOWN_MASK)
            .condition(WHEN_ANCESTOR_OF_FOCUSED_COMPONENT);
    // Set the keycode and action and add the key event
    addKeyEvent(keyEvent.keyCode(VK_1)
            .action(command(editPanel::requestModelFocus)));
    addKeyEvent(keyEvent.keyCode(VK_2)
            .action(command(editPanel::requestLookAndFeelFocus)));
    addKeyEvent(keyEvent.keyCode(VK_3)
            .action(command(editPanel::requestPromptFocus)));
    addKeyEvent(keyEvent.keyCode(VK_4)
            .action(command(editPanel::requestAttachmentFocus)));
    addKeyEvent(keyEvent.keyCode(VK_5)
            .action(command(tablePanel::requestChatFocus)));
    addKeyEvent(keyEvent.keyCode(VK_6)
            .action(command(tablePanel::requestHistoryFocus)));
    addKeyEvent(keyEvent.keyCode(VK_7)
            .action(command(helpPanel.shortcuts::requestFocus)));
    addKeyEvent(keyEvent.keyCode(VK_UP)
            .modifiers(CTRL_DOWN_MASK)
            .action(Control.builder()
                    // Use the built in method to decrement the selected table model indexes
                    .command(tablePanel.tableModel().selection().indexes()::decrement)
                    // Only enabled while the model is not processing
                    .enabled(editModel.processing().not())
                    .build()));
    addKeyEvent(keyEvent.keyCode(VK_DOWN)
            .action(Control.builder()
                    // Use the built in method to increment the selected table model indexes
                    .command(tablePanel.tableModel().selection().indexes()::increment)
                    // Only enabled while the model is not processing
                    .enabled(editModel.processing().not())
                    .build()));
  }

  private void onHelpChanged(boolean visible) {
    if (visible) {
      add(helpPanel, BorderLayout.EAST);
    }
    else {
      remove(helpPanel);
    }
    revalidate();
    repaint();
  }

  private static final class HelpPanel extends JPanel {

    private final JTextArea shortcuts = textArea()
            .value(shortcutsText())
            .font(monospaceFont())
            .editable(false)
            .build();

    private HelpPanel() {
      super(borderLayout());
      setBorder(createTitledBorder("Help"));
      add(scrollPane(shortcuts).build(), BorderLayout.CENTER);
    }

    @Override
    public void updateUI() {
      super.updateUI();
      Utilities.updateUI(shortcuts);
    }

    private static String shortcutsText() {
      try (InputStream inputStream = LlemmyApp.class.getResourceAsStream("shortcuts.txt")) {
        return new BufferedReader(new InputStreamReader(inputStream, StandardCharsets.UTF_8))
                .lines()
                .collect(joining("\n"));
      }
      catch (IOException e) {
        throw new RuntimeException("Unable to load shortcuts.txt", e);
      }
    }

    private static Font monospaceFont() {
      Font font = UIManager.getFont("TextArea.font");

      return new Font(Font.MONOSPACED, font.getStyle(), font.getSize());
    }
  }
}

public final class ChatEditModel extends SwingEntityEditModel {

  // The mime types available for attachments
  public enum MimeType {
    PDF("application/pdf", new FileNameExtensionFilter("PDF", "pdf")),
    JPEG("image/jpeg", new FileNameExtensionFilter("JPEG", "jpg", "jpeg")),
    PNG("image/png", new FileNameExtensionFilter("PNG", "png")),
    PLAIN_TEXT("text/plain", new FileNameExtensionFilter("Text", "txt", "csv"));

    private final String type;
    private final FileFilter fileFilter;

    MimeType(String type, FileFilter fileFilter) {
      this.type = type;
      this.fileFilter = fileFilter;
    }

    public String type() {
      return type;
    }

    public FileFilter fileFilter() {
      return fileFilter;
    }
  }

  private static final Base64.Encoder BASE64_ENCODER = Base64.getEncoder();
  private static final String USER = getProperty("user.name");
  private static final String SYSTEM = "System";

  // Identifies the current chat session
  private final UUID session = randomUUID();
  // Indicates that the prompt text is empty
  private final State promptEmpty = State.state(true);
  // Indicates that the attachments list model is empty
  private final State attachmentsEmpty = State.state(true);
  // Indicates whether processing is ongoing
  private final State processing = State.state();
  // Indicates whether the last prompt resulted in an error
  private final State error = State.state();
  // Indicates whether prompt data is available and the model is not processing
  private final ObservableState ready =
          and(processing.not(), and(promptEmpty, attachmentsEmpty).not());

  // Holds the time the last prompt was issued to the chat model
  private final Value<LocalDateTime> started = Value.nullable();
  // Holds the elapsed processing time of the current query
  private final Value<Duration> elapsed = Value.nonNull(ZERO);
  // Updates the elapsed time every second during processing
  private final TaskScheduler elapsedUpdater =
          TaskScheduler.builder(this::updateElapsed)
                  .interval(1, TimeUnit.SECONDS)
                  .build();

  // Contains the available language models
  private final FilterComboBoxModel<Item<ChatLanguageModel>> languageModels;
  // Contains the file attachments
  private final FilterListModel<Attachment> attachments =
          FilterListModel.<Attachment>filterListModel();
  // Contains the prompt text
  private final Value<String> prompt = Value.builder()
          .nonNull("")
          // Update the promptEmpty state each time the value changes
          .consumer(value -> promptEmpty.set(value.trim().isEmpty()))
          .build();

  /**
   * Instantiates a new {@link ChatEditModel} instance
   * @param languageModels the language models
   * @param connectionProvider the connection provider
   * @throws IllegalArgumentException in case {@code languageModels} is empty
   */
  public ChatEditModel(List<ChatLanguageModel> languageModels,
                       EntityConnectionProvider connectionProvider) {
    super(Chat.TYPE, connectionProvider);
    if (languageModels.isEmpty()) {
      throw new IllegalArgumentException("No language model(s) provided");
    }
    // Wrap the language models in Item instances, for a caption to display in the combo box
    this.languageModels = FilterComboBoxModel.builder(languageModels.stream()
                    .map(model -> item(model, model.provider().name()))
                    .toList())
            .selected(languageModels.getFirst())
            .build();
  }

  public UUID session() {
    return session;
  }

  public Value<String> prompt() {
    return prompt;
  }

  public FilterListModel<Attachment> attachments() {
    return attachments;
  }

  public void addAttachment(Path path, MimeType mimeType) {
    attachments.items().add(createAttachment(requireNonNull(path), requireNonNull(mimeType)));
    attachmentsEmpty.set(false);
  }

  public void removeAttachment(Attachment attachment) {
    attachments.items().remove(requireNonNull(attachment));
    attachmentsEmpty.set(attachments.items().count() == 0);
  }

  /**
   * Updated on the Event Dispatch Thread
   * @return the ready indicator
   */
  public ObservableState ready() {
    return ready;
  }

  /**
   * Updated on the Event Dispatch Thread
   * @return the processing indicator
   */
  public ObservableState processing() {
    return processing.observable();
  }

  /**
   * Updated in a worker thread.
   * @return the elapsed time
   */
  public Observable<Duration> elapsed() {
    return elapsed.observable();
  }

  /**
   * Updated on the Event Dispatch Thread
   * @return the error indicator
   */
  public ObservableState error() {
    return error.observable();
  }

  /**
   * @return the available language models
   */
  public FilterComboBoxModel<Item<ChatLanguageModel>> languageModels() {
    return languageModels;
  }

  /**
   * Sends the current prompt along with all attachments.
   */
  public void send() {
    // Here we perform a couple of async operations, calling the
    // model and inserting the results in a background thread.
    // We assume this method gets called on the EDT.
    UserMessageTask task = new UserMessageTask();
    // UserMessageTask splits the task into a couple of
    // background tasks and some extra methods
    // that must be performed on the EDT.
    send(task);
  }

  @Override
  protected void delete(Collection<Entity> entities, EntityConnection connection) {
    // We override the default delete implementation, in order to implement soft delete
    connection.update(entities.stream()
            .map(this::setDeleted)
            .filter(Entity::modified)
            .toList());
  }

  private Entity setDeleted(Entity entity) {
    entity.set(Chat.DELETED, true);

    return entity;
  }

  private void updateElapsed() {
    elapsed.set(started.optional()
            .map(time -> between(time, LocalDateTime.now()))
            .orElse(ZERO));
  }

  private static void send(UserMessageTask task) {
    // On the Event Dispatch Thread
    task.prepare();
    // The user message is created and inserted
    // into the database in a background thread
    ProgressWorker.builder(task)
            // On the Event Dispatch Thread
            .onException(task::fail)
            // Propagate the resulting task
            // to the next async send method
            .onResult(ChatEditModel::send)
            .execute();
  }

  private static void send(ChatResponseTask task) {
    // On the Event Dispatch Thread
    task.prepare();
    // The language model is prompted and the result
    // inserted into the database in a background thread
    ProgressWorker.builder(task)
            // On the Event Dispatch Thread
            .onResult(task::finish)
            .execute();
  }

  private static Attachment createAttachment(Path path, MimeType mimeType) {
    return switch (mimeType) {
      case PNG, JPEG -> new Attachment(path,
              ImageContent.from(toBase64Bytes(path), mimeType.type()));
      case PLAIN_TEXT -> new Attachment(path,
              TextFileContent.from(toBase64Bytes(path), mimeType.type()));
      case PDF -> new Attachment(path,
              PdfFileContent.from(toBase64Bytes(path), mimeType.type()));
    };
  }

  private static String toBase64Bytes(Path attachment) {
    try {
      return BASE64_ENCODER.encodeToString(readAllBytes(attachment));
    }
    catch (IOException e) {
      throw new RuntimeException(e);
    }
  }

  public record Attachment(Path path, Content content) {

    @Override
    public String toString() {
      return path.toString();
    }
  }

  private final class UserMessageTask implements ResultTask<ChatResponseTask> {

    @Override
    public ChatResponseTask execute() {
      UserMessage userMessage = createMessage();

      return new ChatResponseTask(new Result(insert(userMessage), userMessage));
    }

    private UserMessage createMessage() {
      UserMessage.Builder builder = UserMessage.builder().name(USER);
      prompt.optional()
              .filter(not(String::isBlank))
              .ifPresent(text -> builder.addContent(TextContent.from(text)));
      attachments.items().get().forEach(attachment ->
              builder.addContent(attachment.content()));

      return builder.build();
    }

    private Entity insert(UserMessage message) {
      return connection().insertSelect(entities().builder(Chat.TYPE)
              .with(Chat.MESSAGE_TYPE, ChatMessageType.USER)
              .with(Chat.SESSION, session)
              .with(Chat.NAME, USER)
              .with(Chat.TIMESTAMP, LocalDateTime.now())
              .with(Chat.MESSAGE, messageText(message))
              .with(Chat.JSON, messageToJson(message))
              .build());
    }

    private static String messageText(UserMessage message) {
      return message.contents().stream()
              .filter(TextContent.class::isInstance)
              .map(TextContent.class::cast)
              .map(TextContent::text)
              .collect(joining("\n"));
    }

    // Must be called on the Event Dispatch Thread
    // since this affects one or more UI components
    private void prepare() {
      elapsed.clear();
      started.set(LocalDateTime.now());
      processing.set(true);
      elapsedUpdater.start();
    }

    // Must be called on the Event Dispatch Thread
    // since this affects one or more UI components
    private void fail(Exception exception) {
      elapsedUpdater.stop();
      processing.set(false);
      elapsed.clear();
      started.clear();
    }

    private record Result(Entity entity, UserMessage userMessage) {}
  }

  private final class ChatResponseTask implements ResultTask<Entity> {

    private final UserMessageTask.Result result;

    private ChatResponseTask(UserMessageTask.Result result) {
      this.result = result;
    }

    @Override
    public Entity execute() {
      ChatLanguageModel languageModel = languageModel();
      LocalDateTime start = LocalDateTime.now();
      try {
        return insert(languageModel.provider().name(),
                languageModel.chat(result.userMessage()),
                Duration.between(start, LocalDateTime.now()));
      }
      catch (Exception e) {
        return insert(e);
      }
    }

    private Entity insert(String name, ChatResponse response, Duration responseTime) {
      TokenUsage tokenUsage = response.metadata().tokenUsage();

      return connection().insertSelect(entities().builder(Chat.TYPE)
              .with(Chat.MESSAGE_TYPE, ChatMessageType.AI)
              .with(Chat.SESSION, session)
              .with(Chat.NAME, name)
              .with(Chat.TIMESTAMP, LocalDateTime.now())
              .with(Chat.MESSAGE, response.aiMessage().text())
              .with(Chat.RESPONSE_TIME, responseTime)
              .with(Chat.JSON, messageToJson(response.aiMessage()))
              .with(Chat.INPUT_TOKENS, tokenUsage.inputTokenCount())
              .with(Chat.OUTPUT_TOKENS, tokenUsage.outputTokenCount())
              .with(Chat.TOTAL_TOKENS, tokenUsage.totalTokenCount())
              .build());
    }

    private Entity insert(Exception exception) {
      return connection().insertSelect(entities().builder(Chat.TYPE)
              .with(Chat.MESSAGE_TYPE, ChatMessageType.SYSTEM)
              .with(Chat.SESSION, session)
              .with(Chat.NAME, SYSTEM)
              .with(Chat.TIMESTAMP, LocalDateTime.now())
              .with(Chat.MESSAGE, exception.getMessage())
              .with(Chat.STACK_TRACE, stackTrace(exception))
              .build());
    }

    private ChatLanguageModel languageModel() {
      return languageModels.selection().item().optional()
              .map(Item::value)
              .orElseThrow();
    }

    // Must be called on the Event Dispatch Thread
    // since this affects one or more UI components
    private void prepare() {
      prompt.clear();
      notifyAfterInsert(List.of(result.entity()));
    }

    // Must be called on the Event Dispatch Thread
    // since this affects one or more UI components
    private void finish(Entity entity) {
      elapsedUpdater.stop();
      processing.set(false);
      elapsed.clear();
      started.clear();
      error.set(SYSTEM.equals(entity.get(Chat.NAME)));
      notifyAfterInsert(List.of(entity));
    }
  }

  private static String stackTrace(Exception exception) {
    StringWriter writer = new StringWriter();
    exception.printStackTrace(new PrintWriter(writer));

    return writer.toString();
  }
}

public final class ChatEditPanel extends EntityEditPanel {

  private final ChatEditModel model;

  private final JComboBox<Item<ChatLanguageModel>> languageModelComboBox;
  private final JPanel languageModelPanel;
  private final JTextArea promptTextArea;
  private final JScrollPane promptScrollPane;
  private final JList<Attachment> attachmentsList;
  private final JScrollPane attachmentsScrollPane;
  private final JProgressBar progressBar;
  private final JButton clearButton;
  private final JButton sendButton;
  private final JComboBox<Item<LookAndFeelEnabler>> lookAndFeelComboBox =
          LookAndFeelComboBox.builder().build();

  public ChatEditPanel(ChatEditModel model) {
    super(model);
    this.model = model;
    this.languageModelComboBox = createLanguageModelComboBox();
    this.languageModelPanel = borderLayoutPanel()
            .centerComponent(languageModelComboBox)
            .build();
    Control sendControl = createSendControl();
    this.promptTextArea = createPromptTextArea(sendControl);
    this.promptScrollPane = scrollPane(promptTextArea).build();
    this.attachmentsList = createAttachmentsList();
    this.attachmentsScrollPane = scrollPane(attachmentsList).build();
    this.progressBar = createProgressBar();
    this.clearButton = button(createClearControl()).build();
    this.sendButton = button(sendControl).build();
    model.processing().addConsumer(this::onProcessingChanged);
    model.elapsed().addConsumer(this::onElapsedChanged);
    focus().initial().set(promptTextArea);
  }

  @Override
  public void updateUI() {
    super.updateUI();
    // Here we update the UI of components that may
    // not be visible during Look & Feel selection
    Utilities.updateUI(progressBar, languageModelComboBox);
  }

  void requestModelFocus() {
    languageModelComboBox.requestFocus();
  }

  void requestPromptFocus() {
    promptTextArea.requestFocus();
  }

  void requestAttachmentFocus() {
    attachmentsList.requestFocus();
  }

  void requestLookAndFeelFocus() {
    lookAndFeelComboBox.requestFocus();
  }

  @Override
  protected void initializeUI() {
    setLayout(borderLayout());
    add(splitPane()
            .continuousLayout(true)
            .oneTouchExpandable(true)
            .resizeWeight(0.75)
            .leftComponent(borderLayoutPanel()
                    .northComponent(createModelPanel())
                    .centerComponent(borderLayoutPanel()
                            .border(createTitledBorder("Prompt"))
                            .centerComponent(promptScrollPane)
                            .build())
                    .build())
            .rightComponent(borderLayoutPanel()
                    .northComponent(createLookAndFeelPanel())
                    .centerComponent(borderLayoutPanel()
                            .border(createTitledBorder("Attachments"))
                            .centerComponent(attachmentsScrollPane)
                            .build())
                    .build())
            .build(), BorderLayout.CENTER);
  }

  private JPanel createModelPanel() {
    return borderLayoutPanel()
            .border(createTitledBorder("Model"))
            .centerComponent(languageModelPanel)
            .eastComponent(gridLayoutPanel(1, 2)
                    .addAll(clearButton, sendButton)
                    .build())
            .build();
  }

  private JPanel createLookAndFeelPanel() {
    return borderLayoutPanel()
            .border(createTitledBorder("Look & Feel"))
            .centerComponent(lookAndFeelComboBox)
            .build();
  }

  private Control createClearControl() {
    return Control.builder()
            .command(model.prompt()::clear)
            .caption("Clear")
            .mnemonic('C')
            // Only enabled when the model is ready
            .enabled(model.ready())
            .build();
  }

  private Control createSendControl() {
    return Control.builder()
            .command(model::send)
            .caption("Send")
            .mnemonic('S')
            // Only enabled when the model is ready
            .enabled(model.ready())
            .build();
  }

  private JComboBox<Item<ChatLanguageModel>> createLanguageModelComboBox() {
    return comboBox(model.languageModels())
            // Only enabled when the model is not processing
            .enabled(model.processing().not())
            .preferredWidth(200)
            .build();
  }

  private JTextArea createPromptTextArea(Control sendControl) {
    return textArea(model.prompt())
            .rowsColumns(5, 40)
            .lineWrap(true)
            .wrapStyleWord(true)
            // Only enabled when the model is not processing
            .enabled(model.processing().not())
            .validIndicator(model.error().not())
            // Ctrl-Enter sends the prompt
            .keyEvent(KeyEvents.builder(VK_ENTER)
                    .modifiers(CTRL_DOWN_MASK)
                    .action(sendControl))
            .build();
  }

  private JList<Attachment> createAttachmentsList() {
    return Components.list(model.attachments())
            // The List value is based on the items in
            // the list, as opposed to the selected items.
            .items()
            // Only enabled when the model is not processing
            .enabled(model.processing().not())
            // Insert to add attachment
            .keyEvent(KeyEvents.builder(VK_INSERT)
                    .action(command(this::addAttachment)))
            // Delete to remove the selected attachment
            .keyEvent(KeyEvents.builder(VK_DELETE)
                    .action(command(this::removeAttachment)))
            .build();
  }

  private void addAttachment() {
    // Select the file mime type
    listSelectionDialog(List.of(MimeType.values()))
            // Set the modal dialog owner
            .owner(attachmentsList)
            // Restricts the selection to a single item
            .selectSingle()
            // Returns an empty Optional in case the user cancels
            .ifPresent(mimeType ->
                    // Select the file to attach
                    fileSelectionDialog()
                            // Filter files by the selected mime type
                            .fileFilter(mimeType.fileFilter())
                            // Select one or more files
                            .selectFiles()
                            // Add the attachments
                            .forEach(file ->
                                    model.addAttachment(file.toPath(), mimeType)));
  }

  private void removeAttachment() {
    model.attachments().selection().items().get().forEach(model::removeAttachment);
  }

  private JProgressBar createProgressBar() {
    return progressBar()
            .indeterminate(true)
            .stringPainted(true)
            .string("")
            .build();
  }

  private void onProcessingChanged(boolean processing) {
    languageModelPanel.removeAll();
    languageModelPanel.add(processing ? progressBar : languageModelComboBox, BorderLayout.CENTER);
    progressBar.requestFocus();
    languageModelPanel.revalidate();
    languageModelPanel.repaint();
  }

  private void onElapsedChanged(Duration elapsed) {
    // Use invokeLater() since this gets called in a background thread
    invokeLater(() -> progressBar.setString(
            format("%02d:%02d", elapsed.toMinutes(), elapsed.toSecondsPart())));
  }
}

public final class ChatTableModel extends SwingEntityTableModel {

  /**
   * Instantiates a new {@link ChatTableModel} instance
   * @param languageModels the language models
   * @param connectionProvider the connection provider
   */
  public ChatTableModel(List<ChatLanguageModel> languageModels, EntityConnectionProvider connectionProvider) {
    super(new ChatEditModel(languageModels, connectionProvider));
    ChatEditModel editModel = (ChatEditModel) editModel();
    // Include only chat logs from our session
    queryModel().condition().get(Chat.SESSION).set().equalTo(editModel.session());
    // We implement soft delete (see ChatEditModel), so include
    // only chat log history records not marked as deleted
    queryModel().condition().get(Chat.DELETED).set().equalTo(false);
    // Hardcode the history sorting to the latest at top
    sort().descending(Chat.TIMESTAMP);
    // Display the message in the prompt when a history record is selected
    selection().item().addConsumer(this::onSelection);
  }

  private void onSelection(Entity chat) {
    ChatEditModel model = (ChatEditModel) editModel();
    if (chat == null) {
      model.prompt().clear();
    }
    else if (chat.get(Chat.MESSAGE_TYPE) == USER) {
      model.prompt().set(chat.get(Chat.MESSAGE));
    }
  }
}

public final class ChatTablePanel extends EntityTablePanel {

  private final JTextPane chatPane = textPane()
          .editable(false)
          .build();
  private final StyledDocument document = chatPane.getStyledDocument();
  private final Style userStyle = document.addStyle("user", null);
  private final Style systemStyle = document.addStyle("system", null);

  /**
   * Instantiates a new {@link ChatTablePanel}
   * @param tableModel the {@link ChatTableModel} on which to base the panel
   */
  public ChatTablePanel(ChatTableModel tableModel) {
    super(tableModel, config -> config
            // Lets skip the query conditions
            .includeConditions(false)
            // but include the filters
            .includeFilters(true)
            // and no south panel
            .includeSouthPanel(false)
            // Lets not allow the Chat.SESSION value
            // to be edited via the table popup menu
            .editable(attributes ->
                    attributes.remove(Chat.SESSION)));
    // Refresh the chat each time the visible items or selection changes
    tableModel.items().visible().addListener(this::refreshChat);
    tableModel.selection().items().addListener(this::refreshChat);
    configureTable();
    configureStyles();
  }

  @Override
  public void updateUI() {
    super.updateUI();
    if (chatPane != null) {
      // In case the Look & Feel changed
      // which affects the colors
      refreshChat();
    }
  }

  @Override
  protected void layoutPanel(JComponent tableComponent, JPanel southPanel) {
    setLayout(borderLayout());
    add(splitPane()
            .continuousLayout(true)
            .oneTouchExpandable(true)
            .resizeWeight(0.75)
            .leftComponent(borderLayoutPanel()
                    .border(createTitledBorder("Chat"))
                    .centerComponent(scrollPane(chatPane).build())
                    .build())
            .rightComponent(borderLayoutPanel()
                    .border(createTitledBorder("History"))
                    .centerComponent(tableComponent)
                    .build())
            .build(), BorderLayout.CENTER);
  }

  void requestChatFocus() {
    chatPane.requestFocus();
  }

  void requestHistoryFocus() {
    table().requestFocus();
  }

  private void configureStyles() {
    configureUserStyle();
    StyleConstants.setForeground(systemStyle, Color.WHITE);
    StyleConstants.setBackground(systemStyle, Color.RED);
  }

  private void configureUserStyle() {
    // Keep this separate since these colors are Look & Feel dependent
    // and need to be updated each time it changes
    StyleConstants.setForeground(userStyle, getColor("TextPane.background"));
    StyleConstants.setBackground(userStyle, getColor("TextPane.foreground"));
  }

  private void refreshChat() {
    // In case the Look & Feel has changed
    configureUserStyle();
    // We display all the chat history if the selection is empty,
    // otherwise only the selected history
    List<Entity> chats = tableModel().selection().empty().get() ?
            tableModel().items().visible().get() :
            tableModel().selection().items().get();
    chatPane.setText("");
    chats.stream()
            .sorted(comparing(chat -> chat.get(Chat.TIMESTAMP)))
            .forEach(this::addToChatDocument);
  }

  private void addToChatDocument(Entity chat) {
    try {
      document.insertString(document.getLength(), chat.toString() + "\n\n", style(chat));
    }
    catch (BadLocationException e) {
      throw new RuntimeException(e);
    }
  }

  private AttributeSet style(Entity chat) {
    return switch (chat.get(Chat.MESSAGE_TYPE)) {
      case USER -> userStyle;
      case SYSTEM -> systemStyle;
      default -> null;
    };
  }

  private void configureTable() {
    FilterTable<Entity, Attribute<?>> table = table();
    ChatEditModel editModel = (ChatEditModel) tableModel().editModel();
    // Disable the table while the model is processing
    enableComponents(editModel.processing().not(), table);
    // Set some minimum table column widths
    table.columnModel().column(Chat.TIMESTAMP).setMinWidth(160);
    table.columnModel().column(Chat.MESSAGE_TYPE).setMinWidth(80);
    table.columnModel().column(Chat.NAME).setMinWidth(80);
    // Set the default visible columns
    table.columnModel().visible().set(Chat.TIMESTAMP, Chat.MESSAGE_TYPE, Chat.NAME);
    // and the column auto resize mode
    table.setAutoResizeMode(JTable.AUTO_RESIZE_ALL_COLUMNS);
    // We hardcoded the sorting in ChatTableModel
    table.sortingEnabled().set(false);
  }
}

public final class Runner {

  private Runner() {}

  public static void main(String[] args) {
    findLookAndFeel(FlatDarkLaf.class).ifPresent(LookAndFeelEnabler::enable);
    try (var ollama = new GenericContainer<>("langchain4j/ollama-" + model() + ":latest")
            .withCreateContainerCmdModifier(cmd -> cmd.withHostConfig(new HostConfig()
                    .withPortBindings(new PortBinding(bindPort(PORT), new ExposedPort(PORT)))))) {
      ollama.start();
      var baseUrlField = stringField()
              .value(format("http://%s:%d", ollama.getHost(), PORT))
              .selectAllOnFocusGained(true)
              .columns(25)
              .editable(false)
              .horizontalAlignment(CENTER)
              .build();
      actionDialog(borderLayoutPanel()
              .border(emptyBorder())
              .northComponent(label(ollama.getDockerImageName())
                      .horizontalAlignment(CENTER)
                      .build())
              .centerComponent(baseUrlField)
              .build())
              .title("Ollama")
              .defaultAction(Control.builder()
                      .command(() -> setClipboard(baseUrlField.getText()))
                      .caption("Copy")
                      .mnemonic('C')
                      .build())
              .escapeAction(Control.builder()
                      .command(() -> parentWindow(baseUrlField).dispose())
                      .caption("Stop")
                      .mnemonic('S')
                      .build())
              .show();
      ollama.stop();
    }
  }

  private static String model() {
    return inputDialog(comboBox(FilterComboBoxModel.builder(MODELS).build())
                    .value(ORCA_MINI)
                    .preferredWidth(250))
            .title("Select model")
            .show();
  }
}

gradlew ollama-model:run

public final class Runner {

  public static final int PORT = 11434;
  public static final String ORCA_MINI = "orca-mini";
  public static final List<String> MODELS = List.of(
          ORCA_MINI,
          "llama3",
          "llama2",
          "mistral",
          "codellama",
          "phi",
          "tinyllama",
          "ollama-test");

  private Runner() {}

  public static void main(String[] args) {
    LlemmyApp.start(() -> List.of(OllamaChatModel.builder()
            .baseUrl("http://localhost:" + PORT)
            .modelName(comboBoxSelectionDialog(MODELS)
                    .defaultSelection(ORCA_MINI)
                    .title("Select model")
                    .select()
                    .orElseThrow(CancelException::new))
            .build()));
  }
}

gradlew llemmy-ollama:run

public final class Runner {

  private static final List<String> MODELS =
          Stream.of(OpenAiChatModelName.values())
                  .map(Objects::toString)
                  .toList();

  private Runner() {}

  public static void main(String[] args) {
    LlemmyApp.start(() -> List.of(OpenAiChatModel.builder()
            .apiKey(inputDialog(stringField()
                    .columns(25))
                    .title("OpenAI API Key")
                    .show())
            .modelName(comboBoxSelectionDialog(MODELS)
                    .defaultSelection(GPT_4_O_MINI.toString())
                    .title("Select model")
                    .select()
                    .orElseThrow(CancelException::new))
            .build()));
  }
}

gradlew llemmy-ollama:run