gollama

To delete models:

1. Use the Space key to toggle selection for one or multiple models in the list.
2. Press the Delete key.
3. A confirmation view will appear showing the names of all selected models.
4. Press the ConfirmYes key to execute the deletion or ConfirmNo to cancel.

The AppModel is the central state manager for the Gollama TUI, implementing the tea.Model interface from Bubble Tea. It manages several distinct views to control what the user sees and how they interact with the application:

• MainView: The default list view of available Ollama models.
• TopView: A view showing currently running models, their VRAM usage, and expiration times.
• HelpView: An expanded view displaying all available keybindings.
• ExternalEditorView: A mode used when editing a Modelfile in an external editor.
• Filtering: An active state within the list where the user is typing to narrow down models.
• Inspecting: A view that displays detailed metadata for a specific model in a table format.
• ConfirmDeletion: A state requiring user confirmation before deleting selected models.

The AppModel uses a view field to switch between different UI states. Navigation is primarily handled via q or esc keys, which behave contextually:

• In TopView, HelpView, or ExternalEditorView: Pressing q or esc returns the user to the MainView.
• In MainView (with no active filter): Pressing q or esc quits the application.
• When a filter is applied: Pressing q or esc clears the filter and returns to the unfiltered list.
• In ExternalEditorView: Pressing s saves changes, while other keys return to the main view.

When a model is selected and the inspection mode is triggered, the application displays a detailed table of the model's properties. This includes basic info (Name, ID, Size) and enhanced metadata retrieved from the Ollama API, such as:

• Parameter Size
• Quantization Level
• Format
• Family
• Context Length
• Embedding Length
• Vocab Size
• Capabilities (e.g., vision, etc.)

To return to the main list, press q or esc.

Gollama supports two ways to pull models from Ollama:

1. Pull an existing model: Select a model from the list and use the PullModel keybinding. This shows a progress bar.
2. Pull a new model by name: Use the PullNewModel keybinding. This opens a text input where you can type the model name (e.g., llama3:8b-instruct).

Note: There is a known issue where the progress bar might require a keypress (like an arrow key) to refresh visually.

You can modify a model's configuration using the EditModel keybinding. The behavior depends on your system configuration:

• Internal Editor: Uses a terminal-based editor (like Vim) directly within the TUI.
• External Editor: If an external editor is configured, the application creates a temporary file and opens it in your system editor.
  • While in ExternalEditorView, press s to save changes and return to the main view.
  • Pressing any other key will discard changes and return to the main view.

The TopView provides a real-time look at which models are currently loaded in Ollama's memory. It displays a table with:

• Name: The model name.
• Size (GB): Memory footprint.
• VRAM (GB): VRAM usage.
• Until: Estimated time until unloading (if applicable).

This view can be toggled using the Top keybinding and refreshes automatically every 2 seconds.

The application provides several ways to sort the list of models. These are triggered by specific keybindings (defined in the KeyMap):

• Sort by Name: SortByName
• Sort by Size: SortBySize (largest first)
• Sort by Modified Date: SortByModified (newest first)
• Sort by Quantization: SortByQuant
• Sort by Family: SortByFamily
• Sort by Parameter Size: SortByParamSize (largest first, handles 'B' suffix parsing)

To run a progress bar that updates automatically, initialize a progress.Model (e.g., using progress.WithDefaultGradient()), wrap it in your progressModel, and start the Bubble Tea program. Use tea.Tick to send periodic messages to your Update function to drive the progress increments.

func progressDemo() {
	tickCmd := tea.Tick(time.Second*1, func(t time.Time) tea.Msg {
		return tickMsg(t)
	})

	p := progress.New(progress.WithDefaultGradient())
	m := progressModel{progress: p}

	t := tea.NewProgram(m)

	if err := func() error {
		_, err := t.Run()
		return err
	}(); err != nil {
		panic(err)
	}

	tickCmd()
	t.Kill()
}