images.go 27.4 KB
Newer Older
1
2
3
4
package server

import (
	"bytes"
5
	"context"
6
	"crypto/sha256"
Patrick Devine's avatar
Patrick Devine committed
7
	"encoding/hex"
8
9
10
11
12
13
	"encoding/json"
	"errors"
	"fmt"
	"io"
	"log"
	"net/http"
Michael Yang's avatar
Michael Yang committed
14
	"net/url"
15
16
	"os"
	"path/filepath"
Michael Yang's avatar
Michael Yang committed
17
	"runtime"
18
19
	"strconv"
	"strings"
Quinn Slack's avatar
Quinn Slack committed
20
	"text/template"
21

Michael Yang's avatar
Michael Yang committed
22
23
	"golang.org/x/exp/slices"

24
	"github.com/jmorganca/ollama/api"
25
	"github.com/jmorganca/ollama/llm"
26
	"github.com/jmorganca/ollama/parser"
Michael Yang's avatar
Michael Yang committed
27
	"github.com/jmorganca/ollama/version"
28
29
)

30
31
32
33
type RegistryOptions struct {
	Insecure bool
	Username string
	Password string
Patrick Devine's avatar
Patrick Devine committed
34
	Token    string
35
36
}

37
type Model struct {
Patrick Devine's avatar
Patrick Devine committed
38
39
40
41
42
43
44
45
46
47
	Name          string `json:"name"`
	ShortName     string
	ModelPath     string
	OriginalModel string
	AdapterPaths  []string
	Template      string
	System        string
	License       []string
	Digest        string
	Options       map[string]interface{}
48
49
}

50
func (m *Model) Prompt(request api.GenerateRequest) (string, error) {
51
52
53
54
55
56
	t := m.Template
	if request.Template != "" {
		t = request.Template
	}

	tmpl, err := template.New("").Parse(t)
57
58
59
60
61
	if err != nil {
		return "", err
	}

	var vars struct {
Michael Yang's avatar
Michael Yang committed
62
		First  bool
63
64
65
66
		System string
		Prompt string
	}

Michael Yang's avatar
Michael Yang committed
67
	vars.First = len(request.Context) == 0
68
	vars.System = m.System
69
70
	vars.Prompt = request.Prompt

71
72
73
74
	if request.System != "" {
		vars.System = request.System
	}

75
76
77
78
79
80
81
82
	var sb strings.Builder
	if err := tmpl.Execute(&sb, vars); err != nil {
		return "", err
	}

	return sb.String(), nil
}

83
84
85
86
87
88
89
90
91
92
type ManifestV2 struct {
	SchemaVersion int      `json:"schemaVersion"`
	MediaType     string   `json:"mediaType"`
	Config        Layer    `json:"config"`
	Layers        []*Layer `json:"layers"`
}

type Layer struct {
	MediaType string `json:"mediaType"`
	Digest    string `json:"digest"`
Michael Yang's avatar
Michael Yang committed
93
	Size      int64  `json:"size"`
Michael Yang's avatar
Michael Yang committed
94
	From      string `json:"from,omitempty"`
95
96
}

Michael Yang's avatar
Michael Yang committed
97
type LayerReader struct {
98
	Layer
Michael Yang's avatar
Michael Yang committed
99
	io.Reader
100
101
102
}

type ConfigV2 struct {
Michael Yang's avatar
Michael Yang committed
103
104
105
106
107
	ModelFormat string `json:"model_format"`
	ModelFamily string `json:"model_family"`
	ModelType   string `json:"model_type"`
	FileType    string `json:"file_type"`
	RootFS      RootFS `json:"rootfs"`
108
109

	// required by spec
110
111
112
113
114
115
116
117
118
	Architecture string `json:"architecture"`
	OS           string `json:"os"`
}

type RootFS struct {
	Type    string   `json:"type"`
	DiffIDs []string `json:"diff_ids"`
}

Michael Yang's avatar
Michael Yang committed
119
func (m *ManifestV2) GetTotalSize() (total int64) {
Patrick Devine's avatar
Patrick Devine committed
120
121
122
	for _, layer := range m.Layers {
		total += layer.Size
	}
Michael Yang's avatar
Michael Yang committed
123

Patrick Devine's avatar
Patrick Devine committed
124
125
126
127
	total += m.Config.Size
	return total
}

Patrick Devine's avatar
Patrick Devine committed
128
func GetManifest(mp ModelPath) (*ManifestV2, string, error) {
129
	fp, err := mp.GetManifestPath()
130
	if err != nil {
Patrick Devine's avatar
Patrick Devine committed
131
		return nil, "", err
132
	}
133

134
	if _, err = os.Stat(fp); err != nil {
Patrick Devine's avatar
Patrick Devine committed
135
		return nil, "", err
136
137
138
139
	}

	var manifest *ManifestV2

140
	bts, err := os.ReadFile(fp)
141
	if err != nil {
Patrick Devine's avatar
Patrick Devine committed
142
		return nil, "", fmt.Errorf("couldn't open file '%s'", fp)
143
144
	}

Patrick Devine's avatar
Patrick Devine committed
145
146
147
	shaSum := sha256.Sum256(bts)
	shaStr := hex.EncodeToString(shaSum[:])

148
	if err := json.Unmarshal(bts, &manifest); err != nil {
Patrick Devine's avatar
Patrick Devine committed
149
		return nil, "", err
150
151
	}

Patrick Devine's avatar
Patrick Devine committed
152
	return manifest, shaStr, nil
153
154
155
}

func GetModel(name string) (*Model, error) {
156
	mp := ParseModelPath(name)
Patrick Devine's avatar
Patrick Devine committed
157
	manifest, digest, err := GetManifest(mp)
158
159
160
161
162
	if err != nil {
		return nil, err
	}

	model := &Model{
163
164
165
166
167
		Name:      mp.GetFullTagname(),
		ShortName: mp.GetShortTagname(),
		Digest:    digest,
		Template:  "{{ .Prompt }}",
		License:   []string{},
168
169
170
	}

	for _, layer := range manifest.Layers {
Patrick Devine's avatar
Patrick Devine committed
171
		filename, err := GetBlobsPath(layer.Digest)
172
173
174
175
		if err != nil {
			return nil, err
		}

176
177
178
		switch layer.MediaType {
		case "application/vnd.ollama.image.model":
			model.ModelPath = filename
Patrick Devine's avatar
Patrick Devine committed
179
			model.OriginalModel = layer.From
180
		case "application/vnd.ollama.image.embed":
181
182
183
			// Deprecated in versions  > 0.1.2
			// TODO: remove this warning in a future version
			log.Print("WARNING: model contains embeddings, but embeddings in modelfiles have been deprecated and will be ignored.")
184
185
		case "application/vnd.ollama.image.adapter":
			model.AdapterPaths = append(model.AdapterPaths, filename)
186
187
188
189
190
191
192
193
194
		case "application/vnd.ollama.image.template":
			bts, err := os.ReadFile(filename)
			if err != nil {
				return nil, err
			}

			model.Template = string(bts)
		case "application/vnd.ollama.image.system":
			bts, err := os.ReadFile(filename)
195
196
197
			if err != nil {
				return nil, err
			}
198
199

			model.System = string(bts)
200
201
202
203
204
205
206
		case "application/vnd.ollama.image.prompt":
			bts, err := os.ReadFile(filename)
			if err != nil {
				return nil, err
			}

			model.Template = string(bts)
207
		case "application/vnd.ollama.image.params":
Michael Yang's avatar
Michael Yang committed
208
209
210
211
212
			params, err := os.Open(filename)
			if err != nil {
				return nil, err
			}
			defer params.Close()
213

214
			// parse model options parameters into a map so that we can see which fields have been specified explicitly
215
			if err = json.NewDecoder(params).Decode(&model.Options); err != nil {
216
217
				return nil, err
			}
Patrick Devine's avatar
Patrick Devine committed
218
219
220
221
222
223
		case "application/vnd.ollama.image.license":
			bts, err := os.ReadFile(filename)
			if err != nil {
				return nil, err
			}
			model.License = append(model.License, string(bts))
224
225
226
227
228
229
		}
	}

	return model, nil
}

230
231
func realpath(mfDir, from string) string {
	abspath, err := filepath.Abs(from)
Michael Yang's avatar
Michael Yang committed
232
	if err != nil {
233
		return from
234
235
	}

Michael Yang's avatar
Michael Yang committed
236
	home, err := os.UserHomeDir()
237
	if err != nil {
Michael Yang's avatar
Michael Yang committed
238
		return abspath
239
240
	}

241
	if from == "~" {
Michael Yang's avatar
Michael Yang committed
242
		return home
243
244
245
246
247
248
249
	} else if strings.HasPrefix(from, "~/") {
		return filepath.Join(home, from[2:])
	}

	if _, err := os.Stat(filepath.Join(mfDir, from)); err == nil {
		// this is a file relative to the Modelfile
		return filepath.Join(mfDir, from)
250
251
	}

Michael Yang's avatar
Michael Yang committed
252
253
254
	return abspath
}

255
func CreateModel(ctx context.Context, name, modelFileDir string, commands []parser.Command, fn func(resp api.ProgressResponse)) error {
256
257
	config := ConfigV2{
		OS:           "linux",
Michael Yang's avatar
Michael Yang committed
258
		Architecture: "amd64",
259
260
	}

Michael Yang's avatar
Michael Yang committed
261
262
	deleteMap := make(map[string]struct{})

Michael Yang's avatar
Michael Yang committed
263
	var layers []*LayerReader
Michael Yang's avatar
Michael Yang committed
264

265
	params := make(map[string][]string)
Michael Yang's avatar
Michael Yang committed
266
267
	fromParams := make(map[string]any)

268
	for _, c := range commands {
Michael Yang's avatar
Michael Yang committed
269
270
271
		log.Printf("[%s] - %s", c.Name, c.Args)
		mediatype := fmt.Sprintf("application/vnd.ollama.image.%s", c.Name)

272
273
		switch c.Name {
		case "model":
Michael Yang's avatar
Michael Yang committed
274
275
276
277
278
279
280
281
282
			if strings.HasPrefix(c.Args, "@") {
				blobPath, err := GetBlobsPath(strings.TrimPrefix(c.Args, "@"))
				if err != nil {
					return err
				}

				c.Args = blobPath
			}

283
			bin, err := os.Open(realpath(modelFileDir, c.Args))
284
			if err != nil {
Michael Yang's avatar
Michael Yang committed
285
286
287
288
289
290
291
				// not a file on disk so must be a model reference
				modelpath := ParseModelPath(c.Args)
				manifest, _, err := GetManifest(modelpath)
				switch {
				case errors.Is(err, os.ErrNotExist):
					fn(api.ProgressResponse{Status: "pulling model"})
					if err := PullModel(ctx, c.Args, &RegistryOptions{}, fn); err != nil {
292
293
294
						return err
					}

Michael Yang's avatar
Michael Yang committed
295
					manifest, _, err = GetManifest(modelpath)
296
297
298
					if err != nil {
						return err
					}
Michael Yang's avatar
Michael Yang committed
299
300
				case err != nil:
					return err
301
				}
302

303
				fn(api.ProgressResponse{Status: "reading model metadata"})
Michael Yang's avatar
Michael Yang committed
304
				fromConfigPath, err := GetBlobsPath(manifest.Config.Digest)
Michael Yang's avatar
Michael Yang committed
305
306
307
308
				if err != nil {
					return err
				}

Michael Yang's avatar
Michael Yang committed
309
				fromConfigFile, err := os.Open(fromConfigPath)
Michael Yang's avatar
Michael Yang committed
310
311
312
				if err != nil {
					return err
				}
Michael Yang's avatar
Michael Yang committed
313
				defer fromConfigFile.Close()
Michael Yang's avatar
Michael Yang committed
314

Michael Yang's avatar
Michael Yang committed
315
316
				var fromConfig ConfigV2
				if err := json.NewDecoder(fromConfigFile).Decode(&fromConfig); err != nil {
Michael Yang's avatar
Michael Yang committed
317
318
319
					return err
				}

Michael Yang's avatar
Michael Yang committed
320
321
322
323
				config.ModelFormat = fromConfig.ModelFormat
				config.ModelFamily = fromConfig.ModelFamily
				config.ModelType = fromConfig.ModelType
				config.FileType = fromConfig.FileType
Michael Yang's avatar
Michael Yang committed
324

Michael Yang's avatar
Michael Yang committed
325
326
327
328
				for _, layer := range manifest.Layers {
					deleteMap[layer.Digest] = struct{}{}
					if layer.MediaType == "application/vnd.ollama.image.params" {
						fromParamsPath, err := GetBlobsPath(layer.Digest)
Michael Yang's avatar
Michael Yang committed
329
330
331
332
						if err != nil {
							return err
						}

Michael Yang's avatar
Michael Yang committed
333
						fromParamsFile, err := os.Open(fromParamsPath)
Michael Yang's avatar
Michael Yang committed
334
335
336
						if err != nil {
							return err
						}
Michael Yang's avatar
Michael Yang committed
337
						defer fromParamsFile.Close()
Michael Yang's avatar
Michael Yang committed
338

Michael Yang's avatar
Michael Yang committed
339
						if err := json.NewDecoder(fromParamsFile).Decode(&fromParams); err != nil {
Michael Yang's avatar
Michael Yang committed
340
341
342
343
							return err
						}
					}

Michael Yang's avatar
Michael Yang committed
344
					layer, err := GetLayerWithBufferFromLayer(layer)
345
346
347
					if err != nil {
						return err
					}
Michael Yang's avatar
Michael Yang committed
348
349
350

					layer.From = modelpath.GetShortTagname()
					layers = append(layers, layer)
351
				}
Michael Yang's avatar
Michael Yang committed
352
353
354

				deleteMap[manifest.Config.Digest] = struct{}{}
				continue
355
			}
Michael Yang's avatar
Michael Yang committed
356
			defer bin.Close()
357

Michael Yang's avatar
Michael Yang committed
358
359
			fn(api.ProgressResponse{Status: "creating model layer"})
			ggml, err := llm.DecodeGGML(bin)
Michael Yang's avatar
Michael Yang committed
360
361
			if err != nil {
				return err
362
363
			}

Michael Yang's avatar
Michael Yang committed
364
365
366
367
368
369
370
371
372
373
			config.ModelFormat = ggml.Name()
			config.ModelFamily = ggml.ModelFamily()
			config.ModelType = ggml.ModelType()
			config.FileType = ggml.FileType()

			bin.Seek(0, io.SeekStart)
			layer, err := CreateLayer(bin)
			if err != nil {
				return err
			}
374

Michael Yang's avatar
Michael Yang committed
375
376
377
			layer.MediaType = mediatype
			layers = append(layers, layer)
		case "adapter":
378
379
380
381
382
383
384
385
386
			if strings.HasPrefix(c.Args, "@") {
				blobPath, err := GetBlobsPath(strings.TrimPrefix(c.Args, "@"))
				if err != nil {
					return err
				}

				c.Args = blobPath
			}
			
Michael Yang's avatar
Michael Yang committed
387
			fn(api.ProgressResponse{Status: "creating adapter layer"})
388
			bin, err := os.Open(realpath(modelFileDir, c.Args))
389
			if err != nil {
Michael Yang's avatar
Michael Yang committed
390
				return err
391
			}
Michael Yang's avatar
Michael Yang committed
392
			defer bin.Close()
393

Michael Yang's avatar
Michael Yang committed
394
			layer, err := CreateLayer(bin)
395
			if err != nil {
Michael Yang's avatar
Michael Yang committed
396
				return err
397
			}
Bruce MacDonald's avatar
Bruce MacDonald committed
398

Michael Yang's avatar
Michael Yang committed
399
400
401
402
403
404
			if layer.Size > 0 {
				layer.MediaType = mediatype
				layers = append(layers, layer)
			}
		case "license":
			fn(api.ProgressResponse{Status: "creating license layer"})
Bruce MacDonald's avatar
Bruce MacDonald committed
405
406
407
408
409
			layer, err := CreateLayer(strings.NewReader(c.Args))
			if err != nil {
				return err
			}

410
			if layer.Size > 0 {
Michael Yang's avatar
Michael Yang committed
411
				layer.MediaType = mediatype
412
413
				layers = append(layers, layer)
			}
Michael Yang's avatar
Michael Yang committed
414
415
416
		case "template", "system":
			fn(api.ProgressResponse{Status: fmt.Sprintf("creating %s layer", c.Name)})

Michael Yang's avatar
Michael Yang committed
417
			// remove duplicate layers
Michael Yang's avatar
Michael Yang committed
418
			layers = removeLayerFromLayers(layers, mediatype)
419

420
			layer, err := CreateLayer(strings.NewReader(c.Args))
421
			if err != nil {
422
				return err
423
			}
424

425
			if layer.Size > 0 {
Michael Yang's avatar
Michael Yang committed
426
				layer.MediaType = mediatype
427
428
				layers = append(layers, layer)
			}
429
		default:
430
			params[c.Name] = append(params[c.Name], c.Args)
431
432
433
		}
	}

Michael Yang's avatar
Michael Yang committed
434
	if len(params) > 0 {
Michael Yang's avatar
Michael Yang committed
435
		fn(api.ProgressResponse{Status: "creating parameters layer"})
Michael Yang's avatar
Michael Yang committed
436

437
		formattedParams, err := api.FormatParams(params)
438
		if err != nil {
Michael Yang's avatar
Michael Yang committed
439
			return err
440
		}
441

Michael Yang's avatar
Michael Yang committed
442
		for k, v := range fromParams {
Michael Yang's avatar
Michael Yang committed
443
444
445
446
447
			if _, ok := formattedParams[k]; !ok {
				formattedParams[k] = v
			}
		}

Michael Yang's avatar
Michael Yang committed
448
		if config.ModelType == "65B" {
Michael Yang's avatar
Michael Yang committed
449
			if gqa, ok := formattedParams["gqa"].(int); ok && gqa == 8 {
Michael Yang's avatar
Michael Yang committed
450
451
452
453
				config.ModelType = "70B"
			}
		}

Michael Yang's avatar
Michael Yang committed
454
455
		var b bytes.Buffer
		if err := json.NewEncoder(&b).Encode(formattedParams); err != nil {
456
457
458
			return err
		}

Michael Yang's avatar
Michael Yang committed
459
460
		fn(api.ProgressResponse{Status: "creating config layer"})
		layer, err := CreateLayer(bytes.NewReader(b.Bytes()))
461
		if err != nil {
Michael Yang's avatar
Michael Yang committed
462
			return err
463
		}
Michael Yang's avatar
Michael Yang committed
464
465
466

		layer.MediaType = "application/vnd.ollama.image.params"
		layers = append(layers, layer)
467
468
	}

469
470
471
472
473
	digests, err := getLayerDigests(layers)
	if err != nil {
		return err
	}

Michael Yang's avatar
Michael Yang committed
474
	configLayer, err := createConfigLayer(config, digests)
475
476
477
	if err != nil {
		return err
	}
Michael Yang's avatar
Michael Yang committed
478
479
480

	layers = append(layers, configLayer)
	delete(deleteMap, configLayer.Digest)
481

Michael Yang's avatar
Michael Yang committed
482
	if err := SaveLayers(layers, fn, false); err != nil {
483
484
485
		return err
	}

Michael Yang's avatar
Michael Yang committed
486
487
488
489
490
491
	var contentLayers []*Layer
	for _, layer := range layers {
		contentLayers = append(contentLayers, &layer.Layer)
		delete(deleteMap, layer.Digest)
	}

492
	fn(api.ProgressResponse{Status: "writing manifest"})
Michael Yang's avatar
Michael Yang committed
493
	if err := CreateManifest(name, configLayer, contentLayers); err != nil {
494
495
496
		return err
	}

Michael Yang's avatar
Michael Yang committed
497
498
	if noprune := os.Getenv("OLLAMA_NOPRUNE"); noprune == "" {
		if err := deleteUnusedLayers(nil, deleteMap, false); err != nil {
499
500
501
502
			return err
		}
	}

503
	fn(api.ProgressResponse{Status: "success"})
504
505
506
	return nil
}

Michael Yang's avatar
Michael Yang committed
507
func removeLayerFromLayers(layers []*LayerReader, mediaType string) []*LayerReader {
Michael Yang's avatar
Michael Yang committed
508
509
510
	return slices.DeleteFunc(layers, func(layer *LayerReader) bool {
		return layer.MediaType == mediaType
	})
511
512
}

513
func SaveLayers(layers []*LayerReader, fn func(resp api.ProgressResponse), force bool) error {
514
515
	// Write each of the layers to disk
	for _, layer := range layers {
Patrick Devine's avatar
Patrick Devine committed
516
		fp, err := GetBlobsPath(layer.Digest)
517
518
519
		if err != nil {
			return err
		}
520
521

		_, err = os.Stat(fp)
522
		if os.IsNotExist(err) || force {
523
524
			fn(api.ProgressResponse{Status: fmt.Sprintf("writing layer %s", layer.Digest)})

525
526
527
528
529
530
531
			out, err := os.Create(fp)
			if err != nil {
				log.Printf("couldn't create %s", fp)
				return err
			}
			defer out.Close()

Michael Yang's avatar
Michael Yang committed
532
			if _, err = io.Copy(out, layer.Reader); err != nil {
533
534
				return err
			}
Michael Yang's avatar
Michael Yang committed
535

536
		} else {
537
			fn(api.ProgressResponse{Status: fmt.Sprintf("using already created layer %s", layer.Digest)})
538
539
540
541
542
543
		}
	}

	return nil
}

Michael Yang's avatar
Michael Yang committed
544
func CreateManifest(name string, cfg *LayerReader, layers []*Layer) error {
545
	mp := ParseModelPath(name)
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
	manifest := ManifestV2{
		SchemaVersion: 2,
		MediaType:     "application/vnd.docker.distribution.manifest.v2+json",
		Config: Layer{
			MediaType: cfg.MediaType,
			Size:      cfg.Size,
			Digest:    cfg.Digest,
		},
		Layers: layers,
	}

	manifestJSON, err := json.Marshal(manifest)
	if err != nil {
		return err
	}

562
	fp, err := mp.GetManifestPath()
563
564
565
	if err != nil {
		return err
	}
566
567
568
	if err := os.MkdirAll(filepath.Dir(fp), 0o755); err != nil {
		return err
	}
569
	return os.WriteFile(fp, manifestJSON, 0o644)
570
571
}

Michael Yang's avatar
Michael Yang committed
572
func GetLayerWithBufferFromLayer(layer *Layer) (*LayerReader, error) {
Patrick Devine's avatar
Patrick Devine committed
573
	fp, err := GetBlobsPath(layer.Digest)
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
	if err != nil {
		return nil, err
	}

	file, err := os.Open(fp)
	if err != nil {
		return nil, fmt.Errorf("could not open blob: %w", err)
	}
	defer file.Close()

	newLayer, err := CreateLayer(file)
	if err != nil {
		return nil, err
	}
	newLayer.MediaType = layer.MediaType
	return newLayer, nil
}

Michael Yang's avatar
Michael Yang committed
592
func getLayerDigests(layers []*LayerReader) ([]string, error) {
593
594
595
596
597
598
599
600
601
602
603
	var digests []string
	for _, l := range layers {
		if l.Digest == "" {
			return nil, fmt.Errorf("layer is missing a digest")
		}
		digests = append(digests, l.Digest)
	}
	return digests, nil
}

// CreateLayer creates a Layer object from a given file
Michael Yang's avatar
Michael Yang committed
604
605
func CreateLayer(f io.ReadSeeker) (*LayerReader, error) {
	digest, size := GetSHA256Digest(f)
606
	f.Seek(0, io.SeekStart)
607

Michael Yang's avatar
Michael Yang committed
608
	layer := &LayerReader{
609
610
611
612
613
		Layer: Layer{
			MediaType: "application/vnd.docker.image.rootfs.diff.tar",
			Digest:    digest,
			Size:      size,
		},
Michael Yang's avatar
Michael Yang committed
614
		Reader: f,
615
616
617
618
619
	}

	return layer, nil
}

Patrick Devine's avatar
Patrick Devine committed
620
func CopyModel(src, dest string) error {
621
	srcModelPath := ParseModelPath(src)
622
	srcPath, err := srcModelPath.GetManifestPath()
623
624
625
626
	if err != nil {
		return err
	}

627
	destModelPath := ParseModelPath(dest)
628
	destPath, err := destModelPath.GetManifestPath()
Patrick Devine's avatar
Patrick Devine committed
629
630
631
	if err != nil {
		return err
	}
632
633
634
	if err := os.MkdirAll(filepath.Dir(destPath), 0o755); err != nil {
		return err
	}
Patrick Devine's avatar
Patrick Devine committed
635
636

	// copy the file
Michael Yang's avatar
Michael Yang committed
637
	input, err := os.ReadFile(srcPath)
Patrick Devine's avatar
Patrick Devine committed
638
639
640
641
642
	if err != nil {
		fmt.Println("Error reading file:", err)
		return err
	}

Michael Yang's avatar
Michael Yang committed
643
	err = os.WriteFile(destPath, input, 0o644)
Patrick Devine's avatar
Patrick Devine committed
644
645
646
647
648
649
650
651
	if err != nil {
		fmt.Println("Error reading file:", err)
		return err
	}

	return nil
}

Michael Yang's avatar
Michael Yang committed
652
func deleteUnusedLayers(skipModelPath *ModelPath, deleteMap map[string]struct{}, dryRun bool) error {
653
654
655
656
	fp, err := GetManifestPath()
	if err != nil {
		return err
	}
Michael Yang's avatar
Michael Yang committed
657
658
659
660

	walkFunc := func(path string, info os.FileInfo, _ error) error {
		if info.IsDir() {
			return nil
661
662
		}

Michael Yang's avatar
Michael Yang committed
663
664
665
666
		dir, file := filepath.Split(path)
		dir = strings.Trim(strings.TrimPrefix(dir, fp), string(os.PathSeparator))
		tag := strings.Join([]string{dir, file}, ":")
		fmp := ParseModelPath(tag)
667

Michael Yang's avatar
Michael Yang committed
668
		// skip the manifest we're trying to delete
669
		if skipModelPath != nil && skipModelPath.GetFullTagname() == fmp.GetFullTagname() {
Michael Yang's avatar
Michael Yang committed
670
			return nil
671
		}
Michael Yang's avatar
Michael Yang committed
672
673
674
675
676
677
678
679
680
681
682
683

		// save (i.e. delete from the deleteMap) any files used in other manifests
		manifest, _, err := GetManifest(fmp)
		if err != nil {
			return nil
		}

		for _, layer := range manifest.Layers {
			delete(deleteMap, layer.Digest)
		}

		delete(deleteMap, manifest.Config.Digest)
684
		return nil
Michael Yang's avatar
Michael Yang committed
685
686
687
	}

	if err := filepath.Walk(fp, walkFunc); err != nil {
Michael Yang's avatar
Michael Yang committed
688
689
		return err
	}
690
691

	// only delete the files which are still in the deleteMap
Michael Yang's avatar
Michael Yang committed
692
693
694
695
696
697
698
699
700
	for k := range deleteMap {
		fp, err := GetBlobsPath(k)
		if err != nil {
			log.Printf("couldn't get file path for '%s': %v", k, err)
			continue
		}
		if !dryRun {
			if err := os.Remove(fp); err != nil {
				log.Printf("couldn't remove file '%s': %v", fp, err)
701
702
				continue
			}
Michael Yang's avatar
Michael Yang committed
703
704
		} else {
			log.Printf("wanted to remove: %s", fp)
705
706
707
		}
	}

708
709
710
711
	return nil
}

func PruneLayers() error {
Michael Yang's avatar
Michael Yang committed
712
	deleteMap := make(map[string]struct{})
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
	p, err := GetBlobsPath("")
	if err != nil {
		return err
	}

	blobs, err := os.ReadDir(p)
	if err != nil {
		log.Printf("couldn't read dir '%s': %v", p, err)
		return err
	}

	for _, blob := range blobs {
		name := blob.Name()
		if runtime.GOOS == "windows" {
			name = strings.ReplaceAll(name, "-", ":")
		}
Michael Yang's avatar
Michael Yang committed
729
730
731
		if strings.HasPrefix(name, "sha256:") {
			deleteMap[name] = struct{}{}
		}
732
733
734
735
736
737
738
739
740
741
742
743
744
745
	}

	log.Printf("total blobs: %d", len(deleteMap))

	err = deleteUnusedLayers(nil, deleteMap, false)
	if err != nil {
		return err
	}

	log.Printf("total unused blobs removed: %d", len(deleteMap))

	return nil
}

Michael Yang's avatar
Michael Yang committed
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
func PruneDirectory(path string) error {
	info, err := os.Lstat(path)
	if err != nil {
		return err
	}

	if info.IsDir() && info.Mode()&os.ModeSymlink == 0 {
		entries, err := os.ReadDir(path)
		if err != nil {
			return err
		}

		for _, entry := range entries {
			if err := PruneDirectory(filepath.Join(path, entry.Name())); err != nil {
				return err
			}
		}

		entries, err = os.ReadDir(path)
		if err != nil {
			return err
		}

		if len(entries) > 0 {
			return nil
		}

		return os.Remove(path)
	}

	return nil
}

779
780
781
782
783
784
785
func DeleteModel(name string) error {
	mp := ParseModelPath(name)
	manifest, _, err := GetManifest(mp)
	if err != nil {
		return err
	}

Michael Yang's avatar
Michael Yang committed
786
	deleteMap := make(map[string]struct{})
787
	for _, layer := range manifest.Layers {
Michael Yang's avatar
Michael Yang committed
788
		deleteMap[layer.Digest] = struct{}{}
789
	}
Michael Yang's avatar
Michael Yang committed
790
	deleteMap[manifest.Config.Digest] = struct{}{}
791
792
793
794
795
796

	err = deleteUnusedLayers(&mp, deleteMap, false)
	if err != nil {
		return err
	}

797
	fp, err := mp.GetManifestPath()
798
799
800
801
802
803
804
805
806
807
808
809
	if err != nil {
		return err
	}
	err = os.Remove(fp)
	if err != nil {
		log.Printf("couldn't remove manifest file '%s': %v", fp, err)
		return err
	}

	return nil
}

Patrick Devine's avatar
Patrick Devine committed
810
func ShowModelfile(model *Model) (string, error) {
Michael Yang's avatar
Michael Yang committed
811
	var mt struct {
Patrick Devine's avatar
Patrick Devine committed
812
		*Model
Michael Yang's avatar
Michael Yang committed
813
		From       string
Michael Yang's avatar
Michael Yang committed
814
		Parameters map[string][]any
Patrick Devine's avatar
Patrick Devine committed
815
816
	}

Michael Yang's avatar
Michael Yang committed
817
	mt.Parameters = make(map[string][]any)
Patrick Devine's avatar
Patrick Devine committed
818
	for k, v := range model.Options {
Michael Yang's avatar
Michael Yang committed
819
820
821
		if s, ok := v.([]any); ok {
			mt.Parameters[k] = s
			continue
Patrick Devine's avatar
Patrick Devine committed
822
823
		}

Michael Yang's avatar
Michael Yang committed
824
		mt.Parameters[k] = []any{v}
Patrick Devine's avatar
Patrick Devine committed
825
826
	}

Michael Yang's avatar
Michael Yang committed
827
828
	mt.Model = model
	mt.From = model.ModelPath
Patrick Devine's avatar
Patrick Devine committed
829

Michael Yang's avatar
Michael Yang committed
830
	if model.OriginalModel != "" {
Daniel Reis's avatar
Daniel Reis committed
831
		mt.From = model.OriginalModel
Patrick Devine's avatar
Patrick Devine committed
832
833
834
835
836
837
838
839
	}

	modelFile := `# Modelfile generated by "ollama show"
# To build a new Modelfile based on this one, replace the FROM line with:
# FROM {{ .ShortName }}

FROM {{ .From }}
TEMPLATE """{{ .Template }}"""
840
841

{{- if .System }}
Patrick Devine's avatar
Patrick Devine committed
842
SYSTEM """{{ .System }}"""
843
{{- end }}
844
845
846
847

{{- range $adapter := .AdapterPaths }}
ADAPTER {{ $adapter }}
{{- end }}
Michael Yang's avatar
Michael Yang committed
848

Michael Yang's avatar
Michael Yang committed
849
850
851
852
{{- range $k, $v := .Parameters }}
{{- range $parameter := $v }}
PARAMETER {{ $k }} {{ printf "%#v" $parameter }}
{{- end }}
Michael Yang's avatar
Michael Yang committed
853
{{- end }}`
Patrick Devine's avatar
Patrick Devine committed
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870

	tmpl, err := template.New("").Parse(modelFile)
	if err != nil {
		log.Printf("error parsing template: %q", err)
		return "", err
	}

	var buf bytes.Buffer

	if err = tmpl.Execute(&buf, mt); err != nil {
		log.Printf("error executing template: %q", err)
		return "", err
	}

	return buf.String(), nil
}

871
func PushModel(ctx context.Context, name string, regOpts *RegistryOptions, fn func(api.ProgressResponse)) error {
872
	mp := ParseModelPath(name)
873
874
	fn(api.ProgressResponse{Status: "retrieving manifest"})

875
876
877
878
	if mp.ProtocolScheme == "http" && !regOpts.Insecure {
		return fmt.Errorf("insecure protocol http")
	}

Patrick Devine's avatar
Patrick Devine committed
879
	manifest, _, err := GetManifest(mp)
880
	if err != nil {
881
		fn(api.ProgressResponse{Status: "couldn't retrieve manifest"})
882
883
884
885
		return err
	}

	var layers []*Layer
Jeffrey Morgan's avatar
Jeffrey Morgan committed
886
	layers = append(layers, manifest.Layers...)
887
888
889
	layers = append(layers, &manifest.Config)

	for _, layer := range layers {
Michael Yang's avatar
Michael Yang committed
890
		if err := uploadBlob(ctx, mp, layer, regOpts, fn); err != nil {
891
			log.Printf("error uploading blob: %v", err)
892
893
894
			if errors.Is(err, errUnauthorized) {
				return fmt.Errorf("unable to push %s, make sure this namespace exists and you are authorized to push to it", ParseModelPath(name).GetNamespaceRepository())
			}
895
896
			return err
		}
897
898
	}

899
	fn(api.ProgressResponse{Status: "pushing manifest"})
Michael Yang's avatar
Michael Yang committed
900
901
	requestURL := mp.BaseURL()
	requestURL = requestURL.JoinPath("v2", mp.GetNamespaceRepository(), "manifests", mp.Tag)
902
903
904
905
906
907

	manifestJSON, err := json.Marshal(manifest)
	if err != nil {
		return err
	}

Michael Yang's avatar
Michael Yang committed
908
909
	headers := make(http.Header)
	headers.Set("Content-Type", "application/vnd.docker.distribution.manifest.v2+json")
Michael Yang's avatar
Michael Yang committed
910
	resp, err := makeRequestWithRetry(ctx, http.MethodPut, requestURL, headers, bytes.NewReader(manifestJSON), regOpts)
911
912
913
914
915
	if err != nil {
		return err
	}
	defer resp.Body.Close()

916
	fn(api.ProgressResponse{Status: "success"})
917
918
919
920

	return nil
}

921
func PullModel(ctx context.Context, name string, regOpts *RegistryOptions, fn func(api.ProgressResponse)) error {
922
923
	mp := ParseModelPath(name)

924
925
926
927
928
	var manifest *ManifestV2
	var err error
	var noprune string

	// build deleteMap to prune unused layers
Michael Yang's avatar
Michael Yang committed
929
	deleteMap := make(map[string]struct{})
930
931
932
933
934
935
936
937
938

	if noprune = os.Getenv("OLLAMA_NOPRUNE"); noprune == "" {
		manifest, _, err = GetManifest(mp)
		if err != nil && !errors.Is(err, os.ErrNotExist) {
			return err
		}

		if manifest != nil {
			for _, l := range manifest.Layers {
Michael Yang's avatar
Michael Yang committed
939
				deleteMap[l.Digest] = struct{}{}
940
			}
Michael Yang's avatar
Michael Yang committed
941
			deleteMap[manifest.Config.Digest] = struct{}{}
942
943
944
		}
	}

945
946
	if mp.ProtocolScheme == "http" && !regOpts.Insecure {
		return fmt.Errorf("insecure protocol http")
947
	}
948

949
	fn(api.ProgressResponse{Status: "pulling manifest"})
950

951
	manifest, err = pullModelManifest(ctx, mp, regOpts)
952
	if err != nil {
953
		return fmt.Errorf("pull model manifest: %s", err)
954
955
956
	}

	var layers []*Layer
Bruce MacDonald's avatar
Bruce MacDonald committed
957
	layers = append(layers, manifest.Layers...)
958
959
960
	layers = append(layers, &manifest.Config)

	for _, layer := range layers {
961
962
963
964
965
966
967
968
		if err := downloadBlob(
			ctx,
			downloadOpts{
				mp:      mp,
				digest:  layer.Digest,
				regOpts: regOpts,
				fn:      fn,
			}); err != nil {
969
970
			return err
		}
971
		delete(deleteMap, layer.Digest)
972
	}
973
	delete(deleteMap, manifest.Config.Digest)
974

Michael Yang's avatar
Michael Yang committed
975
976
977
	fn(api.ProgressResponse{Status: "verifying sha256 digest"})
	for _, layer := range layers {
		if err := verifyBlob(layer.Digest); err != nil {
978
979
980
981
982
983
984
985
986
987
988
			if errors.Is(err, errDigestMismatch) {
				// something went wrong, delete the blob
				fp, err := GetBlobsPath(layer.Digest)
				if err != nil {
					return err
				}
				if err := os.Remove(fp); err != nil {
					// log this, but return the original error
					log.Printf("couldn't remove file with digest mismatch '%s': %v", fp, err)
				}
			}
Michael Yang's avatar
Michael Yang committed
989
990
991
992
			return err
		}
	}

993
	fn(api.ProgressResponse{Status: "writing manifest"})
994

995
	manifestJSON, err := json.Marshal(manifest)
996
997
998
999
	if err != nil {
		return err
	}

1000
	fp, err := mp.GetManifestPath()
1001
1002
1003
	if err != nil {
		return err
	}
1004
1005
1006
	if err := os.MkdirAll(filepath.Dir(fp), 0o755); err != nil {
		return err
	}
1007

Bruce MacDonald's avatar
Bruce MacDonald committed
1008
	err = os.WriteFile(fp, manifestJSON, 0o644)
1009
1010
1011
1012
1013
	if err != nil {
		log.Printf("couldn't write to %s", fp)
		return err
	}

1014
1015
1016
1017
1018
1019
1020
1021
	if noprune == "" {
		fn(api.ProgressResponse{Status: "removing any unused layers"})
		err = deleteUnusedLayers(nil, deleteMap, false)
		if err != nil {
			return err
		}
	}

1022
	fn(api.ProgressResponse{Status: "success"})
1023
1024
1025
1026

	return nil
}

1027
func pullModelManifest(ctx context.Context, mp ModelPath, regOpts *RegistryOptions) (*ManifestV2, error) {
Michael Yang's avatar
Michael Yang committed
1028
	requestURL := mp.BaseURL().JoinPath("v2", mp.GetNamespaceRepository(), "manifests", mp.Tag)
1029

Michael Yang's avatar
Michael Yang committed
1030
1031
	headers := make(http.Header)
	headers.Set("Accept", "application/vnd.docker.distribution.manifest.v2+json")
Michael Yang's avatar
Michael Yang committed
1032
	resp, err := makeRequestWithRetry(ctx, http.MethodGet, requestURL, headers, nil, regOpts)
1033
1034
1035
1036
1037
1038
1039
1040
1041
1042
1043
1044
1045
	if err != nil {
		return nil, err
	}
	defer resp.Body.Close()

	var m *ManifestV2
	if err := json.NewDecoder(resp.Body).Decode(&m); err != nil {
		return nil, err
	}

	return m, err
}

1046
1047
1048
1049
func createConfigLayer(config ConfigV2, layers []string) (*LayerReader, error) {
	config.RootFS = RootFS{
		Type:    "layers",
		DiffIDs: layers,
1050
1051
1052
1053
1054
1055
1056
	}

	configJSON, err := json.Marshal(config)
	if err != nil {
		return nil, err
	}

1057
	digest, size := GetSHA256Digest(bytes.NewBuffer(configJSON))
1058

Michael Yang's avatar
Michael Yang committed
1059
	layer := &LayerReader{
1060
1061
1062
1063
1064
		Layer: Layer{
			MediaType: "application/vnd.docker.container.image.v1+json",
			Digest:    digest,
			Size:      size,
		},
1065
		Reader: bytes.NewBuffer(configJSON),
1066
1067
1068
1069
1070
	}
	return layer, nil
}

// GetSHA256Digest returns the SHA256 hash of a given buffer and returns it, and the size of buffer
Michael Yang's avatar
Michael Yang committed
1071
func GetSHA256Digest(r io.Reader) (string, int64) {
Michael Yang's avatar
Michael Yang committed
1072
1073
1074
1075
1076
1077
	h := sha256.New()
	n, err := io.Copy(h, r)
	if err != nil {
		log.Fatal(err)
	}

Michael Yang's avatar
Michael Yang committed
1078
	return fmt.Sprintf("sha256:%x", h.Sum(nil)), n
1079
1080
}

1081
1082
var errUnauthorized = fmt.Errorf("unauthorized")

Michael Yang's avatar
Michael Yang committed
1083
func makeRequestWithRetry(ctx context.Context, method string, requestURL *url.URL, headers http.Header, body io.ReadSeeker, regOpts *RegistryOptions) (*http.Response, error) {
1084
1085
1086
1087
1088
	resp, err := makeRequest(ctx, method, requestURL, headers, body, regOpts)
	if err != nil {
		if !errors.Is(err, context.Canceled) {
			log.Printf("request failed: %v", err)
		}
1089

1090
1091
1092
1093
1094
1095
1096
1097
1098
		return nil, err
	}

	switch {
	case resp.StatusCode == http.StatusUnauthorized:
		// Handle authentication error with one retry
		auth := resp.Header.Get("www-authenticate")
		authRedir := ParseAuthRedirectString(auth)
		token, err := getAuthToken(ctx, authRedir)
Michael Yang's avatar
Michael Yang committed
1099
1100
1101
		if err != nil {
			return nil, err
		}
1102
1103
1104
		regOpts.Token = token
		if body != nil {
			_, err = body.Seek(0, io.SeekStart)
Michael Yang's avatar
Michael Yang committed
1105
1106
1107
1108
			if err != nil {
				return nil, err
			}
		}
1109
1110
1111
1112
1113
1114
1115

		resp, err := makeRequest(ctx, method, requestURL, headers, body, regOpts)
		if resp.StatusCode == http.StatusUnauthorized {
			return nil, errUnauthorized
		}

		return resp, err
1116
1117
1118
1119
1120
1121
1122
1123
	case resp.StatusCode == http.StatusNotFound:
		return nil, os.ErrNotExist
	case resp.StatusCode >= http.StatusBadRequest:
		responseBody, err := io.ReadAll(resp.Body)
		if err != nil {
			return nil, fmt.Errorf("%d: %s", resp.StatusCode, err)
		}
		return nil, fmt.Errorf("%d: %s", resp.StatusCode, responseBody)
Michael Yang's avatar
Michael Yang committed
1124
1125
	}

1126
	return resp, nil
Michael Yang's avatar
Michael Yang committed
1127
1128
}

Michael Yang's avatar
Michael Yang committed
1129
func makeRequest(ctx context.Context, method string, requestURL *url.URL, headers http.Header, body io.Reader, regOpts *RegistryOptions) (*http.Response, error) {
Michael Yang's avatar
Michael Yang committed
1130
	if requestURL.Scheme != "http" && regOpts != nil && regOpts.Insecure {
Michael Yang's avatar
Michael Yang committed
1131
		requestURL.Scheme = "http"
1132
1133
	}

Michael Yang's avatar
Michael Yang committed
1134
	req, err := http.NewRequestWithContext(ctx, method, requestURL.String(), body)
1135
1136
1137
1138
	if err != nil {
		return nil, err
	}

Michael Yang's avatar
Michael Yang committed
1139
1140
1141
1142
	if headers != nil {
		req.Header = headers
	}

Michael Yang's avatar
Michael Yang committed
1143
1144
1145
1146
1147
1148
	if regOpts != nil {
		if regOpts.Token != "" {
			req.Header.Set("Authorization", "Bearer "+regOpts.Token)
		} else if regOpts.Username != "" && regOpts.Password != "" {
			req.SetBasicAuth(regOpts.Username, regOpts.Password)
		}
1149
1150
	}

Michael Yang's avatar
Michael Yang committed
1151
	req.Header.Set("User-Agent", fmt.Sprintf("ollama/%s (%s %s) Go/%s", version.Version, runtime.GOARCH, runtime.GOOS, runtime.Version()))
1152

Michael Yang's avatar
Michael Yang committed
1153
1154
1155
1156
1157
1158
1159
1160
1161
	if s := req.Header.Get("Content-Length"); s != "" {
		contentLength, err := strconv.ParseInt(s, 10, 64)
		if err != nil {
			return nil, err
		}

		req.ContentLength = contentLength
	}

Michael Yang's avatar
Michael Yang committed
1162
1163
1164
1165
1166
1167
1168
1169
1170
1171
1172
1173
	proxyURL, err := http.ProxyFromEnvironment(req)
	if err != nil {
		return nil, err
	}

	client := http.Client{
		Transport: &http.Transport{
			Proxy: http.ProxyURL(proxyURL),
		},
	}

	resp, err := client.Do(req)
1174
1175
1176
1177
1178
1179
	if err != nil {
		return nil, err
	}

	return resp, nil
}
Michael Yang's avatar
Michael Yang committed
1180

Patrick Devine's avatar
Patrick Devine committed
1181
1182
1183
1184
1185
1186
1187
1188
1189
1190
1191
1192
1193
1194
1195
1196
1197
1198
1199
1200
1201
1202
1203
1204
1205
1206
1207
1208
1209
1210
1211
1212
1213
func getValue(header, key string) string {
	startIdx := strings.Index(header, key+"=")
	if startIdx == -1 {
		return ""
	}

	// Move the index to the starting quote after the key.
	startIdx += len(key) + 2
	endIdx := startIdx

	for endIdx < len(header) {
		if header[endIdx] == '"' {
			if endIdx+1 < len(header) && header[endIdx+1] != ',' { // If the next character isn't a comma, continue
				endIdx++
				continue
			}
			break
		}
		endIdx++
	}
	return header[startIdx:endIdx]
}

func ParseAuthRedirectString(authStr string) AuthRedirect {
	authStr = strings.TrimPrefix(authStr, "Bearer ")

	return AuthRedirect{
		Realm:   getValue(authStr, "realm"),
		Service: getValue(authStr, "service"),
		Scope:   getValue(authStr, "scope"),
	}
}

1214
1215
var errDigestMismatch = fmt.Errorf("digest mismatch, file must be downloaded again")

Michael Yang's avatar
Michael Yang committed
1216
1217
1218
1219
1220
1221
1222
1223
1224
1225
1226
1227
1228
1229
func verifyBlob(digest string) error {
	fp, err := GetBlobsPath(digest)
	if err != nil {
		return err
	}

	f, err := os.Open(fp)
	if err != nil {
		return err
	}
	defer f.Close()

	fileDigest, _ := GetSHA256Digest(f)
	if digest != fileDigest {
1230
		return fmt.Errorf("%w: want %s, got %s", errDigestMismatch, digest, fileDigest)
Michael Yang's avatar
Michael Yang committed
1231
1232
1233
1234
	}

	return nil
}