cmd.go 31.6 KB
Newer Older
Jeffrey Morgan's avatar
Jeffrey Morgan committed
1
2
3
package cmd

import (
4
	"archive/zip"
Michael Yang's avatar
Michael Yang committed
5
	"bytes"
Jeffrey Morgan's avatar
Jeffrey Morgan committed
6
	"context"
7
8
	"crypto/ed25519"
	"crypto/rand"
Michael Yang's avatar
Michael Yang committed
9
	"crypto/sha256"
10
	"encoding/pem"
Michael Yang's avatar
Michael Yang committed
11
	"errors"
Bruce MacDonald's avatar
Bruce MacDonald committed
12
	"fmt"
Michael Yang's avatar
Michael Yang committed
13
	"io"
Jeffrey Morgan's avatar
Jeffrey Morgan committed
14
	"log"
15
	"math"
Jeffrey Morgan's avatar
Jeffrey Morgan committed
16
	"net"
17
	"net/http"
Jeffrey Morgan's avatar
Jeffrey Morgan committed
18
	"os"
19
	"os/signal"
20
	"path/filepath"
21
	"regexp"
22
	"runtime"
23
	"slices"
Michael Yang's avatar
Michael Yang committed
24
	"strings"
25
	"syscall"
Michael Yang's avatar
Michael Yang committed
26
	"time"
Jeffrey Morgan's avatar
Jeffrey Morgan committed
27

28
	"github.com/containerd/console"
29
	"github.com/mattn/go-runewidth"
Patrick Devine's avatar
Patrick Devine committed
30
	"github.com/olekukonko/tablewriter"
Michael Yang's avatar
Michael Yang committed
31
	"github.com/spf13/cobra"
32
	"golang.org/x/crypto/ssh"
33
	"golang.org/x/term"
Michael Yang's avatar
Michael Yang committed
34

35
	"github.com/ollama/ollama/api"
36
	"github.com/ollama/ollama/auth"
37
	"github.com/ollama/ollama/envconfig"
38
	"github.com/ollama/ollama/format"
39
	"github.com/ollama/ollama/parser"
40
41
	"github.com/ollama/ollama/progress"
	"github.com/ollama/ollama/server"
42
43
	"github.com/ollama/ollama/types/errtypes"
	"github.com/ollama/ollama/types/model"
44
	"github.com/ollama/ollama/version"
Jeffrey Morgan's avatar
Jeffrey Morgan committed
45
46
)

47
func CreateHandler(cmd *cobra.Command, args []string) error {
48
	filename, _ := cmd.Flags().GetString("file")
49
50
51
52
53
	filename, err := filepath.Abs(filename)
	if err != nil {
		return err
	}

Michael Yang's avatar
Michael Yang committed
54
	client, err := api.ClientFromEnvironment()
55
56
57
	if err != nil {
		return err
	}
58

Michael Yang's avatar
Michael Yang committed
59
60
61
	p := progress.NewProgress(os.Stderr)
	defer p.Stop()

Michael Yang's avatar
Michael Yang committed
62
	f, err := os.Open(filename)
Michael Yang's avatar
Michael Yang committed
63
64
65
	if err != nil {
		return err
	}
Michael Yang's avatar
Michael Yang committed
66
	defer f.Close()
Michael Yang's avatar
Michael Yang committed
67

68
	modelfile, err := parser.ParseFile(f)
Michael Yang's avatar
Michael Yang committed
69
70
71
72
73
74
75
76
77
	if err != nil {
		return err
	}

	home, err := os.UserHomeDir()
	if err != nil {
		return err
	}

78
79
	status := "transferring model data"
	spinner := progress.NewSpinner(status)
80
81
	p.Add(status, spinner)

Michael Yang's avatar
Michael Yang committed
82
83
	for i := range modelfile.Commands {
		switch modelfile.Commands[i].Name {
Michael Yang's avatar
Michael Yang committed
84
		case "model", "adapter":
Michael Yang's avatar
Michael Yang committed
85
			path := modelfile.Commands[i].Args
Michael Yang's avatar
Michael Yang committed
86
87
88
89
90
91
			if path == "~" {
				path = home
			} else if strings.HasPrefix(path, "~/") {
				path = filepath.Join(home, path[2:])
			}

92
93
94
95
			if !filepath.IsAbs(path) {
				path = filepath.Join(filepath.Dir(filename), path)
			}

96
			fi, err := os.Stat(path)
Michael Yang's avatar
Michael Yang committed
97
			if errors.Is(err, os.ErrNotExist) && modelfile.Commands[i].Name == "model" {
Michael Yang's avatar
Michael Yang committed
98
				continue
Michael Yang's avatar
Michael Yang committed
99
100
101
102
			} else if err != nil {
				return err
			}

103
			if fi.IsDir() {
Michael Yang's avatar
Michael Yang committed
104
105
106
				// this is likely a safetensors or pytorch directory
				// TODO make this work w/ adapters
				tempfile, err := tempZipFiles(path)
107
108
109
				if err != nil {
					return err
				}
Michael Yang's avatar
Michael Yang committed
110
				defer os.RemoveAll(tempfile)
111

Michael Yang's avatar
Michael Yang committed
112
				path = tempfile
Michael Yang's avatar
Michael Yang committed
113
114
			}

115
116
			digest, err := createBlob(cmd, client, path)
			if err != nil {
Michael Yang's avatar
Michael Yang committed
117
118
119
				return err
			}

Michael Yang's avatar
Michael Yang committed
120
			modelfile.Commands[i].Args = "@" + digest
Michael Yang's avatar
Michael Yang committed
121
122
		}
	}
Michael Yang's avatar
Michael Yang committed
123

Michael Yang's avatar
Michael Yang committed
124
	bars := make(map[string]*progress.Bar)
125
	fn := func(resp api.ProgressResponse) error {
Michael Yang's avatar
Michael Yang committed
126
127
128
129
130
		if resp.Digest != "" {
			spinner.Stop()

			bar, ok := bars[resp.Digest]
			if !ok {
131
				bar = progress.NewBar(fmt.Sprintf("pulling %s...", resp.Digest[7:19]), resp.Total, resp.Completed)
Michael Yang's avatar
Michael Yang committed
132
133
134
135
136
137
138
139
140
141
142
143
144
				bars[resp.Digest] = bar
				p.Add(resp.Digest, bar)
			}

			bar.Set(resp.Completed)
		} else if status != resp.Status {
			spinner.Stop()

			status = resp.Status
			spinner = progress.NewSpinner(status)
			p.Add(status, spinner)
		}

145
146
147
		return nil
	}

148
	quantize, _ := cmd.Flags().GetString("quantize")
Michael Yang's avatar
Michael Yang committed
149

150
	request := api.CreateRequest{Name: args[0], Modelfile: modelfile.String(), Quantize: quantize}
Michael Yang's avatar
Michael Yang committed
151
	if err := client.Create(cmd.Context(), &request, fn); err != nil {
152
153
154
155
156
157
		return err
	}

	return nil
}

Michael Yang's avatar
Michael Yang committed
158
159
160
161
162
163
164
func tempZipFiles(path string) (string, error) {
	tempfile, err := os.CreateTemp("", "ollama-tf")
	if err != nil {
		return "", err
	}
	defer tempfile.Close()

Michael Yang's avatar
Michael Yang committed
165
166
	detectContentType := func(path string) (string, error) {
		f, err := os.Open(path)
Michael Yang's avatar
Michael Yang committed
167
168
169
		if err != nil {
			return "", err
		}
Michael Yang's avatar
Michael Yang committed
170
		defer f.Close()
Michael Yang's avatar
Michael Yang committed
171

Michael Yang's avatar
Michael Yang committed
172
173
		var b bytes.Buffer
		b.Grow(512)
Michael Yang's avatar
Michael Yang committed
174

Michael Yang's avatar
Michael Yang committed
175
176
177
178
179
180
		if _, err := io.CopyN(&b, f, 512); err != nil && !errors.Is(err, io.EOF) {
			return "", err
		}

		contentType, _, _ := strings.Cut(http.DetectContentType(b.Bytes()), ";")
		return contentType, nil
Michael Yang's avatar
Michael Yang committed
181
182
	}

Michael Yang's avatar
Michael Yang committed
183
184
185
186
187
188
189
190
191
192
193
	glob := func(pattern, contentType string) ([]string, error) {
		matches, err := filepath.Glob(pattern)
		if err != nil {
			return nil, err
		}

		for _, safetensor := range matches {
			if ct, err := detectContentType(safetensor); err != nil {
				return nil, err
			} else if ct != contentType {
				return nil, fmt.Errorf("invalid content type: expected %s for %s", ct, safetensor)
Michael Yang's avatar
Michael Yang committed
194
			}
Michael Yang's avatar
Michael Yang committed
195
196
197
198
199
200
201
202
203
204
205
206
207
208
		}

		return matches, nil
	}

	var files []string
	if st, _ := glob(filepath.Join(path, "model*.safetensors"), "application/octet-stream"); len(st) > 0 {
		// safetensors files might be unresolved git lfs references; skip if they are
		// covers model-x-of-y.safetensors, model.fp32-x-of-y.safetensors, model.safetensors
		files = append(files, st...)
	} else if pt, _ := glob(filepath.Join(path, "pytorch_model*.bin"), "application/zip"); len(pt) > 0 {
		// pytorch files might also be unresolved git lfs references; skip if they are
		// covers pytorch_model-x-of-y.bin, pytorch_model.fp32-x-of-y.bin, pytorch_model.bin
		files = append(files, pt...)
Patrick Devine's avatar
Patrick Devine committed
209
	} else if pt, _ := glob(filepath.Join(path, "consolidated*.pth"), "application/zip"); len(pt) > 0 {
Michael Yang's avatar
Michael Yang committed
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
		// pytorch files might also be unresolved git lfs references; skip if they are
		// covers consolidated.x.pth, consolidated.pth
		files = append(files, pt...)
	} else {
		return "", errors.New("no safetensors or torch files found")
	}

	// add configuration files, json files are detected as text/plain
	js, err := glob(filepath.Join(path, "*.json"), "text/plain")
	if err != nil {
		return "", err
	}
	files = append(files, js...)

	if tks, _ := glob(filepath.Join(path, "tokenizer.model"), "application/octet-stream"); len(tks) > 0 {
		// add tokenizer.model if it exists, tokenizer.json is automatically picked up by the previous glob
		// tokenizer.model might be a unresolved git lfs reference; error if it is
		files = append(files, tks...)
	} else if tks, _ := glob(filepath.Join(path, "**/tokenizer.model"), "text/plain"); len(tks) > 0 {
		// some times tokenizer.model is in a subdirectory (e.g. meta-llama/Meta-Llama-3-8B)
		files = append(files, tks...)
	}

233
234
235
	zipfile := zip.NewWriter(tempfile)
	defer zipfile.Close()

Michael Yang's avatar
Michael Yang committed
236
237
238
	for _, file := range files {
		f, err := os.Open(file)
		if err != nil {
Michael Yang's avatar
Michael Yang committed
239
240
			return "", err
		}
Michael Yang's avatar
Michael Yang committed
241
		defer f.Close()
Michael Yang's avatar
Michael Yang committed
242
243
244
245
246
247

		fi, err := f.Stat()
		if err != nil {
			return "", err
		}

Michael Yang's avatar
Michael Yang committed
248
		zfi, err := zip.FileInfoHeader(fi)
Michael Yang's avatar
Michael Yang committed
249
250
251
252
		if err != nil {
			return "", err
		}

Michael Yang's avatar
Michael Yang committed
253
		zf, err := zipfile.CreateHeader(zfi)
Michael Yang's avatar
Michael Yang committed
254
255
256
257
		if err != nil {
			return "", err
		}

Michael Yang's avatar
Michael Yang committed
258
		if _, err := io.Copy(zf, f); err != nil {
Michael Yang's avatar
Michael Yang committed
259
260
261
262
263
264
265
			return "", err
		}
	}

	return tempfile.Name(), nil
}

266
267
268
269
270
271
272
273
274
275
276
func createBlob(cmd *cobra.Command, client *api.Client, path string) (string, error) {
	bin, err := os.Open(path)
	if err != nil {
		return "", err
	}
	defer bin.Close()

	hash := sha256.New()
	if _, err := io.Copy(hash, bin); err != nil {
		return "", err
	}
277
278
279
280

	if _, err := bin.Seek(0, io.SeekStart); err != nil {
		return "", err
	}
281
282
283
284
285
286
287
288

	digest := fmt.Sprintf("sha256:%x", hash.Sum(nil))
	if err = client.CreateBlob(cmd.Context(), digest, bin); err != nil {
		return "", err
	}
	return digest, nil
}

289
func RunHandler(cmd *cobra.Command, args []string) error {
290
291
292
	interactive := true

	opts := runOptions{
293
294
295
		Model:    args[0],
		WordWrap: os.Getenv("TERM") == "xterm-256color",
		Options:  map[string]interface{}{},
296
297
298
299
300
301
302
303
	}

	format, err := cmd.Flags().GetString("format")
	if err != nil {
		return err
	}
	opts.Format = format

304
305
306
307
308
309
310
311
312
313
314
315
	keepAlive, err := cmd.Flags().GetString("keepalive")
	if err != nil {
		return err
	}
	if keepAlive != "" {
		d, err := time.ParseDuration(keepAlive)
		if err != nil {
			return err
		}
		opts.KeepAlive = &api.Duration{Duration: d}
	}

316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
	prompts := args[1:]
	// prepend stdin to the prompt if provided
	if !term.IsTerminal(int(os.Stdin.Fd())) {
		in, err := io.ReadAll(os.Stdin)
		if err != nil {
			return err
		}

		prompts = append([]string{string(in)}, prompts...)
		opts.WordWrap = false
		interactive = false
	}
	opts.Prompt = strings.Join(prompts, " ")
	if len(prompts) > 0 {
		interactive = false
	}

	nowrap, err := cmd.Flags().GetBool("nowordwrap")
	if err != nil {
		return err
	}
	opts.WordWrap = !nowrap

339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
	// Fill out the rest of the options based on information about the
	// model.
	client, err := api.ClientFromEnvironment()
	if err != nil {
		return err
	}

	name := args[0]
	info, err := func() (*api.ShowResponse, error) {
		showReq := &api.ShowRequest{Name: name}
		info, err := client.Show(cmd.Context(), showReq)
		var se api.StatusError
		if errors.As(err, &se) && se.StatusCode == http.StatusNotFound {
			if err := PullHandler(cmd, []string{name}); err != nil {
				return nil, err
			}
			return client.Show(cmd.Context(), &api.ShowRequest{Name: name})
		}
		return info, err
	}()
	if err != nil {
		return err
361
362
	}

363
364
365
366
	opts.MultiModal = slices.Contains(info.Details.Families, "clip")
	opts.ParentModel = info.Details.ParentModel

	if interactive {
Michael Yang's avatar
Michael Yang committed
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
		if err := loadModel(cmd, &opts); err != nil {
			return err
		}

		for _, msg := range info.Messages {
			switch msg.Role {
			case "user":
				fmt.Printf(">>> %s\n", msg.Content)
			case "assistant":
				state := &displayResponseState{}
				displayResponse(msg.Content, opts.WordWrap, state)
				fmt.Println()
				fmt.Println()
			}
		}

383
384
385
		return generateInteractive(cmd, opts)
	}
	return generate(cmd, opts)
Bruce MacDonald's avatar
Bruce MacDonald committed
386
387
}

388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
func errFromUnknownKey(unknownKeyErr error) error {
	// find SSH public key in the error message
	sshKeyPattern := `ssh-\w+ [^\s"]+`
	re := regexp.MustCompile(sshKeyPattern)
	matches := re.FindStringSubmatch(unknownKeyErr.Error())

	if len(matches) > 0 {
		serverPubKey := matches[0]

		localPubKey, err := auth.GetPublicKey()
		if err != nil {
			return unknownKeyErr
		}

		if runtime.GOOS == "linux" && serverPubKey != localPubKey {
			// try the ollama service public key
			svcPubKey, err := os.ReadFile("/usr/share/ollama/.ollama/id_ed25519.pub")
			if err != nil {
				return unknownKeyErr
			}
			localPubKey = strings.TrimSpace(string(svcPubKey))
		}

		// check if the returned public key matches the local public key, this prevents adding a remote key to the user's account
		if serverPubKey != localPubKey {
			return unknownKeyErr
		}

		var msg strings.Builder
		msg.WriteString(unknownKeyErr.Error())
		msg.WriteString("\n\nYour ollama key is:\n")
		msg.WriteString(localPubKey)
		msg.WriteString("\nAdd your key at:\n")
		msg.WriteString("https://ollama.com/settings/keys")

		return errors.New(msg.String())
	}

	return unknownKeyErr
}

429
func PushHandler(cmd *cobra.Command, args []string) error {
Michael Yang's avatar
Michael Yang committed
430
	client, err := api.ClientFromEnvironment()
431
432
433
	if err != nil {
		return err
	}
434

435
436
437
438
439
	insecure, err := cmd.Flags().GetBool("insecure")
	if err != nil {
		return err
	}

Michael Yang's avatar
Michael Yang committed
440
441
442
443
	p := progress.NewProgress(os.Stderr)
	defer p.Stop()

	bars := make(map[string]*progress.Bar)
444
445
	var status string
	var spinner *progress.Spinner
Michael Yang's avatar
Michael Yang committed
446

447
	fn := func(resp api.ProgressResponse) error {
Michael Yang's avatar
Michael Yang committed
448
		if resp.Digest != "" {
449
450
451
			if spinner != nil {
				spinner.Stop()
			}
Michael Yang's avatar
Michael Yang committed
452
453
454

			bar, ok := bars[resp.Digest]
			if !ok {
455
				bar = progress.NewBar(fmt.Sprintf("pushing %s...", resp.Digest[7:19]), resp.Total, resp.Completed)
Michael Yang's avatar
Michael Yang committed
456
457
458
459
460
461
				bars[resp.Digest] = bar
				p.Add(resp.Digest, bar)
			}

			bar.Set(resp.Completed)
		} else if status != resp.Status {
462
463
464
			if spinner != nil {
				spinner.Stop()
			}
Michael Yang's avatar
Michael Yang committed
465
466
467
468
469
470

			status = resp.Status
			spinner = progress.NewSpinner(status)
			p.Add(status, spinner)
		}

471
472
473
		return nil
	}

Michael Yang's avatar
Michael Yang committed
474
	request := api.PushRequest{Name: args[0], Insecure: insecure}
Michael Yang's avatar
Michael Yang committed
475
	if err := client.Push(cmd.Context(), &request, fn); err != nil {
476
477
478
479
480
481
482
483
484
485
486
487
488
489
		if spinner != nil {
			spinner.Stop()
		}
		if strings.Contains(err.Error(), "access denied") {
			return errors.New("you are not authorized to push to this namespace, create the model under a namespace you own")
		}
		host := model.ParseName(args[0]).Host
		isOllamaHost := strings.HasSuffix(host, ".ollama.ai") || strings.HasSuffix(host, ".ollama.com")
		if strings.Contains(err.Error(), errtypes.UnknownOllamaKeyErrMsg) && isOllamaHost {
			// the user has not added their ollama key to ollama.com
			// re-throw an error with a more user-friendly message
			return errFromUnknownKey(err)
		}

Michael Yang's avatar
Michael Yang committed
490
491
492
		return err
	}

493
	spinner.Stop()
Michael Yang's avatar
Michael Yang committed
494
	return nil
495
496
}

497
func ListHandler(cmd *cobra.Command, args []string) error {
Michael Yang's avatar
Michael Yang committed
498
	client, err := api.ClientFromEnvironment()
499
500
501
	if err != nil {
		return err
	}
Patrick Devine's avatar
Patrick Devine committed
502

Michael Yang's avatar
Michael Yang committed
503
	models, err := client.List(cmd.Context())
Patrick Devine's avatar
Patrick Devine committed
504
505
506
507
508
509
510
	if err != nil {
		return err
	}

	var data [][]string

	for _, m := range models.Models {
Michael Yang's avatar
Michael Yang committed
511
		if len(args) == 0 || strings.HasPrefix(m.Name, args[0]) {
512
			data = append(data, []string{m.Name, m.Digest[:12], format.HumanBytes(m.Size), format.HumanTime(m.ModifiedAt, "Never")})
Michael Yang's avatar
Michael Yang committed
513
		}
Patrick Devine's avatar
Patrick Devine committed
514
515
516
	}

	table := tablewriter.NewWriter(os.Stdout)
Patrick Devine's avatar
Patrick Devine committed
517
	table.SetHeader([]string{"NAME", "ID", "SIZE", "MODIFIED"})
Patrick Devine's avatar
Patrick Devine committed
518
519
520
521
522
523
524
525
526
527
528
529
	table.SetHeaderAlignment(tablewriter.ALIGN_LEFT)
	table.SetAlignment(tablewriter.ALIGN_LEFT)
	table.SetHeaderLine(false)
	table.SetBorder(false)
	table.SetNoWhiteSpace(true)
	table.SetTablePadding("\t")
	table.AppendBulk(data)
	table.Render()

	return nil
}

530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
func ListRunningHandler(cmd *cobra.Command, args []string) error {
	client, err := api.ClientFromEnvironment()
	if err != nil {
		return err
	}

	models, err := client.ListRunning(cmd.Context())
	if err != nil {
		return err
	}

	var data [][]string

	for _, m := range models.Models {
		if len(args) == 0 || strings.HasPrefix(m.Name, args[0]) {
			var procStr string
			switch {
			case m.SizeVRAM == 0:
				procStr = "100% CPU"
			case m.SizeVRAM == m.Size:
				procStr = "100% GPU"
			case m.SizeVRAM > m.Size || m.Size == 0:
				procStr = "Unknown"
			default:
				sizeCPU := m.Size - m.SizeVRAM
				cpuPercent := math.Round(float64(sizeCPU) / float64(m.Size) * 100)
				procStr = fmt.Sprintf("%d%%/%d%% CPU/GPU", int(cpuPercent), int(100-cpuPercent))
			}
			data = append(data, []string{m.Name, m.Digest[:12], format.HumanBytes(m.Size), procStr, format.HumanTime(m.ExpiresAt, "Never")})
		}
	}

	table := tablewriter.NewWriter(os.Stdout)
	table.SetHeader([]string{"NAME", "ID", "SIZE", "PROCESSOR", "UNTIL"})
	table.SetHeaderAlignment(tablewriter.ALIGN_LEFT)
	table.SetAlignment(tablewriter.ALIGN_LEFT)
	table.SetHeaderLine(false)
	table.SetBorder(false)
	table.SetNoWhiteSpace(true)
	table.SetTablePadding("\t")
	table.AppendBulk(data)
	table.Render()

	return nil
}

576
func DeleteHandler(cmd *cobra.Command, args []string) error {
Michael Yang's avatar
Michael Yang committed
577
	client, err := api.ClientFromEnvironment()
578
579
580
	if err != nil {
		return err
	}
581

582
583
	for _, name := range args {
		req := api.DeleteRequest{Name: name}
Michael Yang's avatar
Michael Yang committed
584
		if err := client.Delete(cmd.Context(), &req); err != nil {
585
586
587
			return err
		}
		fmt.Printf("deleted '%s'\n", name)
588
589
590
591
	}
	return nil
}

Patrick Devine's avatar
Patrick Devine committed
592
func ShowHandler(cmd *cobra.Command, args []string) error {
Michael Yang's avatar
Michael Yang committed
593
	client, err := api.ClientFromEnvironment()
Patrick Devine's avatar
Patrick Devine committed
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
	if err != nil {
		return err
	}

	license, errLicense := cmd.Flags().GetBool("license")
	modelfile, errModelfile := cmd.Flags().GetBool("modelfile")
	parameters, errParams := cmd.Flags().GetBool("parameters")
	system, errSystem := cmd.Flags().GetBool("system")
	template, errTemplate := cmd.Flags().GetBool("template")

	for _, boolErr := range []error{errLicense, errModelfile, errParams, errSystem, errTemplate} {
		if boolErr != nil {
			return errors.New("error retrieving flags")
		}
	}

	flagsSet := 0
	showType := ""

	if license {
		flagsSet++
		showType = "license"
	}

	if modelfile {
		flagsSet++
		showType = "modelfile"
	}

	if parameters {
		flagsSet++
		showType = "parameters"
	}

	if system {
		flagsSet++
		showType = "system"
	}

	if template {
		flagsSet++
		showType = "template"
	}

	if flagsSet > 1 {
639
		return errors.New("only one of '--license', '--modelfile', '--parameters', '--system', or '--template' can be specified")
640
641
	}

642
643
644
645
646
	req := api.ShowRequest{Name: args[0]}
	resp, err := client.Show(cmd.Context(), &req)
	if err != nil {
		return err
	}
647

648
	if flagsSet == 1 {
649
650
651
652
653
654
655
656
657
658
659
660
661
662
		switch showType {
		case "license":
			fmt.Println(resp.License)
		case "modelfile":
			fmt.Println(resp.Modelfile)
		case "parameters":
			fmt.Println(resp.Parameters)
		case "system":
			fmt.Println(resp.System)
		case "template":
			fmt.Println(resp.Template)
		}

		return nil
Patrick Devine's avatar
Patrick Devine committed
663
664
	}

665
	showInfo(resp)
Patrick Devine's avatar
Patrick Devine committed
666

667
668
669
670
	return nil
}

func showInfo(resp *api.ShowResponse) {
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
	arch := resp.ModelInfo["general.architecture"].(string)

	modelData := [][]string{
		{"arch", arch},
		{"parameters", resp.Details.ParameterSize},
		{"quantization", resp.Details.QuantizationLevel},
		{"context length", fmt.Sprintf("%v", resp.ModelInfo[fmt.Sprintf("%s.context_length", arch)].(float64))},
		{"embedding length", fmt.Sprintf("%v", resp.ModelInfo[fmt.Sprintf("%s.embedding_length", arch)].(float64))},
	}

	mainTableData := [][]string{
		{"Model"},
		{renderSubTable(modelData, false)},
	}

	if resp.ProjectorInfo != nil {
		projectorData := [][]string{
			{"arch", "clip"},
			{"parameters", format.HumanNumber(uint64(resp.ProjectorInfo["general.parameter_count"].(float64)))},
		}

692
693
694
695
696
697
698
699
700
		if projectorType, ok := resp.ProjectorInfo["clip.projector_type"]; ok {
			projectorData = append(projectorData, []string{"projector type", projectorType.(string)})
		}

		projectorData = append(projectorData,
			[]string{"embedding length", fmt.Sprintf("%v", resp.ProjectorInfo["clip.vision.embedding_length"].(float64))},
			[]string{"projection dimensionality", fmt.Sprintf("%v", resp.ProjectorInfo["clip.vision.projection_dim"].(float64))},
		)

701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
		mainTableData = append(mainTableData,
			[]string{"Projector"},
			[]string{renderSubTable(projectorData, false)},
		)
	}

	if resp.Parameters != "" {
		mainTableData = append(mainTableData, []string{"Parameters"}, []string{formatParams(resp.Parameters)})
	}

	if resp.System != "" {
		mainTableData = append(mainTableData, []string{"System"}, []string{renderSubTable(twoLines(resp.System), true)})
	}

	if resp.License != "" {
		mainTableData = append(mainTableData, []string{"License"}, []string{renderSubTable(twoLines(resp.License), true)})
	}

	table := tablewriter.NewWriter(os.Stdout)
	table.SetAutoWrapText(false)
	table.SetBorder(false)
	table.SetAlignment(tablewriter.ALIGN_LEFT)

	for _, v := range mainTableData {
		table.Append(v)
Patrick Devine's avatar
Patrick Devine committed
726
727
	}

728
	table.Render()
Patrick Devine's avatar
Patrick Devine committed
729
730
}

731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
func renderSubTable(data [][]string, file bool) string {
	var buf bytes.Buffer
	table := tablewriter.NewWriter(&buf)
	table.SetAutoWrapText(!file)
	table.SetBorder(false)
	table.SetNoWhiteSpace(true)
	table.SetTablePadding("\t")
	table.SetAlignment(tablewriter.ALIGN_LEFT)

	for _, v := range data {
		table.Append(v)
	}

	table.Render()

	renderedTable := buf.String()
	lines := strings.Split(renderedTable, "\n")
	for i, line := range lines {
		lines[i] = "\t" + line
	}

	return strings.Join(lines, "\n")
}

func twoLines(s string) [][]string {
	lines := strings.Split(s, "\n")
	res := [][]string{}

	count := 0
	for _, line := range lines {
		line = strings.TrimSpace(line)
		if line != "" {
			count++
			res = append(res, []string{line})
			if count == 2 {
				return res
			}
		}
	}
	return res
}

func formatParams(s string) string {
	lines := strings.Split(s, "\n")
	table := [][]string{}

	for _, line := range lines {
		table = append(table, strings.Fields(line))
	}
	return renderSubTable(table, false)
}

Patrick Devine's avatar
Patrick Devine committed
783
func CopyHandler(cmd *cobra.Command, args []string) error {
Michael Yang's avatar
Michael Yang committed
784
	client, err := api.ClientFromEnvironment()
785
786
787
	if err != nil {
		return err
	}
Patrick Devine's avatar
Patrick Devine committed
788
789

	req := api.CopyRequest{Source: args[0], Destination: args[1]}
Michael Yang's avatar
Michael Yang committed
790
	if err := client.Copy(cmd.Context(), &req); err != nil {
Patrick Devine's avatar
Patrick Devine committed
791
792
793
794
795
796
		return err
	}
	fmt.Printf("copied '%s' to '%s'\n", args[0], args[1])
	return nil
}

797
func PullHandler(cmd *cobra.Command, args []string) error {
798
799
800
801
802
	insecure, err := cmd.Flags().GetBool("insecure")
	if err != nil {
		return err
	}

Michael Yang's avatar
Michael Yang committed
803
	client, err := api.ClientFromEnvironment()
804
805
806
	if err != nil {
		return err
	}
807

Michael Yang's avatar
Michael Yang committed
808
809
810
811
812
	p := progress.NewProgress(os.Stderr)
	defer p.Stop()

	bars := make(map[string]*progress.Bar)

813
814
	var status string
	var spinner *progress.Spinner
Michael Yang's avatar
Michael Yang committed
815

816
	fn := func(resp api.ProgressResponse) error {
Michael Yang's avatar
Michael Yang committed
817
		if resp.Digest != "" {
818
819
820
			if spinner != nil {
				spinner.Stop()
			}
Michael Yang's avatar
Michael Yang committed
821
822
823

			bar, ok := bars[resp.Digest]
			if !ok {
824
				bar = progress.NewBar(fmt.Sprintf("pulling %s...", resp.Digest[7:19]), resp.Total, resp.Completed)
Michael Yang's avatar
Michael Yang committed
825
826
827
828
829
830
				bars[resp.Digest] = bar
				p.Add(resp.Digest, bar)
			}

			bar.Set(resp.Completed)
		} else if status != resp.Status {
831
832
833
			if spinner != nil {
				spinner.Stop()
			}
Michael Yang's avatar
Michael Yang committed
834
835
836
837
838
839

			status = resp.Status
			spinner = progress.NewSpinner(status)
			p.Add(status, spinner)
		}

840
841
		return nil
	}
842

Michael Yang's avatar
Michael Yang committed
843
	request := api.PullRequest{Name: args[0], Insecure: insecure}
Michael Yang's avatar
Michael Yang committed
844
	if err := client.Pull(cmd.Context(), &request, fn); err != nil {
Michael Yang's avatar
Michael Yang committed
845
846
847
848
		return err
	}

	return nil
Michael Yang's avatar
Michael Yang committed
849
850
}

851
852
type generateContextKey string

853
type runOptions struct {
854
855
856
857
858
859
860
861
862
863
	Model       string
	ParentModel string
	Prompt      string
	Messages    []api.Message
	WordWrap    bool
	Format      string
	System      string
	Images      []api.ImageData
	Options     map[string]interface{}
	MultiModal  bool
864
	KeepAlive   *api.Duration
865
866
}

867
868
869
870
871
872
873
874
875
type displayResponseState struct {
	lineLength int
	wordBuffer string
}

func displayResponse(content string, wordWrap bool, state *displayResponseState) {
	termWidth, _, _ := term.GetSize(int(os.Stdout.Fd()))
	if wordWrap && termWidth >= 10 {
		for _, ch := range content {
Josh Yan's avatar
Josh Yan committed
876
877
			if state.lineLength+1 > termWidth-5 {
				if runewidth.StringWidth(state.wordBuffer) > termWidth-10 {
878
879
880
881
882
883
884
					fmt.Printf("%s%c", state.wordBuffer, ch)
					state.wordBuffer = ""
					state.lineLength = 0
					continue
				}

				// backtrack the length of the last word and clear to the end of the line
885
886
				a := runewidth.StringWidth(state.wordBuffer)
				if a > 0 {
887
					fmt.Printf("\x1b[%dD", a)
888
889
				}
				fmt.Printf("\x1b[K\n")
890
				fmt.Printf("%s%c", state.wordBuffer, ch)
891
892
893
				chWidth := runewidth.RuneWidth(ch)

				state.lineLength = runewidth.StringWidth(state.wordBuffer) + chWidth
894
895
			} else {
				fmt.Print(string(ch))
896
897
898
899
				state.lineLength += runewidth.RuneWidth(ch)
				if runewidth.RuneWidth(ch) >= 2 {
					state.wordBuffer = ""
					continue
Josh Yan's avatar
Josh Yan committed
900
				}
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968

				switch ch {
				case ' ':
					state.wordBuffer = ""
				case '\n':
					state.lineLength = 0
				default:
					state.wordBuffer += string(ch)
				}
			}
		}
	} else {
		fmt.Printf("%s%s", state.wordBuffer, content)
		if len(state.wordBuffer) > 0 {
			state.wordBuffer = ""
		}
	}
}

func chat(cmd *cobra.Command, opts runOptions) (*api.Message, error) {
	client, err := api.ClientFromEnvironment()
	if err != nil {
		return nil, err
	}

	p := progress.NewProgress(os.Stderr)
	defer p.StopAndClear()

	spinner := progress.NewSpinner("")
	p.Add("", spinner)

	cancelCtx, cancel := context.WithCancel(cmd.Context())
	defer cancel()

	sigChan := make(chan os.Signal, 1)
	signal.Notify(sigChan, syscall.SIGINT)

	go func() {
		<-sigChan
		cancel()
	}()

	var state *displayResponseState = &displayResponseState{}
	var latest api.ChatResponse
	var fullResponse strings.Builder
	var role string

	fn := func(response api.ChatResponse) error {
		p.StopAndClear()

		latest = response

		role = response.Message.Role
		content := response.Message.Content
		fullResponse.WriteString(content)

		displayResponse(content, opts.WordWrap, state)

		return nil
	}

	req := &api.ChatRequest{
		Model:    opts.Model,
		Messages: opts.Messages,
		Format:   opts.Format,
		Options:  opts.Options,
	}

969
970
971
972
	if opts.KeepAlive != nil {
		req.KeepAlive = opts.KeepAlive
	}

973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
	if err := client.Chat(cancelCtx, req, fn); err != nil {
		if errors.Is(err, context.Canceled) {
			return nil, nil
		}
		return nil, err
	}

	if len(opts.Messages) > 0 {
		fmt.Println()
		fmt.Println()
	}

	verbose, err := cmd.Flags().GetBool("verbose")
	if err != nil {
		return nil, err
	}

	if verbose {
		latest.Summary()
	}

	return &api.Message{Role: role, Content: fullResponse.String()}, nil
}

func generate(cmd *cobra.Command, opts runOptions) error {
Michael Yang's avatar
Michael Yang committed
998
	client, err := api.ClientFromEnvironment()
Patrick Devine's avatar
Patrick Devine committed
999
	if err != nil {
1000
		return err
Patrick Devine's avatar
Patrick Devine committed
1001
	}
Michael Yang's avatar
Michael Yang committed
1002

Michael Yang's avatar
Michael Yang committed
1003
	p := progress.NewProgress(os.Stderr)
1004
	defer p.StopAndClear()
1005

Michael Yang's avatar
Michael Yang committed
1006
1007
1008
	spinner := progress.NewSpinner("")
	p.Add("", spinner)

1009
1010
1011
1012
1013
1014
1015
	var latest api.GenerateResponse

	generateContext, ok := cmd.Context().Value(generateContextKey("context")).([]int)
	if !ok {
		generateContext = []int{}
	}

Michael Yang's avatar
Michael Yang committed
1016
	ctx, cancel := context.WithCancel(cmd.Context())
1017
1018
1019
1020
1021
1022
1023
1024
1025
1026
	defer cancel()

	sigChan := make(chan os.Signal, 1)
	signal.Notify(sigChan, syscall.SIGINT)

	go func() {
		<-sigChan
		cancel()
	}()

1027
	var state *displayResponseState = &displayResponseState{}
1028

1029
	fn := func(response api.GenerateResponse) error {
Michael Yang's avatar
Michael Yang committed
1030
		p.StopAndClear()
1031

Patrick Devine's avatar
Patrick Devine committed
1032
		latest = response
1033
		content := response.Response
1034

1035
		displayResponse(content, opts.WordWrap, state)
1036

Patrick Devine's avatar
Patrick Devine committed
1037
1038
		return nil
	}
1039

1040
1041
1042
1043
1044
1045
1046
	if opts.MultiModal {
		opts.Prompt, opts.Images, err = extractFileData(opts.Prompt)
		if err != nil {
			return err
		}
	}

Michael Yang's avatar
Michael Yang committed
1047
	request := api.GenerateRequest{
1048
1049
1050
1051
1052
1053
1054
1055
		Model:     opts.Model,
		Prompt:    opts.Prompt,
		Context:   generateContext,
		Images:    opts.Images,
		Format:    opts.Format,
		System:    opts.System,
		Options:   opts.Options,
		KeepAlive: opts.KeepAlive,
Michael Yang's avatar
Michael Yang committed
1056
1057
1058
	}

	if err := client.Generate(ctx, &request, fn); err != nil {
1059
		if errors.Is(err, context.Canceled) {
1060
			return nil
1061
		}
1062
		return err
Patrick Devine's avatar
Patrick Devine committed
1063
	}
1064

1065
	if opts.Prompt != "" {
Michael Yang's avatar
Michael Yang committed
1066
1067
		fmt.Println()
		fmt.Println()
Patrick Devine's avatar
Patrick Devine committed
1068
	}
1069

1070
1071
1072
1073
	if !latest.Done {
		return nil
	}

Patrick Devine's avatar
Patrick Devine committed
1074
1075
	verbose, err := cmd.Flags().GetBool("verbose")
	if err != nil {
1076
		return err
Patrick Devine's avatar
Patrick Devine committed
1077
	}
Michael Yang's avatar
Michael Yang committed
1078

Patrick Devine's avatar
Patrick Devine committed
1079
1080
	if verbose {
		latest.Summary()
Michael Yang's avatar
Michael Yang committed
1081
	}
Michael Yang's avatar
Michael Yang committed
1082

Patrick Devine's avatar
Patrick Devine committed
1083
1084
1085
	ctx = context.WithValue(cmd.Context(), generateContextKey("context"), latest.Context)
	cmd.SetContext(ctx)

1086
	return nil
Michael Yang's avatar
Michael Yang committed
1087
1088
}

1089
func RunServer(cmd *cobra.Command, _ []string) error {
Michael Yang's avatar
Michael Yang committed
1090
	if err := initializeKeypair(); err != nil {
1091
1092
1093
		return err
	}

1094
	ln, err := net.Listen("tcp", net.JoinHostPort(envconfig.Host.Host, envconfig.Host.Port))
1095
1096
1097
	if err != nil {
		return err
	}
Jeffrey Morgan's avatar
Jeffrey Morgan committed
1098

1099
1100
1101
1102
1103
1104
	err = server.Serve(ln)
	if errors.Is(err, http.ErrServerClosed) {
		return nil
	}

	return err
Jeffrey Morgan's avatar
Jeffrey Morgan committed
1105
1106
}

1107
1108
1109
1110
1111
1112
1113
1114
1115
1116
1117
1118
func initializeKeypair() error {
	home, err := os.UserHomeDir()
	if err != nil {
		return err
	}

	privKeyPath := filepath.Join(home, ".ollama", "id_ed25519")
	pubKeyPath := filepath.Join(home, ".ollama", "id_ed25519.pub")

	_, err = os.Stat(privKeyPath)
	if os.IsNotExist(err) {
		fmt.Printf("Couldn't find '%s'. Generating new private key.\n", privKeyPath)
Michael Yang's avatar
Michael Yang committed
1119
		cryptoPublicKey, cryptoPrivateKey, err := ed25519.GenerateKey(rand.Reader)
1120
1121
1122
1123
		if err != nil {
			return err
		}

Michael Yang's avatar
Michael Yang committed
1124
		privateKeyBytes, err := ssh.MarshalPrivateKey(cryptoPrivateKey, "")
1125
1126
1127
1128
		if err != nil {
			return err
		}

Michael Yang's avatar
Michael Yang committed
1129
		if err := os.MkdirAll(filepath.Dir(privKeyPath), 0o755); err != nil {
1130
1131
1132
			return fmt.Errorf("could not create directory %w", err)
		}

Michael Yang's avatar
Michael Yang committed
1133
		if err := os.WriteFile(privKeyPath, pem.EncodeToMemory(privateKeyBytes), 0o600); err != nil {
1134
1135
1136
			return err
		}

Michael Yang's avatar
Michael Yang committed
1137
		sshPublicKey, err := ssh.NewPublicKey(cryptoPublicKey)
1138
1139
1140
1141
		if err != nil {
			return err
		}

Michael Yang's avatar
Michael Yang committed
1142
		publicKeyBytes := ssh.MarshalAuthorizedKey(sshPublicKey)
1143

Michael Yang's avatar
Michael Yang committed
1144
		if err := os.WriteFile(pubKeyPath, publicKeyBytes, 0o644); err != nil {
1145
1146
1147
			return err
		}

Michael Yang's avatar
Michael Yang committed
1148
		fmt.Printf("Your new public key is: \n\n%s\n", publicKeyBytes)
1149
1150
1151
1152
	}
	return nil
}

Michael Yang's avatar
Michael Yang committed
1153
func checkServerHeartbeat(cmd *cobra.Command, _ []string) error {
Michael Yang's avatar
Michael Yang committed
1154
	client, err := api.ClientFromEnvironment()
1155
1156
1157
	if err != nil {
		return err
	}
Michael Yang's avatar
Michael Yang committed
1158
	if err := client.Heartbeat(cmd.Context()); err != nil {
1159
		if !strings.Contains(err.Error(), " refused") {
Bruce MacDonald's avatar
Bruce MacDonald committed
1160
1161
			return err
		}
1162
1163
		if err := startApp(cmd.Context(), client); err != nil {
			return fmt.Errorf("could not connect to ollama app, is it running?")
1164
1165
1166
1167
1168
		}
	}
	return nil
}

Michael Yang's avatar
Michael Yang committed
1169
1170
1171
1172
1173
1174
1175
1176
func versionHandler(cmd *cobra.Command, _ []string) {
	client, err := api.ClientFromEnvironment()
	if err != nil {
		return
	}

	serverVersion, err := client.Version(cmd.Context())
	if err != nil {
Michael Yang's avatar
Michael Yang committed
1177
1178
1179
1180
1181
		fmt.Println("Warning: could not connect to a running Ollama instance")
	}

	if serverVersion != "" {
		fmt.Printf("ollama version is %s\n", serverVersion)
Michael Yang's avatar
Michael Yang committed
1182
1183
	}

1184
	if serverVersion != version.Version {
Michael Yang's avatar
Michael Yang committed
1185
		fmt.Printf("Warning: client version is %s\n", version.Version)
1186
	}
Michael Yang's avatar
Michael Yang committed
1187
1188
}

1189
func appendEnvDocs(cmd *cobra.Command, envs []envconfig.EnvVar) {
1190
1191
1192
1193
1194
	if len(envs) == 0 {
		return
	}

	envUsage := `
1195
1196
Environment Variables:
`
1197
	for _, e := range envs {
1198
		envUsage += fmt.Sprintf("      %-24s   %s\n", e.Name, e.Description)
1199
1200
1201
	}

	cmd.SetUsageTemplate(cmd.UsageTemplate() + envUsage)
1202
1203
}

Jeffrey Morgan's avatar
Jeffrey Morgan committed
1204
1205
func NewCLI() *cobra.Command {
	log.SetFlags(log.LstdFlags | log.Lshortfile)
Michael Yang's avatar
Michael Yang committed
1206
	cobra.EnableCommandSorting = false
Jeffrey Morgan's avatar
Jeffrey Morgan committed
1207

1208
	if runtime.GOOS == "windows" {
1209
		console.ConsoleFromFile(os.Stdin) //nolint:errcheck
1210
1211
	}

Jeffrey Morgan's avatar
Jeffrey Morgan committed
1212
	rootCmd := &cobra.Command{
1213
1214
1215
1216
		Use:           "ollama",
		Short:         "Large language model runner",
		SilenceUsage:  true,
		SilenceErrors: true,
Jeffrey Morgan's avatar
Jeffrey Morgan committed
1217
1218
1219
		CompletionOptions: cobra.CompletionOptions{
			DisableDefaultCmd: true,
		},
Michael Yang's avatar
Michael Yang committed
1220
1221
1222
1223
1224
1225
1226
1227
		Run: func(cmd *cobra.Command, args []string) {
			if version, _ := cmd.Flags().GetBool("version"); version {
				versionHandler(cmd, args)
				return
			}

			cmd.Print(cmd.UsageString())
		},
Jeffrey Morgan's avatar
Jeffrey Morgan committed
1228
1229
	}

Michael Yang's avatar
Michael Yang committed
1230
	rootCmd.Flags().BoolP("version", "v", false, "Show version information")
Jeffrey Morgan's avatar
Jeffrey Morgan committed
1231

1232
	createCmd := &cobra.Command{
1233
1234
		Use:     "create MODEL",
		Short:   "Create a model from a Modelfile",
Michael Yang's avatar
Michael Yang committed
1235
		Args:    cobra.ExactArgs(1),
1236
1237
		PreRunE: checkServerHeartbeat,
		RunE:    CreateHandler,
1238
1239
	}

1240
	createCmd.Flags().StringP("file", "f", "Modelfile", "Name of the Modelfile")
1241
	createCmd.Flags().StringP("quantize", "q", "", "Quantize model to this level (e.g. q4_0)")
1242

Patrick Devine's avatar
Patrick Devine committed
1243
1244
1245
	showCmd := &cobra.Command{
		Use:     "show MODEL",
		Short:   "Show information for a model",
Michael Yang's avatar
Michael Yang committed
1246
		Args:    cobra.ExactArgs(1),
Patrick Devine's avatar
Patrick Devine committed
1247
1248
1249
1250
1251
1252
1253
1254
		PreRunE: checkServerHeartbeat,
		RunE:    ShowHandler,
	}

	showCmd.Flags().Bool("license", false, "Show license of a model")
	showCmd.Flags().Bool("modelfile", false, "Show Modelfile of a model")
	showCmd.Flags().Bool("parameters", false, "Show parameters of a model")
	showCmd.Flags().Bool("template", false, "Show template of a model")
1255
	showCmd.Flags().Bool("system", false, "Show system message of a model")
Patrick Devine's avatar
Patrick Devine committed
1256

Jeffrey Morgan's avatar
Jeffrey Morgan committed
1257
	runCmd := &cobra.Command{
1258
1259
1260
1261
1262
		Use:     "run MODEL [PROMPT]",
		Short:   "Run a model",
		Args:    cobra.MinimumNArgs(1),
		PreRunE: checkServerHeartbeat,
		RunE:    RunHandler,
Jeffrey Morgan's avatar
Jeffrey Morgan committed
1263
1264
	}

1265
	runCmd.Flags().String("keepalive", "", "Duration to keep a model loaded (e.g. 5m)")
1266
	runCmd.Flags().Bool("verbose", false, "Show timings for response")
1267
	runCmd.Flags().Bool("insecure", false, "Use an insecure registry")
1268
	runCmd.Flags().Bool("nowordwrap", false, "Don't wrap words to the next line automatically")
Jeffrey Morgan's avatar
Jeffrey Morgan committed
1269
	runCmd.Flags().String("format", "", "Response format (e.g. json)")
Jeffrey Morgan's avatar
Jeffrey Morgan committed
1270
1271
1272
1273
	serveCmd := &cobra.Command{
		Use:     "serve",
		Aliases: []string{"start"},
		Short:   "Start ollama",
Michael Yang's avatar
Michael Yang committed
1274
		Args:    cobra.ExactArgs(0),
Michael Yang's avatar
Michael Yang committed
1275
		RunE:    RunServer,
Jeffrey Morgan's avatar
Jeffrey Morgan committed
1276
1277
	}

1278
	pullCmd := &cobra.Command{
1279
1280
		Use:     "pull MODEL",
		Short:   "Pull a model from a registry",
Michael Yang's avatar
Michael Yang committed
1281
		Args:    cobra.ExactArgs(1),
1282
1283
		PreRunE: checkServerHeartbeat,
		RunE:    PullHandler,
1284
1285
	}

1286
1287
	pullCmd.Flags().Bool("insecure", false, "Use an insecure registry")

1288
	pushCmd := &cobra.Command{
1289
1290
		Use:     "push MODEL",
		Short:   "Push a model to a registry",
Michael Yang's avatar
Michael Yang committed
1291
		Args:    cobra.ExactArgs(1),
1292
1293
		PreRunE: checkServerHeartbeat,
		RunE:    PushHandler,
1294
1295
	}

1296
1297
	pushCmd.Flags().Bool("insecure", false, "Use an insecure registry")

Patrick Devine's avatar
Patrick Devine committed
1298
	listCmd := &cobra.Command{
1299
		Use:     "list",
Patrick Devine's avatar
Patrick Devine committed
1300
		Aliases: []string{"ls"},
1301
		Short:   "List models",
1302
		PreRunE: checkServerHeartbeat,
1303
		RunE:    ListHandler,
1304
	}
1305
1306
1307
1308
1309
1310
1311
1312

	psCmd := &cobra.Command{
		Use:     "ps",
		Short:   "List running models",
		PreRunE: checkServerHeartbeat,
		RunE:    ListRunningHandler,
	}

Patrick Devine's avatar
Patrick Devine committed
1313
	copyCmd := &cobra.Command{
Michael Yang's avatar
Michael Yang committed
1314
		Use:     "cp SOURCE DESTINATION",
1315
		Short:   "Copy a model",
Michael Yang's avatar
Michael Yang committed
1316
		Args:    cobra.ExactArgs(2),
1317
1318
		PreRunE: checkServerHeartbeat,
		RunE:    CopyHandler,
Patrick Devine's avatar
Patrick Devine committed
1319
1320
	}

1321
	deleteCmd := &cobra.Command{
Michael Yang's avatar
Michael Yang committed
1322
		Use:     "rm MODEL [MODEL...]",
1323
1324
1325
1326
		Short:   "Remove a model",
		Args:    cobra.MinimumNArgs(1),
		PreRunE: checkServerHeartbeat,
		RunE:    DeleteHandler,
Patrick Devine's avatar
Patrick Devine committed
1327
1328
	}

1329
1330
1331
	envVars := envconfig.AsMap()

	envs := []envconfig.EnvVar{envVars["OLLAMA_HOST"]}
1332

1333
1334
1335
1336
1337
1338
1339
	for _, cmd := range []*cobra.Command{
		createCmd,
		showCmd,
		runCmd,
		pullCmd,
		pushCmd,
		listCmd,
1340
		psCmd,
1341
1342
		copyCmd,
		deleteCmd,
1343
		serveCmd,
1344
	} {
1345
1346
		switch cmd {
		case runCmd:
1347
1348
1349
1350
1351
1352
1353
1354
1355
1356
1357
1358
1359
			appendEnvDocs(cmd, []envconfig.EnvVar{envVars["OLLAMA_HOST"], envVars["OLLAMA_NOHISTORY"]})
		case serveCmd:
			appendEnvDocs(cmd, []envconfig.EnvVar{
				envVars["OLLAMA_DEBUG"],
				envVars["OLLAMA_HOST"],
				envVars["OLLAMA_KEEP_ALIVE"],
				envVars["OLLAMA_MAX_LOADED_MODELS"],
				envVars["OLLAMA_MAX_QUEUE"],
				envVars["OLLAMA_MODELS"],
				envVars["OLLAMA_NUM_PARALLEL"],
				envVars["OLLAMA_NOPRUNE"],
				envVars["OLLAMA_ORIGINS"],
				envVars["OLLAMA_TMPDIR"],
1360
1361
				envVars["OLLAMA_FLASH_ATTENTION"],
				envVars["OLLAMA_LLM_LIBRARY"],
1362
			})
1363
1364
1365
		default:
			appendEnvDocs(cmd, envs)
		}
1366
1367
	}

Jeffrey Morgan's avatar
Jeffrey Morgan committed
1368
1369
	rootCmd.AddCommand(
		serveCmd,
1370
		createCmd,
Patrick Devine's avatar
Patrick Devine committed
1371
		showCmd,
1372
		runCmd,
1373
1374
		pullCmd,
		pushCmd,
Patrick Devine's avatar
Patrick Devine committed
1375
		listCmd,
1376
		psCmd,
Patrick Devine's avatar
Patrick Devine committed
1377
		copyCmd,
1378
		deleteCmd,
Jeffrey Morgan's avatar
Jeffrey Morgan committed
1379
1380
1381
1382
	)

	return rootCmd
}