interactive.go 17.2 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
	"strings"

	"github.com/spf13/cobra"
Michael Yang's avatar
Michael Yang committed
16
	"golang.org/x/exp/maps"
17

18
	"github.com/ollama/ollama/api"
19
	"github.com/ollama/ollama/envconfig"
Michael Yang's avatar
Michael Yang committed
20
	"github.com/ollama/ollama/parser"
21
	"github.com/ollama/ollama/readline"
22
	"github.com/ollama/ollama/types/errtypes"
23
24
25
26
27
28
29
30
31
32
)

type MultilineState int

const (
	MultilineNone MultilineState = iota
	MultilinePrompt
	MultilineSystem
)

33
func generateInteractive(cmd *cobra.Command, opts runOptions) error {
34
35
	usage := func() {
		fmt.Fprintln(os.Stderr, "Available Commands:")
36
37
38
39
		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
40
		fmt.Fprintln(os.Stderr, "  /clear          Clear session context")
41
42
43
		fmt.Fprintln(os.Stderr, "  /bye            Exit")
		fmt.Fprintln(os.Stderr, "  /?, /help       Help for a command")
		fmt.Fprintln(os.Stderr, "  /? shortcuts    Help for keyboard shortcuts")
44
45
		fmt.Fprintln(os.Stderr, "")
		fmt.Fprintln(os.Stderr, "Use \"\"\" to begin a multi-line message.")
46
47
48
49
50

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

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
76
		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
77
		fmt.Fprintln(os.Stderr, "  Ctrl + w            Delete the word before the cursor")
78
79
80
81
82
83
84
85
86
		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:")
87
		fmt.Fprintln(os.Stderr, "  /show info         Show details for this model")
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
		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")
103
		fmt.Fprintln(os.Stderr, "  /set parameter min_p <float>          Pick token based on top token probability * min_p")
104
105
106
107
108
		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")
109
		fmt.Fprintln(os.Stderr, "  /set parameter stop <string> <string> ...   Set the stop parameters")
110
111
112
113
114
115
116
117
118
119
120
121
122
		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
123
	if envconfig.NoHistory() {
124
125
126
		scanner.HistoryDisable()
	}

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

130
	var sb strings.Builder
131
132
133
134
135
136
137
138
139
140
141
142
143
144
	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
145
			sb.Reset()
146
147
148
149
150
151
152

			continue
		case err != nil:
			return err
		}

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

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

170
			multiline = MultilineNone
171
172
173
174
175
176
177
178
179
180
181
			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
			}
182
		case scanner.Pasting:
183
			fmt.Fprintln(&sb, line)
184
185
186
187
188
189
			continue
		case strings.HasPrefix(line, "/list"):
			args := strings.Fields(line)
			if err := ListHandler(cmd, args[1:]); err != nil {
				return err
			}
190
191
192
193
194
195
196
197
198
		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
199
			if err := loadOrUnloadModel(cmd, &opts); err != nil {
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
				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
			}

			req := &api.CreateRequest{
				Name:      args[1],
				Modelfile: buildModelfile(opts),
			}
			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":
Michael Yang's avatar
Michael Yang committed
351
					_ = showInfo(resp, 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 buildModelfile(opts runOptions) string {
Michael Yang's avatar
Michael Yang committed
463
464
465
	var f parser.File
	f.Commands = append(f.Commands, parser.Command{Name: "model", Args: cmp.Or(opts.ParentModel, opts.Model)})

466
	if opts.System != "" {
Michael Yang's avatar
Michael Yang committed
467
		f.Commands = append(f.Commands, parser.Command{Name: "system", Args: opts.System})
468
469
	}

Michael Yang's avatar
Michael Yang committed
470
471
	keys := maps.Keys(opts.Options)
	slices.Sort(keys)
472
	for _, k := range keys {
Michael Yang's avatar
Michael Yang committed
473
474
475
476
477
478
479
480
481
482
483
484
		v := opts.Options[k]
		var cmds []parser.Command
		switch t := v.(type) {
		case []string:
			for _, s := range t {
				cmds = append(cmds, parser.Command{Name: k, Args: s})
			}
		default:
			cmds = append(cmds, parser.Command{Name: k, Args: fmt.Sprintf("%v", t)})
		}

		f.Commands = append(f.Commands, cmds...)
485
486
487
	}

	for _, msg := range opts.Messages {
488
489
490
		if strings.Contains(msg.Content, "\"") {
			msg.Content = `"""` + msg.Content + `"""`
		}
Michael Yang's avatar
Michael Yang committed
491
		f.Commands = append(f.Commands, parser.Command{Name: "message", Args: fmt.Sprintf("%s: %s", msg.Role, msg.Content)})
492
493
	}

Michael Yang's avatar
Michael Yang committed
494
	return f.String()
495
496
}

497
func normalizeFilePath(fp string) string {
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
	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)
514
515
516
}

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

	return re.FindAllString(input, -1)
}

526
func extractFileData(input string) (string, []api.ImageData, error) {
527
	filePaths := extractFileNames(input)
528
	var imgs []api.ImageData
529
530
531
532

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

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)
560
	allowedTypes := []string{"image/jpeg", "image/jpg", "image/png"}
561
562
563
564
565
566
567
568
569
570
571
572
	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
573
		return nil, errors.New("file size exceeds maximum limit (100MB)")
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
	}

	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
}