interactive.go 16.8 KB
Newer Older
1
2
3
package cmd

import (
Michael Yang's avatar
Michael Yang committed
4
	"cmp"
5
6
7
8
9
	"errors"
	"fmt"
	"io"
	"net/http"
	"os"
10
	"path/filepath"
11
	"regexp"
12
	"slices"
13
14
15
16
	"strings"

	"github.com/spf13/cobra"

17
	"github.com/ollama/ollama/api"
18
	"github.com/ollama/ollama/envconfig"
19
	"github.com/ollama/ollama/readline"
20
	"github.com/ollama/ollama/types/errtypes"
21
	"github.com/ollama/ollama/types/model"
22
23
24
25
26
27
28
29
30
31
)

type MultilineState int

const (
	MultilineNone MultilineState = iota
	MultilinePrompt
	MultilineSystem
)

32
func generateInteractive(cmd *cobra.Command, opts runOptions) error {
33
34
	usage := func() {
		fmt.Fprintln(os.Stderr, "Available Commands:")
35
36
37
38
		fmt.Fprintln(os.Stderr, "  /set            Set session variables")
		fmt.Fprintln(os.Stderr, "  /show           Show model information")
		fmt.Fprintln(os.Stderr, "  /load <model>   Load a session or model")
		fmt.Fprintln(os.Stderr, "  /save <model>   Save your current session")
Bryce Reitano's avatar
Bryce Reitano committed
39
		fmt.Fprintln(os.Stderr, "  /clear          Clear session context")
40
41
42
		fmt.Fprintln(os.Stderr, "  /bye            Exit")
		fmt.Fprintln(os.Stderr, "  /?, /help       Help for a command")
		fmt.Fprintln(os.Stderr, "  /? shortcuts    Help for keyboard shortcuts")
43
44
		fmt.Fprintln(os.Stderr, "")
		fmt.Fprintln(os.Stderr, "Use \"\"\" to begin a multi-line message.")
45
46
47
48
49

		if opts.MultiModal {
			fmt.Fprintf(os.Stderr, "Use %s to include .jpg or .png images.\n", filepath.FromSlash("/path/to/file"))
		}

50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
		fmt.Fprintln(os.Stderr, "")
	}

	usageSet := func() {
		fmt.Fprintln(os.Stderr, "Available Commands:")
		fmt.Fprintln(os.Stderr, "  /set parameter ...     Set a parameter")
		fmt.Fprintln(os.Stderr, "  /set system <string>   Set system message")
		fmt.Fprintln(os.Stderr, "  /set history           Enable history")
		fmt.Fprintln(os.Stderr, "  /set nohistory         Disable history")
		fmt.Fprintln(os.Stderr, "  /set wordwrap          Enable wordwrap")
		fmt.Fprintln(os.Stderr, "  /set nowordwrap        Disable wordwrap")
		fmt.Fprintln(os.Stderr, "  /set format json       Enable JSON mode")
		fmt.Fprintln(os.Stderr, "  /set noformat          Disable formatting")
		fmt.Fprintln(os.Stderr, "  /set verbose           Show LLM stats")
		fmt.Fprintln(os.Stderr, "  /set quiet             Disable LLM stats")
		fmt.Fprintln(os.Stderr, "")
	}

	usageShortcuts := func() {
		fmt.Fprintln(os.Stderr, "Available keyboard shortcuts:")
		fmt.Fprintln(os.Stderr, "  Ctrl + a            Move to the beginning of the line (Home)")
		fmt.Fprintln(os.Stderr, "  Ctrl + e            Move to the end of the line (End)")
		fmt.Fprintln(os.Stderr, "   Alt + b            Move back (left) one word")
		fmt.Fprintln(os.Stderr, "   Alt + f            Move forward (right) one word")
		fmt.Fprintln(os.Stderr, "  Ctrl + k            Delete the sentence after the cursor")
		fmt.Fprintln(os.Stderr, "  Ctrl + u            Delete the sentence before the cursor")
Josh Yan's avatar
Josh Yan committed
76
		fmt.Fprintln(os.Stderr, "  Ctrl + w            Delete the word before the cursor")
77
78
79
80
81
82
83
84
85
		fmt.Fprintln(os.Stderr, "")
		fmt.Fprintln(os.Stderr, "  Ctrl + l            Clear the screen")
		fmt.Fprintln(os.Stderr, "  Ctrl + c            Stop the model from responding")
		fmt.Fprintln(os.Stderr, "  Ctrl + d            Exit ollama (/bye)")
		fmt.Fprintln(os.Stderr, "")
	}

	usageShow := func() {
		fmt.Fprintln(os.Stderr, "Available Commands:")
86
		fmt.Fprintln(os.Stderr, "  /show info         Show details for this model")
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
		fmt.Fprintln(os.Stderr, "  /show license      Show model license")
		fmt.Fprintln(os.Stderr, "  /show modelfile    Show Modelfile for this model")
		fmt.Fprintln(os.Stderr, "  /show parameters   Show parameters for this model")
		fmt.Fprintln(os.Stderr, "  /show system       Show system message")
		fmt.Fprintln(os.Stderr, "  /show template     Show prompt template")
		fmt.Fprintln(os.Stderr, "")
	}

	// only list out the most common parameters
	usageParameters := func() {
		fmt.Fprintln(os.Stderr, "Available Parameters:")
		fmt.Fprintln(os.Stderr, "  /set parameter seed <int>             Random number seed")
		fmt.Fprintln(os.Stderr, "  /set parameter num_predict <int>      Max number of tokens to predict")
		fmt.Fprintln(os.Stderr, "  /set parameter top_k <int>            Pick from top k num of tokens")
		fmt.Fprintln(os.Stderr, "  /set parameter top_p <float>          Pick token based on sum of probabilities")
102
		fmt.Fprintln(os.Stderr, "  /set parameter min_p <float>          Pick token based on top token probability * min_p")
103
104
105
106
107
		fmt.Fprintln(os.Stderr, "  /set parameter num_ctx <int>          Set the context size")
		fmt.Fprintln(os.Stderr, "  /set parameter temperature <float>    Set creativity level")
		fmt.Fprintln(os.Stderr, "  /set parameter repeat_penalty <float> How strongly to penalize repetitions")
		fmt.Fprintln(os.Stderr, "  /set parameter repeat_last_n <int>    Set how far back to look for repetitions")
		fmt.Fprintln(os.Stderr, "  /set parameter num_gpu <int>          The number of layers to send to the GPU")
108
		fmt.Fprintln(os.Stderr, "  /set parameter stop <string> <string> ...   Set the stop parameters")
109
110
111
112
113
114
115
116
117
118
119
120
121
		fmt.Fprintln(os.Stderr, "")
	}

	scanner, err := readline.New(readline.Prompt{
		Prompt:         ">>> ",
		AltPrompt:      "... ",
		Placeholder:    "Send a message (/? for help)",
		AltPlaceholder: `Use """ to end multi-line input`,
	})
	if err != nil {
		return err
	}

Michael Yang's avatar
bool  
Michael Yang committed
122
	if envconfig.NoHistory() {
123
124
125
		scanner.HistoryDisable()
	}

126
127
128
	fmt.Print(readline.StartBracketedPaste)
	defer fmt.Printf(readline.EndBracketedPaste)

129
	var sb strings.Builder
130
131
132
133
134
135
136
137
138
139
140
141
142
143
	var multiline MultilineState

	for {
		line, err := scanner.Readline()
		switch {
		case errors.Is(err, io.EOF):
			fmt.Println()
			return nil
		case errors.Is(err, readline.ErrInterrupt):
			if line == "" {
				fmt.Println("\nUse Ctrl + d or /bye to exit.")
			}

			scanner.Prompt.UseAlt = false
144
			sb.Reset()
145
146
147
148
149
150
151

			continue
		case err != nil:
			return err
		}

		switch {
152
153
154
155
156
157
		case multiline != MultilineNone:
			// check if there's a multiline terminating string
			before, ok := strings.CutSuffix(line, `"""`)
			sb.WriteString(before)
			if !ok {
				fmt.Fprintln(&sb)
158
159
160
161
162
				continue
			}

			switch multiline {
			case MultilineSystem:
163
				opts.System = sb.String()
164
				opts.Messages = append(opts.Messages, api.Message{Role: "system", Content: opts.System})
165
				fmt.Println("Set system message.")
166
				sb.Reset()
167
			}
168

169
			multiline = MultilineNone
170
171
172
173
174
175
176
177
178
179
180
			scanner.Prompt.UseAlt = false
		case strings.HasPrefix(line, `"""`):
			line := strings.TrimPrefix(line, `"""`)
			line, ok := strings.CutSuffix(line, `"""`)
			sb.WriteString(line)
			if !ok {
				// no multiline terminating string; need more input
				fmt.Fprintln(&sb)
				multiline = MultilinePrompt
				scanner.Prompt.UseAlt = true
			}
181
		case scanner.Pasting:
182
			fmt.Fprintln(&sb, line)
183
184
185
186
187
188
			continue
		case strings.HasPrefix(line, "/list"):
			args := strings.Fields(line)
			if err := ListHandler(cmd, args[1:]); err != nil {
				return err
			}
189
190
191
192
193
194
195
196
197
		case strings.HasPrefix(line, "/load"):
			args := strings.Fields(line)
			if len(args) != 2 {
				fmt.Println("Usage:\n  /load <modelname>")
				continue
			}
			opts.Model = args[1]
			opts.Messages = []api.Message{}
			fmt.Printf("Loading model '%s'\n", opts.Model)
Patrick Devine's avatar
Patrick Devine committed
198
			if err := loadOrUnloadModel(cmd, &opts); err != nil {
199
200
201
202
				if strings.Contains(err.Error(), "not found") {
					fmt.Printf("error: %v\n", err)
					continue
				}
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
				return err
			}
			continue
		case strings.HasPrefix(line, "/save"):
			args := strings.Fields(line)
			if len(args) != 2 {
				fmt.Println("Usage:\n  /save <modelname>")
				continue
			}

			client, err := api.ClientFromEnvironment()
			if err != nil {
				fmt.Println("error: couldn't connect to ollama server")
				return err
			}

219
			req := NewCreateRequest(args[1], opts)
220
221
222
			fn := func(resp api.ProgressResponse) error { return nil }
			err = client.Create(cmd.Context(), req, fn)
			if err != nil {
223
224
225
226
				if strings.Contains(err.Error(), errtypes.InvalidModelNameErrMsg) {
					fmt.Printf("error: The model name '%s' is invalid\n", args[1])
					continue
				}
227
228
229
230
				return err
			}
			fmt.Printf("Created new model '%s'\n", args[1])
			continue
Bryce Reitano's avatar
Bryce Reitano committed
231
232
		case strings.HasPrefix(line, "/clear"):
			opts.Messages = []api.Message{}
Patrick Devine's avatar
Patrick Devine committed
233
234
235
236
			if opts.System != "" {
				newMessage := api.Message{Role: "system", Content: opts.System}
				opts.Messages = append(opts.Messages, newMessage)
			}
Bryce Reitano's avatar
Bryce Reitano committed
237
238
			fmt.Println("Cleared session context")
			continue
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
		case strings.HasPrefix(line, "/set"):
			args := strings.Fields(line)
			if len(args) > 1 {
				switch args[1] {
				case "history":
					scanner.HistoryEnable()
				case "nohistory":
					scanner.HistoryDisable()
				case "wordwrap":
					opts.WordWrap = true
					fmt.Println("Set 'wordwrap' mode.")
				case "nowordwrap":
					opts.WordWrap = false
					fmt.Println("Set 'nowordwrap' mode.")
				case "verbose":
254
255
256
					if err := cmd.Flags().Set("verbose", "true"); err != nil {
						return err
					}
257
258
					fmt.Println("Set 'verbose' mode.")
				case "quiet":
259
260
261
					if err := cmd.Flags().Set("verbose", "false"); err != nil {
						return err
					}
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
					fmt.Println("Set 'quiet' mode.")
				case "format":
					if len(args) < 3 || args[2] != "json" {
						fmt.Println("Invalid or missing format. For 'json' mode use '/set format json'")
					} else {
						opts.Format = args[2]
						fmt.Printf("Set format to '%s' mode.\n", args[2])
					}
				case "noformat":
					opts.Format = ""
					fmt.Println("Disabled format.")
				case "parameter":
					if len(args) < 4 {
						usageParameters()
						continue
					}
Michael Yang's avatar
Michael Yang committed
278
					params := args[3:]
279
280
					fp, err := api.FormatParams(map[string][]string{args[2]: params})
					if err != nil {
281
						fmt.Printf("Couldn't set parameter: %q\n", err)
282
283
						continue
					}
284
					fmt.Printf("Set parameter '%s' to '%s'\n", args[2], strings.Join(params, ", "))
285
					opts.Options[args[2]] = fp[args[2]]
Patrick Devine's avatar
Patrick Devine committed
286
				case "system":
287
288
289
290
					if len(args) < 3 {
						usageSet()
						continue
					}
291

Patrick Devine's avatar
Patrick Devine committed
292
					multiline = MultilineSystem
293

294
					line := strings.Join(args[2:], " ")
295
296
297
					line, ok := strings.CutPrefix(line, `"""`)
					if !ok {
						multiline = MultilineNone
298
					} else {
299
300
301
302
303
304
305
306
307
308
309
310
311
						// only cut suffix if the line is multiline
						line, ok = strings.CutSuffix(line, `"""`)
						if ok {
							multiline = MultilineNone
						}
					}

					sb.WriteString(line)
					if multiline != MultilineNone {
						scanner.Prompt.UseAlt = true
						continue
					}

Patrick Devine's avatar
Patrick Devine committed
312
313
314
315
316
317
318
319
					opts.System = sb.String() // for display in modelfile
					newMessage := api.Message{Role: "system", Content: sb.String()}
					// Check if the slice is not empty and the last message is from 'system'
					if len(opts.Messages) > 0 && opts.Messages[len(opts.Messages)-1].Role == "system" {
						// Replace the last message
						opts.Messages[len(opts.Messages)-1] = newMessage
					} else {
						opts.Messages = append(opts.Messages, newMessage)
320
					}
Patrick Devine's avatar
Patrick Devine committed
321
					fmt.Println("Set system message.")
322
323
					sb.Reset()
					continue
324
325
326
327
328
329
330
331
332
333
334
335
336
337
				default:
					fmt.Printf("Unknown command '/set %s'. Type /? for help\n", args[1])
				}
			} else {
				usageSet()
			}
		case strings.HasPrefix(line, "/show"):
			args := strings.Fields(line)
			if len(args) > 1 {
				client, err := api.ClientFromEnvironment()
				if err != nil {
					fmt.Println("error: couldn't connect to ollama server")
					return err
				}
338
				req := &api.ShowRequest{
Michael Yang's avatar
Michael Yang committed
339
340
341
					Name:    opts.Model,
					System:  opts.System,
					Options: opts.Options,
342
343
				}
				resp, err := client.Show(cmd.Context(), req)
344
345
346
347
348
349
				if err != nil {
					fmt.Println("error: couldn't get model")
					return err
				}

				switch args[1] {
350
				case "info":
351
					_ = showInfo(resp, false, os.Stderr)
352
353
				case "license":
					if resp.License == "" {
354
						fmt.Println("No license was specified for this model.")
355
356
357
358
359
360
361
					} else {
						fmt.Println(resp.License)
					}
				case "modelfile":
					fmt.Println(resp.Modelfile)
				case "parameters":
					if resp.Parameters == "" {
362
						fmt.Println("No parameters were specified for this model.")
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
					} else {
						if len(opts.Options) > 0 {
							fmt.Println("User defined parameters:")
							for k, v := range opts.Options {
								fmt.Printf("%-*s %v\n", 30, k, v)
							}
							fmt.Println()
						}
						fmt.Println("Model defined parameters:")
						fmt.Println(resp.Parameters)
					}
				case "system":
					switch {
					case opts.System != "":
						fmt.Println(opts.System + "\n")
					case resp.System != "":
						fmt.Println(resp.System + "\n")
					default:
381
						fmt.Println("No system message was specified for this model.")
382
383
					}
				case "template":
Patrick Devine's avatar
Patrick Devine committed
384
					if resp.Template != "" {
385
						fmt.Println(resp.Template)
Patrick Devine's avatar
Patrick Devine committed
386
					} else {
387
						fmt.Println("No prompt template was specified for this model.")
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
					}
				default:
					fmt.Printf("Unknown command '/show %s'. Type /? for help\n", args[1])
				}
			} else {
				usageShow()
			}
		case strings.HasPrefix(line, "/help"), strings.HasPrefix(line, "/?"):
			args := strings.Fields(line)
			if len(args) > 1 {
				switch args[1] {
				case "set", "/set":
					usageSet()
				case "show", "/show":
					usageShow()
				case "shortcut", "shortcuts":
					usageShortcuts()
				}
			} else {
				usage()
			}
409
		case strings.HasPrefix(line, "/exit"), strings.HasPrefix(line, "/bye"):
410
411
412
413
414
			return nil
		case strings.HasPrefix(line, "/"):
			args := strings.Fields(line)
			isFile := false

415
			if opts.MultiModal {
416
417
418
419
420
421
422
423
				for _, f := range extractFileNames(line) {
					if strings.HasPrefix(f, args[0]) {
						isFile = true
						break
					}
				}
			}

424
			if !isFile {
425
426
427
				fmt.Printf("Unknown command '%s'. Type /? for help\n", args[0])
				continue
			}
428
429

			sb.WriteString(line)
430
		default:
431
			sb.WriteString(line)
432
433
		}

434
		if sb.Len() > 0 && multiline == MultilineNone {
435
436
			newMessage := api.Message{Role: "user", Content: sb.String()}

437
			if opts.MultiModal {
438
				msg, images, err := extractFileData(sb.String())
439
440
441
				if err != nil {
					return err
				}
442

443
				newMessage.Content = msg
444
				newMessage.Images = images
445
			}
446

447
448
449
450
			opts.Messages = append(opts.Messages, newMessage)

			assistant, err := chat(cmd, opts)
			if err != nil {
451
452
				return err
			}
453
454
455
			if assistant != nil {
				opts.Messages = append(opts.Messages, *assistant)
			}
456

457
			sb.Reset()
458
459
460
461
		}
	}
}

462
func NewCreateRequest(name string, opts runOptions) *api.CreateRequest {
463
464
465
466
467
468
469
	parentModel := opts.ParentModel

	modelName := model.ParseName(parentModel)
	if !modelName.IsValid() {
		parentModel = ""
	}

470
	req := &api.CreateRequest{
471
472
		Model: name,
		From:  cmp.Or(parentModel, opts.Model),
473
	}
Michael Yang's avatar
Michael Yang committed
474

475
	if opts.System != "" {
476
		req.System = opts.System
477
478
	}

479
480
	if len(opts.Options) > 0 {
		req.Parameters = opts.Options
481
482
	}

483
484
	if len(opts.Messages) > 0 {
		req.Messages = opts.Messages
485
486
	}

487
	return req
488
489
}

490
func normalizeFilePath(fp string) string {
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
	return strings.NewReplacer(
		"\\ ", " ", // Escaped space
		"\\(", "(", // Escaped left parenthesis
		"\\)", ")", // Escaped right parenthesis
		"\\[", "[", // Escaped left square bracket
		"\\]", "]", // Escaped right square bracket
		"\\{", "{", // Escaped left curly brace
		"\\}", "}", // Escaped right curly brace
		"\\$", "$", // Escaped dollar sign
		"\\&", "&", // Escaped ampersand
		"\\;", ";", // Escaped semicolon
		"\\'", "'", // Escaped single quote
		"\\\\", "\\", // Escaped backslash
		"\\*", "*", // Escaped asterisk
		"\\?", "?", // Escaped question mark
	).Replace(fp)
507
508
509
}

func extractFileNames(input string) []string {
510
	// Regex to match file paths starting with optional drive letter, / ./ \ or .\ and include escaped or unescaped spaces (\ or %20)
511
	// and followed by more characters and a file extension
512
	// This will capture non filename strings, but we'll check for file existence to remove mismatches
513
	regexPattern := `(?:[a-zA-Z]:)?(?:\./|/|\\)[\S\\ ]+?\.(?i:jpg|jpeg|png)\b`
514
515
516
517
518
	re := regexp.MustCompile(regexPattern)

	return re.FindAllString(input, -1)
}

519
func extractFileData(input string) (string, []api.ImageData, error) {
520
	filePaths := extractFileNames(input)
521
	var imgs []api.ImageData
522
523
524
525

	for _, fp := range filePaths {
		nfp := normalizeFilePath(fp)
		data, err := getImageData(nfp)
526
527
528
		if errors.Is(err, os.ErrNotExist) {
			continue
		} else if err != nil {
529
			fmt.Fprintf(os.Stderr, "Couldn't process image: %q\n", err)
530
531
			return "", imgs, err
		}
532
		fmt.Fprintf(os.Stderr, "Added image '%s'\n", nfp)
533
534
535
		input = strings.ReplaceAll(input, fp, "")
		imgs = append(imgs, data)
	}
536
	return strings.TrimSpace(input), imgs, nil
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
}

func getImageData(filePath string) ([]byte, error) {
	file, err := os.Open(filePath)
	if err != nil {
		return nil, err
	}
	defer file.Close()

	buf := make([]byte, 512)
	_, err = file.Read(buf)
	if err != nil {
		return nil, err
	}

	contentType := http.DetectContentType(buf)
553
	allowedTypes := []string{"image/jpeg", "image/jpg", "image/png"}
554
555
556
557
558
559
560
561
562
563
564
565
	if !slices.Contains(allowedTypes, contentType) {
		return nil, fmt.Errorf("invalid image type: %s", contentType)
	}

	info, err := file.Stat()
	if err != nil {
		return nil, err
	}

	// Check if the file size exceeds 100MB
	var maxSize int64 = 100 * 1024 * 1024 // 100MB in bytes
	if info.Size() > maxSize {
Michael Yang's avatar
lint  
Michael Yang committed
566
		return nil, errors.New("file size exceeds maximum limit (100MB)")
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
	}

	buf = make([]byte, info.Size())
	_, err = file.Seek(0, 0)
	if err != nil {
		return nil, err
	}

	_, err = io.ReadFull(file, buf)
	if err != nil {
		return nil, err
	}

	return buf, nil
}