cmd.go 31.3 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
367
368
369
370
	opts.MultiModal = slices.Contains(info.Details.Families, "clip")
	opts.ParentModel = info.Details.ParentModel
	opts.Messages = append(opts.Messages, info.Messages...)

	if interactive {
		return generateInteractive(cmd, opts)
	}
	return generate(cmd, opts)
Bruce MacDonald's avatar
Bruce MacDonald committed
371
372
}

373
374
375
376
377
378
379
380
381
382
383
384
385
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
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
}

414
func PushHandler(cmd *cobra.Command, args []string) error {
Michael Yang's avatar
Michael Yang committed
415
	client, err := api.ClientFromEnvironment()
416
417
418
	if err != nil {
		return err
	}
419

420
421
422
423
424
	insecure, err := cmd.Flags().GetBool("insecure")
	if err != nil {
		return err
	}

Michael Yang's avatar
Michael Yang committed
425
426
427
428
	p := progress.NewProgress(os.Stderr)
	defer p.Stop()

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

432
	fn := func(resp api.ProgressResponse) error {
Michael Yang's avatar
Michael Yang committed
433
		if resp.Digest != "" {
434
435
436
			if spinner != nil {
				spinner.Stop()
			}
Michael Yang's avatar
Michael Yang committed
437
438
439

			bar, ok := bars[resp.Digest]
			if !ok {
440
				bar = progress.NewBar(fmt.Sprintf("pushing %s...", resp.Digest[7:19]), resp.Total, resp.Completed)
Michael Yang's avatar
Michael Yang committed
441
442
443
444
445
446
				bars[resp.Digest] = bar
				p.Add(resp.Digest, bar)
			}

			bar.Set(resp.Completed)
		} else if status != resp.Status {
447
448
449
			if spinner != nil {
				spinner.Stop()
			}
Michael Yang's avatar
Michael Yang committed
450
451
452
453
454
455

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

456
457
458
		return nil
	}

Michael Yang's avatar
Michael Yang committed
459
	request := api.PushRequest{Name: args[0], Insecure: insecure}
Michael Yang's avatar
Michael Yang committed
460
	if err := client.Push(cmd.Context(), &request, fn); err != nil {
461
462
463
464
465
466
467
468
469
470
471
472
473
474
		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
475
476
477
		return err
	}

478
	spinner.Stop()
Michael Yang's avatar
Michael Yang committed
479
	return nil
480
481
}

482
func ListHandler(cmd *cobra.Command, args []string) error {
Michael Yang's avatar
Michael Yang committed
483
	client, err := api.ClientFromEnvironment()
484
485
486
	if err != nil {
		return err
	}
Patrick Devine's avatar
Patrick Devine committed
487

Michael Yang's avatar
Michael Yang committed
488
	models, err := client.List(cmd.Context())
Patrick Devine's avatar
Patrick Devine committed
489
490
491
492
493
494
495
	if err != nil {
		return err
	}

	var data [][]string

	for _, m := range models.Models {
Michael Yang's avatar
Michael Yang committed
496
		if len(args) == 0 || strings.HasPrefix(m.Name, args[0]) {
497
			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
498
		}
Patrick Devine's avatar
Patrick Devine committed
499
500
501
	}

	table := tablewriter.NewWriter(os.Stdout)
Patrick Devine's avatar
Patrick Devine committed
502
	table.SetHeader([]string{"NAME", "ID", "SIZE", "MODIFIED"})
Patrick Devine's avatar
Patrick Devine committed
503
504
505
506
507
508
509
510
511
512
513
514
	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
}

515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
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
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
}

561
func DeleteHandler(cmd *cobra.Command, args []string) error {
Michael Yang's avatar
Michael Yang committed
562
	client, err := api.ClientFromEnvironment()
563
564
565
	if err != nil {
		return err
	}
566

567
568
	for _, name := range args {
		req := api.DeleteRequest{Name: name}
Michael Yang's avatar
Michael Yang committed
569
		if err := client.Delete(cmd.Context(), &req); err != nil {
570
571
572
			return err
		}
		fmt.Printf("deleted '%s'\n", name)
573
574
575
576
	}
	return nil
}

Patrick Devine's avatar
Patrick Devine committed
577
func ShowHandler(cmd *cobra.Command, args []string) error {
Michael Yang's avatar
Michael Yang committed
578
	client, err := api.ClientFromEnvironment()
Patrick Devine's avatar
Patrick Devine committed
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
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
	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 {
624
		return errors.New("only one of '--license', '--modelfile', '--parameters', '--system', or '--template' can be specified")
625
626
	}

627
628
629
630
631
	req := api.ShowRequest{Name: args[0]}
	resp, err := client.Show(cmd.Context(), &req)
	if err != nil {
		return err
	}
632

633
	if flagsSet == 1 {
634
635
636
637
638
639
640
641
642
643
644
645
646
647
		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
648
649
	}

650
	showInfo(resp)
Patrick Devine's avatar
Patrick Devine committed
651

652
653
654
655
	return nil
}

func showInfo(resp *api.ShowResponse) {
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
	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)))},
		}

677
678
679
680
681
682
683
684
685
		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))},
		)

686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
		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
711
712
	}

713
	table.Render()
Patrick Devine's avatar
Patrick Devine committed
714
715
}

716
717
718
719
720
721
722
723
724
725
726
727
728
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
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
768
func CopyHandler(cmd *cobra.Command, args []string) error {
Michael Yang's avatar
Michael Yang committed
769
	client, err := api.ClientFromEnvironment()
770
771
772
	if err != nil {
		return err
	}
Patrick Devine's avatar
Patrick Devine committed
773
774

	req := api.CopyRequest{Source: args[0], Destination: args[1]}
Michael Yang's avatar
Michael Yang committed
775
	if err := client.Copy(cmd.Context(), &req); err != nil {
Patrick Devine's avatar
Patrick Devine committed
776
777
778
779
780
781
		return err
	}
	fmt.Printf("copied '%s' to '%s'\n", args[0], args[1])
	return nil
}

782
func PullHandler(cmd *cobra.Command, args []string) error {
783
784
785
786
787
	insecure, err := cmd.Flags().GetBool("insecure")
	if err != nil {
		return err
	}

Michael Yang's avatar
Michael Yang committed
788
	client, err := api.ClientFromEnvironment()
789
790
791
	if err != nil {
		return err
	}
792

Michael Yang's avatar
Michael Yang committed
793
794
795
796
797
	p := progress.NewProgress(os.Stderr)
	defer p.Stop()

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

798
799
	var status string
	var spinner *progress.Spinner
Michael Yang's avatar
Michael Yang committed
800

801
	fn := func(resp api.ProgressResponse) error {
Michael Yang's avatar
Michael Yang committed
802
		if resp.Digest != "" {
803
804
805
			if spinner != nil {
				spinner.Stop()
			}
Michael Yang's avatar
Michael Yang committed
806
807
808

			bar, ok := bars[resp.Digest]
			if !ok {
809
				bar = progress.NewBar(fmt.Sprintf("pulling %s...", resp.Digest[7:19]), resp.Total, resp.Completed)
Michael Yang's avatar
Michael Yang committed
810
811
812
813
814
815
				bars[resp.Digest] = bar
				p.Add(resp.Digest, bar)
			}

			bar.Set(resp.Completed)
		} else if status != resp.Status {
816
817
818
			if spinner != nil {
				spinner.Stop()
			}
Michael Yang's avatar
Michael Yang committed
819
820
821
822
823
824

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

825
826
		return nil
	}
827

Michael Yang's avatar
Michael Yang committed
828
	request := api.PullRequest{Name: args[0], Insecure: insecure}
Michael Yang's avatar
Michael Yang committed
829
	if err := client.Pull(cmd.Context(), &request, fn); err != nil {
Michael Yang's avatar
Michael Yang committed
830
831
832
833
		return err
	}

	return nil
Michael Yang's avatar
Michael Yang committed
834
835
}

836
837
type generateContextKey string

838
type runOptions struct {
839
840
841
842
843
844
845
846
847
848
	Model       string
	ParentModel string
	Prompt      string
	Messages    []api.Message
	WordWrap    bool
	Format      string
	System      string
	Images      []api.ImageData
	Options     map[string]interface{}
	MultiModal  bool
849
	KeepAlive   *api.Duration
850
851
}

852
853
854
855
856
857
858
859
860
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
861
862
			if state.lineLength+1 > termWidth-5 {
				if runewidth.StringWidth(state.wordBuffer) > termWidth-10 {
863
864
865
866
867
868
869
					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
870
871
				a := runewidth.StringWidth(state.wordBuffer)
				if a > 0 {
872
					fmt.Printf("\x1b[%dD", a)
873
874
				}
				fmt.Printf("\x1b[K\n")
875
				fmt.Printf("%s%c", state.wordBuffer, ch)
876
877
878
				chWidth := runewidth.RuneWidth(ch)

				state.lineLength = runewidth.StringWidth(state.wordBuffer) + chWidth
879
880
			} else {
				fmt.Print(string(ch))
881
882
883
884
				state.lineLength += runewidth.RuneWidth(ch)
				if runewidth.RuneWidth(ch) >= 2 {
					state.wordBuffer = ""
					continue
Josh Yan's avatar
Josh Yan committed
885
				}
886
887
888
889
890
891
892
893
894
895
896
897
898
899
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

				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,
	}

954
955
956
957
	if opts.KeepAlive != nil {
		req.KeepAlive = opts.KeepAlive
	}

958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
	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
983
	client, err := api.ClientFromEnvironment()
Patrick Devine's avatar
Patrick Devine committed
984
	if err != nil {
985
		return err
Patrick Devine's avatar
Patrick Devine committed
986
	}
Michael Yang's avatar
Michael Yang committed
987

Michael Yang's avatar
Michael Yang committed
988
	p := progress.NewProgress(os.Stderr)
989
	defer p.StopAndClear()
990

Michael Yang's avatar
Michael Yang committed
991
992
993
	spinner := progress.NewSpinner("")
	p.Add("", spinner)

994
995
996
997
998
999
1000
	var latest api.GenerateResponse

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

Michael Yang's avatar
Michael Yang committed
1001
	ctx, cancel := context.WithCancel(cmd.Context())
1002
1003
1004
1005
1006
1007
1008
1009
1010
1011
	defer cancel()

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

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

1012
	var state *displayResponseState = &displayResponseState{}
1013

1014
	fn := func(response api.GenerateResponse) error {
Michael Yang's avatar
Michael Yang committed
1015
		p.StopAndClear()
1016

Patrick Devine's avatar
Patrick Devine committed
1017
		latest = response
1018
		content := response.Response
1019

1020
		displayResponse(content, opts.WordWrap, state)
1021

Patrick Devine's avatar
Patrick Devine committed
1022
1023
		return nil
	}
1024

1025
1026
1027
1028
1029
1030
1031
	if opts.MultiModal {
		opts.Prompt, opts.Images, err = extractFileData(opts.Prompt)
		if err != nil {
			return err
		}
	}

Michael Yang's avatar
Michael Yang committed
1032
	request := api.GenerateRequest{
1033
1034
1035
1036
1037
1038
1039
1040
		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
1041
1042
1043
	}

	if err := client.Generate(ctx, &request, fn); err != nil {
1044
		if errors.Is(err, context.Canceled) {
1045
			return nil
1046
		}
1047
		return err
Patrick Devine's avatar
Patrick Devine committed
1048
	}
1049

1050
	if opts.Prompt != "" {
Michael Yang's avatar
Michael Yang committed
1051
1052
		fmt.Println()
		fmt.Println()
Patrick Devine's avatar
Patrick Devine committed
1053
	}
1054

1055
1056
1057
1058
	if !latest.Done {
		return nil
	}

Patrick Devine's avatar
Patrick Devine committed
1059
1060
	verbose, err := cmd.Flags().GetBool("verbose")
	if err != nil {
1061
		return err
Patrick Devine's avatar
Patrick Devine committed
1062
	}
Michael Yang's avatar
Michael Yang committed
1063

Patrick Devine's avatar
Patrick Devine committed
1064
1065
	if verbose {
		latest.Summary()
Michael Yang's avatar
Michael Yang committed
1066
	}
Michael Yang's avatar
Michael Yang committed
1067

Patrick Devine's avatar
Patrick Devine committed
1068
1069
1070
	ctx = context.WithValue(cmd.Context(), generateContextKey("context"), latest.Context)
	cmd.SetContext(ctx)

1071
	return nil
Michael Yang's avatar
Michael Yang committed
1072
1073
}

1074
func RunServer(cmd *cobra.Command, _ []string) error {
Michael Yang's avatar
Michael Yang committed
1075
	if err := initializeKeypair(); err != nil {
1076
1077
1078
		return err
	}

1079
	ln, err := net.Listen("tcp", net.JoinHostPort(envconfig.Host.Host, envconfig.Host.Port))
1080
1081
1082
	if err != nil {
		return err
	}
Jeffrey Morgan's avatar
Jeffrey Morgan committed
1083

1084
1085
1086
1087
1088
1089
	err = server.Serve(ln)
	if errors.Is(err, http.ErrServerClosed) {
		return nil
	}

	return err
Jeffrey Morgan's avatar
Jeffrey Morgan committed
1090
1091
}

1092
1093
1094
1095
1096
1097
1098
1099
1100
1101
1102
1103
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
1104
		cryptoPublicKey, cryptoPrivateKey, err := ed25519.GenerateKey(rand.Reader)
1105
1106
1107
1108
		if err != nil {
			return err
		}

Michael Yang's avatar
Michael Yang committed
1109
		privateKeyBytes, err := ssh.MarshalPrivateKey(cryptoPrivateKey, "")
1110
1111
1112
1113
		if err != nil {
			return err
		}

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

Michael Yang's avatar
Michael Yang committed
1118
		if err := os.WriteFile(privKeyPath, pem.EncodeToMemory(privateKeyBytes), 0o600); err != nil {
1119
1120
1121
			return err
		}

Michael Yang's avatar
Michael Yang committed
1122
		sshPublicKey, err := ssh.NewPublicKey(cryptoPublicKey)
1123
1124
1125
1126
		if err != nil {
			return err
		}

Michael Yang's avatar
Michael Yang committed
1127
		publicKeyBytes := ssh.MarshalAuthorizedKey(sshPublicKey)
1128

Michael Yang's avatar
Michael Yang committed
1129
		if err := os.WriteFile(pubKeyPath, publicKeyBytes, 0o644); err != nil {
1130
1131
1132
			return err
		}

Michael Yang's avatar
Michael Yang committed
1133
		fmt.Printf("Your new public key is: \n\n%s\n", publicKeyBytes)
1134
1135
1136
1137
	}
	return nil
}

Michael Yang's avatar
Michael Yang committed
1138
func checkServerHeartbeat(cmd *cobra.Command, _ []string) error {
Michael Yang's avatar
Michael Yang committed
1139
	client, err := api.ClientFromEnvironment()
1140
1141
1142
	if err != nil {
		return err
	}
Michael Yang's avatar
Michael Yang committed
1143
	if err := client.Heartbeat(cmd.Context()); err != nil {
1144
		if !strings.Contains(err.Error(), " refused") {
Bruce MacDonald's avatar
Bruce MacDonald committed
1145
1146
			return err
		}
1147
1148
		if err := startApp(cmd.Context(), client); err != nil {
			return fmt.Errorf("could not connect to ollama app, is it running?")
1149
1150
1151
1152
1153
		}
	}
	return nil
}

Michael Yang's avatar
Michael Yang committed
1154
1155
1156
1157
1158
1159
1160
1161
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
1162
1163
1164
1165
1166
		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
1167
1168
	}

1169
	if serverVersion != version.Version {
Michael Yang's avatar
Michael Yang committed
1170
		fmt.Printf("Warning: client version is %s\n", version.Version)
1171
	}
Michael Yang's avatar
Michael Yang committed
1172
1173
}

1174
func appendEnvDocs(cmd *cobra.Command, envs []envconfig.EnvVar) {
1175
1176
1177
1178
1179
	if len(envs) == 0 {
		return
	}

	envUsage := `
1180
1181
Environment Variables:
`
1182
	for _, e := range envs {
1183
		envUsage += fmt.Sprintf("      %-24s   %s\n", e.Name, e.Description)
1184
1185
1186
	}

	cmd.SetUsageTemplate(cmd.UsageTemplate() + envUsage)
1187
1188
}

Jeffrey Morgan's avatar
Jeffrey Morgan committed
1189
1190
func NewCLI() *cobra.Command {
	log.SetFlags(log.LstdFlags | log.Lshortfile)
Michael Yang's avatar
Michael Yang committed
1191
	cobra.EnableCommandSorting = false
Jeffrey Morgan's avatar
Jeffrey Morgan committed
1192

1193
	if runtime.GOOS == "windows" {
1194
		console.ConsoleFromFile(os.Stdin) //nolint:errcheck
1195
1196
	}

Jeffrey Morgan's avatar
Jeffrey Morgan committed
1197
	rootCmd := &cobra.Command{
1198
1199
1200
1201
		Use:           "ollama",
		Short:         "Large language model runner",
		SilenceUsage:  true,
		SilenceErrors: true,
Jeffrey Morgan's avatar
Jeffrey Morgan committed
1202
1203
1204
		CompletionOptions: cobra.CompletionOptions{
			DisableDefaultCmd: true,
		},
Michael Yang's avatar
Michael Yang committed
1205
1206
1207
1208
1209
1210
1211
1212
		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
1213
1214
	}

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

1217
	createCmd := &cobra.Command{
1218
1219
		Use:     "create MODEL",
		Short:   "Create a model from a Modelfile",
Michael Yang's avatar
Michael Yang committed
1220
		Args:    cobra.ExactArgs(1),
1221
1222
		PreRunE: checkServerHeartbeat,
		RunE:    CreateHandler,
1223
1224
	}

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

Patrick Devine's avatar
Patrick Devine committed
1228
1229
1230
	showCmd := &cobra.Command{
		Use:     "show MODEL",
		Short:   "Show information for a model",
Michael Yang's avatar
Michael Yang committed
1231
		Args:    cobra.ExactArgs(1),
Patrick Devine's avatar
Patrick Devine committed
1232
1233
1234
1235
1236
1237
1238
1239
		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")
1240
	showCmd.Flags().Bool("system", false, "Show system message of a model")
Patrick Devine's avatar
Patrick Devine committed
1241

Jeffrey Morgan's avatar
Jeffrey Morgan committed
1242
	runCmd := &cobra.Command{
1243
1244
1245
1246
1247
		Use:     "run MODEL [PROMPT]",
		Short:   "Run a model",
		Args:    cobra.MinimumNArgs(1),
		PreRunE: checkServerHeartbeat,
		RunE:    RunHandler,
Jeffrey Morgan's avatar
Jeffrey Morgan committed
1248
1249
	}

1250
	runCmd.Flags().String("keepalive", "", "Duration to keep a model loaded (e.g. 5m)")
1251
	runCmd.Flags().Bool("verbose", false, "Show timings for response")
1252
	runCmd.Flags().Bool("insecure", false, "Use an insecure registry")
1253
	runCmd.Flags().Bool("nowordwrap", false, "Don't wrap words to the next line automatically")
Jeffrey Morgan's avatar
Jeffrey Morgan committed
1254
	runCmd.Flags().String("format", "", "Response format (e.g. json)")
Jeffrey Morgan's avatar
Jeffrey Morgan committed
1255
1256
1257
1258
	serveCmd := &cobra.Command{
		Use:     "serve",
		Aliases: []string{"start"},
		Short:   "Start ollama",
Michael Yang's avatar
Michael Yang committed
1259
		Args:    cobra.ExactArgs(0),
Michael Yang's avatar
Michael Yang committed
1260
		RunE:    RunServer,
Jeffrey Morgan's avatar
Jeffrey Morgan committed
1261
1262
	}

1263
	pullCmd := &cobra.Command{
1264
1265
		Use:     "pull MODEL",
		Short:   "Pull a model from a registry",
Michael Yang's avatar
Michael Yang committed
1266
		Args:    cobra.ExactArgs(1),
1267
1268
		PreRunE: checkServerHeartbeat,
		RunE:    PullHandler,
1269
1270
	}

1271
1272
	pullCmd.Flags().Bool("insecure", false, "Use an insecure registry")

1273
	pushCmd := &cobra.Command{
1274
1275
		Use:     "push MODEL",
		Short:   "Push a model to a registry",
Michael Yang's avatar
Michael Yang committed
1276
		Args:    cobra.ExactArgs(1),
1277
1278
		PreRunE: checkServerHeartbeat,
		RunE:    PushHandler,
1279
1280
	}

1281
1282
	pushCmd.Flags().Bool("insecure", false, "Use an insecure registry")

Patrick Devine's avatar
Patrick Devine committed
1283
	listCmd := &cobra.Command{
1284
		Use:     "list",
Patrick Devine's avatar
Patrick Devine committed
1285
		Aliases: []string{"ls"},
1286
		Short:   "List models",
1287
		PreRunE: checkServerHeartbeat,
1288
		RunE:    ListHandler,
1289
	}
1290
1291
1292
1293
1294
1295
1296
1297

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

Patrick Devine's avatar
Patrick Devine committed
1298
	copyCmd := &cobra.Command{
Michael Yang's avatar
Michael Yang committed
1299
		Use:     "cp SOURCE DESTINATION",
1300
		Short:   "Copy a model",
Michael Yang's avatar
Michael Yang committed
1301
		Args:    cobra.ExactArgs(2),
1302
1303
		PreRunE: checkServerHeartbeat,
		RunE:    CopyHandler,
Patrick Devine's avatar
Patrick Devine committed
1304
1305
	}

1306
	deleteCmd := &cobra.Command{
Michael Yang's avatar
Michael Yang committed
1307
		Use:     "rm MODEL [MODEL...]",
1308
1309
1310
1311
		Short:   "Remove a model",
		Args:    cobra.MinimumNArgs(1),
		PreRunE: checkServerHeartbeat,
		RunE:    DeleteHandler,
Patrick Devine's avatar
Patrick Devine committed
1312
1313
	}

1314
1315
1316
	envVars := envconfig.AsMap()

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

1318
1319
1320
1321
1322
1323
1324
	for _, cmd := range []*cobra.Command{
		createCmd,
		showCmd,
		runCmd,
		pullCmd,
		pushCmd,
		listCmd,
1325
		psCmd,
1326
1327
		copyCmd,
		deleteCmd,
1328
		serveCmd,
1329
	} {
1330
1331
		switch cmd {
		case runCmd:
1332
1333
1334
1335
1336
1337
1338
1339
1340
1341
1342
1343
1344
			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"],
1345
1346
				envVars["OLLAMA_FLASH_ATTENTION"],
				envVars["OLLAMA_LLM_LIBRARY"],
1347
			})
1348
1349
1350
		default:
			appendEnvDocs(cmd, envs)
		}
1351
1352
	}

Jeffrey Morgan's avatar
Jeffrey Morgan committed
1353
1354
	rootCmd.AddCommand(
		serveCmd,
1355
		createCmd,
Patrick Devine's avatar
Patrick Devine committed
1356
		showCmd,
1357
		runCmd,
1358
1359
		pullCmd,
		pushCmd,
Patrick Devine's avatar
Patrick Devine committed
1360
		listCmd,
1361
		psCmd,
Patrick Devine's avatar
Patrick Devine committed
1362
		copyCmd,
1363
		deleteCmd,
Jeffrey Morgan's avatar
Jeffrey Morgan committed
1364
1365
1366
1367
	)

	return rootCmd
}