images.go 26.7 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
	"encoding/json"
	"errors"
	"fmt"
	"io"
	"log"
13
	"log/slog"
14
	"net/http"
Michael Yang's avatar
Michael Yang committed
15
	"net/url"
16
17
	"os"
	"path/filepath"
Michael Yang's avatar
Michael Yang committed
18
	"runtime"
Michael Yang's avatar
Michael Yang committed
19
	"strconv"
20
	"strings"
Quinn Slack's avatar
Quinn Slack committed
21
	"text/template"
22

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

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

Michael Yang's avatar
Michael Yang committed
31
32
33
34
35
36
37
type registryOptions struct {
	Insecure bool
	Username string
	Password string
	Token    string
}

38
type Model struct {
Michael Yang's avatar
Michael Yang committed
39
	Name           string `json:"name"`
40
	Config         ConfigV2
Michael Yang's avatar
Michael Yang committed
41
42
	ShortName      string
	ModelPath      string
43
	ParentModel    string
Michael Yang's avatar
Michael Yang committed
44
45
46
47
48
49
	AdapterPaths   []string
	ProjectorPaths []string
	Template       string
	System         string
	License        []string
	Digest         string
Patrick Devine's avatar
Patrick Devine committed
50
	Size           int64
Michael Yang's avatar
Michael Yang committed
51
	Options        map[string]interface{}
52
53
54
55
56
57
	Messages       []Message
}

type Message struct {
	Role    string `json:"role"`
	Content string `json:"content"`
58
59
60
61
62
}

type ManifestV2 struct {
	SchemaVersion int      `json:"schemaVersion"`
	MediaType     string   `json:"mediaType"`
Michael Yang's avatar
Michael Yang committed
63
	Config        *Layer   `json:"config"`
64
65
66
67
	Layers        []*Layer `json:"layers"`
}

type ConfigV2 struct {
68
69
70
71
72
73
	ModelFormat   string   `json:"model_format"`
	ModelFamily   string   `json:"model_family"`
	ModelFamilies []string `json:"model_families"`
	ModelType     string   `json:"model_type"`
	FileType      string   `json:"file_type"`

74
	// required by spec
75
76
	Architecture string `json:"architecture"`
	OS           string `json:"os"`
77
	RootFS       RootFS `json:"rootfs"`
78
79
}

Michael Yang's avatar
Michael Yang committed
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
func (c *ConfigV2) SetModelFormat(format string) {
	if c.ModelFormat == "" {
		c.ModelFormat = format
	}
}

func (c *ConfigV2) SetModelFamily(families ...string) {
	for _, family := range families {
		if c.ModelFamily == "" {
			c.ModelFamily = family
		}

		if !slices.Contains(c.ModelFamilies, family) {
			c.ModelFamilies = append(c.ModelFamilies, family)
		}
	}
}

func (c *ConfigV2) SetModelType(modelType string) {
	if c.ModelType == "" {
		c.ModelType = modelType
	}
}

func (c *ConfigV2) SetFileType(fileType string) {
	if c.FileType == "" {
		c.FileType = fileType
	}
}

110
111
112
113
114
type RootFS struct {
	Type    string   `json:"type"`
	DiffIDs []string `json:"diff_ids"`
}

Michael Yang's avatar
Michael Yang committed
115
func (m *ManifestV2) GetTotalSize() (total int64) {
Patrick Devine's avatar
Patrick Devine committed
116
117
118
	for _, layer := range m.Layers {
		total += layer.Size
	}
Michael Yang's avatar
Michael Yang committed
119

Patrick Devine's avatar
Patrick Devine committed
120
121
122
123
	total += m.Config.Size
	return total
}

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

130
	if _, err = os.Stat(fp); err != nil {
Patrick Devine's avatar
Patrick Devine committed
131
		return nil, "", err
132
133
134
135
	}

	var manifest *ManifestV2

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

Patrick Devine's avatar
Patrick Devine committed
141
142
143
	shaSum := sha256.Sum256(bts)
	shaStr := hex.EncodeToString(shaSum[:])

144
	if err := json.Unmarshal(bts, &manifest); err != nil {
Patrick Devine's avatar
Patrick Devine committed
145
		return nil, "", err
146
147
	}

Patrick Devine's avatar
Patrick Devine committed
148
	return manifest, shaStr, nil
149
150
151
}

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

	model := &Model{
159
160
161
162
163
		Name:      mp.GetFullTagname(),
		ShortName: mp.GetShortTagname(),
		Digest:    digest,
		Template:  "{{ .Prompt }}",
		License:   []string{},
Patrick Devine's avatar
Patrick Devine committed
164
		Size:      manifest.GetTotalSize(),
165
166
	}

167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
	filename, err := GetBlobsPath(manifest.Config.Digest)
	if err != nil {
		return nil, err
	}

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

	if err := json.NewDecoder(configFile).Decode(&model.Config); err != nil {
		return nil, err
	}

182
	for _, layer := range manifest.Layers {
Patrick Devine's avatar
Patrick Devine committed
183
		filename, err := GetBlobsPath(layer.Digest)
184
185
186
187
		if err != nil {
			return nil, err
		}

188
189
190
		switch layer.MediaType {
		case "application/vnd.ollama.image.model":
			model.ModelPath = filename
191
			model.ParentModel = layer.From
192
		case "application/vnd.ollama.image.embed":
193
194
			// Deprecated in versions  > 0.1.2
			// TODO: remove this warning in a future version
195
			slog.Info("WARNING: model contains embeddings, but embeddings in modelfiles have been deprecated and will be ignored.")
196
197
		case "application/vnd.ollama.image.adapter":
			model.AdapterPaths = append(model.AdapterPaths, filename)
Michael Yang's avatar
Michael Yang committed
198
199
		case "application/vnd.ollama.image.projector":
			model.ProjectorPaths = append(model.ProjectorPaths, filename)
200
201
202
203
204
205
206
207
208
		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)
209
210
211
			if err != nil {
				return nil, err
			}
212
213

			model.System = string(bts)
214
215
216
217
218
219
220
		case "application/vnd.ollama.image.prompt":
			bts, err := os.ReadFile(filename)
			if err != nil {
				return nil, err
			}

			model.Template = string(bts)
221
		case "application/vnd.ollama.image.params":
Michael Yang's avatar
Michael Yang committed
222
223
224
225
226
			params, err := os.Open(filename)
			if err != nil {
				return nil, err
			}
			defer params.Close()
227

228
			// parse model options parameters into a map so that we can see which fields have been specified explicitly
229
			if err = json.NewDecoder(params).Decode(&model.Options); err != nil {
230
231
				return nil, err
			}
232
233
234
235
236
237
238
239
240
241
		case "application/vnd.ollama.image.messages":
			msgs, err := os.Open(filename)
			if err != nil {
				return nil, err
			}
			defer msgs.Close()

			if err = json.NewDecoder(msgs).Decode(&model.Messages); err != nil {
				return nil, err
			}
Patrick Devine's avatar
Patrick Devine committed
242
243
244
245
246
247
		case "application/vnd.ollama.image.license":
			bts, err := os.ReadFile(filename)
			if err != nil {
				return nil, err
			}
			model.License = append(model.License, string(bts))
248
249
250
251
252
253
		}
	}

	return model, nil
}

254
255
func realpath(mfDir, from string) string {
	abspath, err := filepath.Abs(from)
Michael Yang's avatar
Michael Yang committed
256
	if err != nil {
257
		return from
258
259
	}

Michael Yang's avatar
Michael Yang committed
260
	home, err := os.UserHomeDir()
261
	if err != nil {
Michael Yang's avatar
Michael Yang committed
262
		return abspath
263
264
	}

265
	if from == "~" {
Michael Yang's avatar
Michael Yang committed
266
		return home
267
268
269
270
271
272
273
	} 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)
274
275
	}

Michael Yang's avatar
Michael Yang committed
276
277
278
	return abspath
}

279
func CreateModel(ctx context.Context, name, modelFileDir string, commands []parser.Command, fn func(resp api.ProgressResponse)) error {
280
281
282
283
284
285
286
	deleteMap := make(map[string]struct{})
	if manifest, _, err := GetManifest(ParseModelPath(name)); err == nil {
		for _, layer := range append(manifest.Layers, manifest.Config) {
			deleteMap[layer.Digest] = struct{}{}
		}
	}

287
288
	config := ConfigV2{
		OS:           "linux",
Michael Yang's avatar
Michael Yang committed
289
		Architecture: "amd64",
Michael Yang's avatar
Michael Yang committed
290
291
292
		RootFS: RootFS{
			Type: "layers",
		},
293
294
	}

Michael Yang's avatar
Michael Yang committed
295
	var layers Layers
296
	messages := []string{}
Michael Yang's avatar
Michael Yang committed
297

298
	params := make(map[string][]string)
Michael Yang's avatar
Michael Yang committed
299
300
	fromParams := make(map[string]any)

301
	for _, c := range commands {
Michael Yang's avatar
Michael Yang committed
302
303
		mediatype := fmt.Sprintf("application/vnd.ollama.image.%s", c.Name)

304
305
		switch c.Name {
		case "model":
Michael Yang's avatar
Michael Yang committed
306
307
308
309
310
311
312
313
314
			if strings.HasPrefix(c.Args, "@") {
				blobPath, err := GetBlobsPath(strings.TrimPrefix(c.Args, "@"))
				if err != nil {
					return err
				}

				c.Args = blobPath
			}

315
			bin, err := os.Open(realpath(modelFileDir, c.Args))
316
			if err != nil {
Michael Yang's avatar
Michael Yang committed
317
318
319
320
321
322
				// 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"})
Michael Yang's avatar
Michael Yang committed
323
					if err := PullModel(ctx, c.Args, &registryOptions{}, fn); err != nil {
324
325
326
						return err
					}

Michael Yang's avatar
Michael Yang committed
327
					manifest, _, err = GetManifest(modelpath)
328
329
330
					if err != nil {
						return err
					}
Michael Yang's avatar
Michael Yang committed
331
332
				case err != nil:
					return err
333
				}
334

335
				fn(api.ProgressResponse{Status: "reading model metadata"})
Michael Yang's avatar
Michael Yang committed
336
				fromConfigPath, err := GetBlobsPath(manifest.Config.Digest)
Michael Yang's avatar
Michael Yang committed
337
338
339
340
				if err != nil {
					return err
				}

Michael Yang's avatar
Michael Yang committed
341
				fromConfigFile, err := os.Open(fromConfigPath)
Michael Yang's avatar
Michael Yang committed
342
343
344
				if err != nil {
					return err
				}
Michael Yang's avatar
Michael Yang committed
345
				defer fromConfigFile.Close()
Michael Yang's avatar
Michael Yang committed
346

Michael Yang's avatar
Michael Yang committed
347
348
				var fromConfig ConfigV2
				if err := json.NewDecoder(fromConfigFile).Decode(&fromConfig); err != nil {
Michael Yang's avatar
Michael Yang committed
349
350
351
					return err
				}

Bruce MacDonald's avatar
Bruce MacDonald committed
352
353
354
355
356
				// if the model is still not in gguf format, error out
				if fromConfig.ModelFormat != "gguf" {
					return fmt.Errorf("%s is not in gguf format, this base model is not compatible with this version of ollama", c.Args)
				}

Michael Yang's avatar
Michael Yang committed
357
358
359
360
				config.SetModelFormat(fromConfig.ModelFormat)
				config.SetModelFamily(append(fromConfig.ModelFamilies, fromConfig.ModelFamily)...)
				config.SetModelType(fromConfig.ModelType)
				config.SetFileType(fromConfig.FileType)
Michael Yang's avatar
Michael Yang committed
361

Michael Yang's avatar
Michael Yang committed
362
363
364
365
				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
366
367
368
369
						if err != nil {
							return err
						}

Michael Yang's avatar
Michael Yang committed
370
						fromParamsFile, err := os.Open(fromParamsPath)
Michael Yang's avatar
Michael Yang committed
371
372
373
						if err != nil {
							return err
						}
Michael Yang's avatar
Michael Yang committed
374
						defer fromParamsFile.Close()
Michael Yang's avatar
Michael Yang committed
375

Michael Yang's avatar
Michael Yang committed
376
						if err := json.NewDecoder(fromParamsFile).Decode(&fromParams); err != nil {
Michael Yang's avatar
Michael Yang committed
377
378
379
380
							return err
						}
					}

Michael Yang's avatar
Michael Yang committed
381
					layer, err := NewLayerFromLayer(layer.Digest, layer.MediaType, modelpath.GetShortTagname())
382
383
384
					if err != nil {
						return err
					}
Michael Yang's avatar
Michael Yang committed
385

Michael Yang's avatar
Michael Yang committed
386
					layers.Add(layer)
387
				}
Michael Yang's avatar
Michael Yang committed
388
389
390

				deleteMap[manifest.Config.Digest] = struct{}{}
				continue
391
			}
Michael Yang's avatar
Michael Yang committed
392
			defer bin.Close()
393

394
			var offset int64
Bruce MacDonald's avatar
Bruce MacDonald committed
395
		CREATE:
396
397
			for {
				fn(api.ProgressResponse{Status: "creating model layer"})
398

399
400
				bin.Seek(offset, io.SeekStart)
				ggml, err := llm.DecodeGGML(bin)
Bruce MacDonald's avatar
Bruce MacDonald committed
401
402
403
404
405
406
407
408
409
				if err != nil {
					switch {
					case errors.Is(err, io.EOF):
						break CREATE
					case errors.Is(err, llm.ErrUnsupportedFormat):
						return fmt.Errorf("model binary specified in FROM field is not a valid gguf format model, %w", err)
					default:
						return err
					}
410
				}
Michael Yang's avatar
Michael Yang committed
411

Michael Yang's avatar
Michael Yang committed
412
413
414
415
				config.SetModelFormat(ggml.Name())
				config.SetModelFamily(ggml.ModelFamily())
				config.SetModelType(ggml.ModelType())
				config.SetFileType(ggml.FileType())
416

417
418
419
420
				mediatype := mediatype
				if ggml.ModelFamily() == "clip" {
					mediatype = "application/vnd.ollama.image.projector"
				}
421

422
423
424
425
426
427
428
429
430
431
				sr := io.NewSectionReader(bin, offset, ggml.Size)
				layer, err := NewLayer(sr, mediatype)
				if err != nil {
					return err
				}

				layers.Add(layer)

				offset += ggml.Size
			}
Michael Yang's avatar
Michael Yang committed
432
		case "adapter":
433
434
435
436
437
438
439
440
			if strings.HasPrefix(c.Args, "@") {
				blobPath, err := GetBlobsPath(strings.TrimPrefix(c.Args, "@"))
				if err != nil {
					return err
				}

				c.Args = blobPath
			}
Bruce MacDonald's avatar
Bruce MacDonald committed
441

Michael Yang's avatar
Michael Yang committed
442
			fn(api.ProgressResponse{Status: "creating adapter layer"})
443
			bin, err := os.Open(realpath(modelFileDir, c.Args))
444
			if err != nil {
Michael Yang's avatar
Michael Yang committed
445
				return err
446
			}
Michael Yang's avatar
Michael Yang committed
447
			defer bin.Close()
448

Michael Yang's avatar
Michael Yang committed
449
			layer, err := NewLayer(bin, mediatype)
450
			if err != nil {
Michael Yang's avatar
Michael Yang committed
451
				return err
452
			}
Bruce MacDonald's avatar
Bruce MacDonald committed
453

Michael Yang's avatar
Michael Yang committed
454
			layers.Add(layer)
Michael Yang's avatar
Michael Yang committed
455
456
		case "license":
			fn(api.ProgressResponse{Status: "creating license layer"})
Michael Yang's avatar
Michael Yang committed
457
458
459

			bin := strings.NewReader(c.Args)
			layer, err := NewLayer(bin, mediatype)
Bruce MacDonald's avatar
Bruce MacDonald committed
460
461
462
463
			if err != nil {
				return err
			}

Michael Yang's avatar
Michael Yang committed
464
			layers.Add(layer)
Michael Yang's avatar
Michael Yang committed
465
466
467
		case "template", "system":
			fn(api.ProgressResponse{Status: fmt.Sprintf("creating %s layer", c.Name)})

Michael Yang's avatar
Michael Yang committed
468
469
			bin := strings.NewReader(c.Args)
			layer, err := NewLayer(bin, mediatype)
470
			if err != nil {
471
				return err
472
			}
473

Michael Yang's avatar
Michael Yang committed
474
			layers.Replace(layer)
475
476
		case "message":
			messages = append(messages, c.Args)
477
		default:
478
			params[c.Name] = append(params[c.Name], c.Args)
479
480
481
		}
	}

482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
	if len(messages) > 0 {
		fn(api.ProgressResponse{Status: "creating parameters layer"})

		msgs := make([]api.Message, 0)

		for _, m := range messages {
			// todo: handle images
			msg := strings.SplitN(m, ": ", 2)
			msgs = append(msgs, api.Message{Role: msg[0], Content: msg[1]})
		}

		var b bytes.Buffer
		if err := json.NewEncoder(&b).Encode(msgs); err != nil {
			return err
		}

		layer, err := NewLayer(&b, "application/vnd.ollama.image.messages")
		if err != nil {
			return err
		}

		layers.Replace(layer)
	}

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

509
		formattedParams, err := api.FormatParams(params)
510
		if err != nil {
Michael Yang's avatar
Michael Yang committed
511
			return err
512
		}
513

Michael Yang's avatar
Michael Yang committed
514
		for k, v := range fromParams {
Michael Yang's avatar
Michael Yang committed
515
516
517
518
519
			if _, ok := formattedParams[k]; !ok {
				formattedParams[k] = v
			}
		}

Patrick Devine's avatar
Patrick Devine committed
520
		// xxx - can this be removed?
Michael Yang's avatar
Michael Yang committed
521
		if config.ModelType == "65B" {
Michael Yang's avatar
Michael Yang committed
522
			if gqa, ok := formattedParams["gqa"].(int); ok && gqa == 8 {
Michael Yang's avatar
Michael Yang committed
523
524
525
526
				config.ModelType = "70B"
			}
		}

Michael Yang's avatar
Michael Yang committed
527
528
		var b bytes.Buffer
		if err := json.NewEncoder(&b).Encode(formattedParams); err != nil {
529
530
531
			return err
		}

Michael Yang's avatar
Michael Yang committed
532
		fn(api.ProgressResponse{Status: "creating config layer"})
Michael Yang's avatar
Michael Yang committed
533
		layer, err := NewLayer(&b, "application/vnd.ollama.image.params")
534
		if err != nil {
Michael Yang's avatar
Michael Yang committed
535
			return err
536
		}
Michael Yang's avatar
Michael Yang committed
537

Michael Yang's avatar
Michael Yang committed
538
		layers.Replace(layer)
539
540
	}

Michael Yang's avatar
Michael Yang committed
541
542
543
	digests := make([]string, len(layers.items))
	for i, layer := range layers.items {
		digests[i] = layer.Digest
544
545
	}

Michael Yang's avatar
Michael Yang committed
546
	config.RootFS.DiffIDs = digests
Michael Yang's avatar
Michael Yang committed
547

Michael Yang's avatar
Michael Yang committed
548
549
	var b bytes.Buffer
	if err := json.NewEncoder(&b).Encode(config); err != nil {
550
551
552
		return err
	}

Michael Yang's avatar
Michael Yang committed
553
554
	configLayer, err := NewLayer(&b, "application/vnd.docker.container.image.v1+json")
	if err != nil {
555
556
557
		return err
	}

Michael Yang's avatar
Michael Yang committed
558
	delete(deleteMap, configLayer.Digest)
559

Michael Yang's avatar
Michael Yang committed
560
561
	for _, layer := range append(layers.items, configLayer) {
		committed, err := layer.Commit()
562
563
564
		if err != nil {
			return err
		}
565

Michael Yang's avatar
Michael Yang committed
566
567
568
		status := "writing layer"
		if !committed {
			status = "using already created layer"
569
570
		}

Michael Yang's avatar
Michael Yang committed
571
		fn(api.ProgressResponse{Status: fmt.Sprintf("%s %s", status, layer.Digest)})
572

Michael Yang's avatar
Michael Yang committed
573
		delete(deleteMap, layer.Digest)
574
575
	}

Michael Yang's avatar
Michael Yang committed
576
577
	fn(api.ProgressResponse{Status: "writing manifest"})
	if err := WriteManifest(name, configLayer, layers.items); err != nil {
578
579
		return err
	}
580

Michael Yang's avatar
Michael Yang committed
581
582
583
	if noprune := os.Getenv("OLLAMA_NOPRUNE"); noprune == "" {
		if err := deleteUnusedLayers(nil, deleteMap, false); err != nil {
			return err
584
585
586
		}
	}

Michael Yang's avatar
Michael Yang committed
587
588
	fn(api.ProgressResponse{Status: "success"})
	return nil
589
590
}

Patrick Devine's avatar
Patrick Devine committed
591
func CopyModel(src, dest string) error {
592
	srcModelPath := ParseModelPath(src)
593
	srcPath, err := srcModelPath.GetManifestPath()
594
595
596
597
	if err != nil {
		return err
	}

598
	destModelPath := ParseModelPath(dest)
599
	destPath, err := destModelPath.GetManifestPath()
Patrick Devine's avatar
Patrick Devine committed
600
601
602
	if err != nil {
		return err
	}
603
604
605
	if err := os.MkdirAll(filepath.Dir(destPath), 0o755); err != nil {
		return err
	}
Patrick Devine's avatar
Patrick Devine committed
606
607

	// copy the file
Michael Yang's avatar
Michael Yang committed
608
	input, err := os.ReadFile(srcPath)
Patrick Devine's avatar
Patrick Devine committed
609
610
611
612
613
	if err != nil {
		fmt.Println("Error reading file:", err)
		return err
	}

Michael Yang's avatar
Michael Yang committed
614
	err = os.WriteFile(destPath, input, 0o644)
Patrick Devine's avatar
Patrick Devine committed
615
616
617
618
619
620
621
622
	if err != nil {
		fmt.Println("Error reading file:", err)
		return err
	}

	return nil
}

Michael Yang's avatar
Michael Yang committed
623
func deleteUnusedLayers(skipModelPath *ModelPath, deleteMap map[string]struct{}, dryRun bool) error {
624
625
626
627
	fp, err := GetManifestPath()
	if err != nil {
		return err
	}
Michael Yang's avatar
Michael Yang committed
628
629
630
631

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

Michael Yang's avatar
Michael Yang committed
634
635
636
637
		dir, file := filepath.Split(path)
		dir = strings.Trim(strings.TrimPrefix(dir, fp), string(os.PathSeparator))
		tag := strings.Join([]string{dir, file}, ":")
		fmp := ParseModelPath(tag)
638

Michael Yang's avatar
Michael Yang committed
639
		// skip the manifest we're trying to delete
640
		if skipModelPath != nil && skipModelPath.GetFullTagname() == fmp.GetFullTagname() {
Michael Yang's avatar
Michael Yang committed
641
			return nil
642
		}
Michael Yang's avatar
Michael Yang committed
643
644
645
646

		// save (i.e. delete from the deleteMap) any files used in other manifests
		manifest, _, err := GetManifest(fmp)
		if err != nil {
Michael Yang's avatar
Michael Yang committed
647
			// nolint: nilerr
Michael Yang's avatar
Michael Yang committed
648
649
650
651
652
653
654
655
			return nil
		}

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

		delete(deleteMap, manifest.Config.Digest)
656
		return nil
Michael Yang's avatar
Michael Yang committed
657
658
659
	}

	if err := filepath.Walk(fp, walkFunc); err != nil {
Michael Yang's avatar
Michael Yang committed
660
661
		return err
	}
662
663

	// only delete the files which are still in the deleteMap
Michael Yang's avatar
Michael Yang committed
664
665
666
	for k := range deleteMap {
		fp, err := GetBlobsPath(k)
		if err != nil {
667
			slog.Info(fmt.Sprintf("couldn't get file path for '%s': %v", k, err))
Michael Yang's avatar
Michael Yang committed
668
669
670
671
			continue
		}
		if !dryRun {
			if err := os.Remove(fp); err != nil {
672
				slog.Info(fmt.Sprintf("couldn't remove file '%s': %v", fp, err))
673
674
				continue
			}
Michael Yang's avatar
Michael Yang committed
675
		} else {
676
			slog.Info(fmt.Sprintf("wanted to remove: %s", fp))
677
678
679
		}
	}

680
681
682
683
	return nil
}

func PruneLayers() error {
Michael Yang's avatar
Michael Yang committed
684
	deleteMap := make(map[string]struct{})
685
686
687
688
689
690
691
	p, err := GetBlobsPath("")
	if err != nil {
		return err
	}

	blobs, err := os.ReadDir(p)
	if err != nil {
692
		slog.Info(fmt.Sprintf("couldn't read dir '%s': %v", p, err))
693
694
695
696
697
698
699
700
		return err
	}

	for _, blob := range blobs {
		name := blob.Name()
		if runtime.GOOS == "windows" {
			name = strings.ReplaceAll(name, "-", ":")
		}
Michael Yang's avatar
Michael Yang committed
701
702
703
		if strings.HasPrefix(name, "sha256:") {
			deleteMap[name] = struct{}{}
		}
704
705
	}

706
	slog.Info(fmt.Sprintf("total blobs: %d", len(deleteMap)))
707
708
709
710
711
712

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

713
	slog.Info(fmt.Sprintf("total unused blobs removed: %d", len(deleteMap)))
714
715
716
717

	return nil
}

Michael Yang's avatar
Michael Yang committed
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
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
}

751
752
753
754
755
756
757
func DeleteModel(name string) error {
	mp := ParseModelPath(name)
	manifest, _, err := GetManifest(mp)
	if err != nil {
		return err
	}

Michael Yang's avatar
Michael Yang committed
758
	deleteMap := make(map[string]struct{})
759
	for _, layer := range manifest.Layers {
Michael Yang's avatar
Michael Yang committed
760
		deleteMap[layer.Digest] = struct{}{}
761
	}
Michael Yang's avatar
Michael Yang committed
762
	deleteMap[manifest.Config.Digest] = struct{}{}
763
764
765
766
767
768

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

769
	fp, err := mp.GetManifestPath()
770
771
772
773
774
	if err != nil {
		return err
	}
	err = os.Remove(fp)
	if err != nil {
775
		slog.Info(fmt.Sprintf("couldn't remove manifest file '%s': %v", fp, err))
776
777
778
779
780
781
		return err
	}

	return nil
}

Patrick Devine's avatar
Patrick Devine committed
782
func ShowModelfile(model *Model) (string, error) {
Michael Yang's avatar
Michael Yang committed
783
	var mt struct {
Patrick Devine's avatar
Patrick Devine committed
784
		*Model
Michael Yang's avatar
Michael Yang committed
785
		From       string
Michael Yang's avatar
Michael Yang committed
786
		Parameters map[string][]any
Patrick Devine's avatar
Patrick Devine committed
787
788
	}

Michael Yang's avatar
Michael Yang committed
789
	mt.Parameters = make(map[string][]any)
Patrick Devine's avatar
Patrick Devine committed
790
	for k, v := range model.Options {
Michael Yang's avatar
Michael Yang committed
791
792
793
		if s, ok := v.([]any); ok {
			mt.Parameters[k] = s
			continue
Patrick Devine's avatar
Patrick Devine committed
794
795
		}

Michael Yang's avatar
Michael Yang committed
796
		mt.Parameters[k] = []any{v}
Patrick Devine's avatar
Patrick Devine committed
797
798
	}

Michael Yang's avatar
Michael Yang committed
799
800
	mt.Model = model
	mt.From = model.ModelPath
Patrick Devine's avatar
Patrick Devine committed
801

802
803
	if model.ParentModel != "" {
		mt.From = model.ParentModel
Patrick Devine's avatar
Patrick Devine committed
804
805
806
807
808
809
810
811
	}

	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 }}"""
812
813

{{- if .System }}
Patrick Devine's avatar
Patrick Devine committed
814
SYSTEM """{{ .System }}"""
815
{{- end }}
816
817
818
819

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

Michael Yang's avatar
Michael Yang committed
821
822
823
824
{{- range $k, $v := .Parameters }}
{{- range $parameter := $v }}
PARAMETER {{ $k }} {{ printf "%#v" $parameter }}
{{- end }}
Michael Yang's avatar
Michael Yang committed
825
{{- end }}`
Patrick Devine's avatar
Patrick Devine committed
826
827
828

	tmpl, err := template.New("").Parse(modelFile)
	if err != nil {
829
		slog.Info(fmt.Sprintf("error parsing template: %q", err))
Patrick Devine's avatar
Patrick Devine committed
830
831
832
833
834
835
		return "", err
	}

	var buf bytes.Buffer

	if err = tmpl.Execute(&buf, mt); err != nil {
836
		slog.Info(fmt.Sprintf("error executing template: %q", err))
Patrick Devine's avatar
Patrick Devine committed
837
838
839
840
841
842
		return "", err
	}

	return buf.String(), nil
}

Michael Yang's avatar
Michael Yang committed
843
func PushModel(ctx context.Context, name string, regOpts *registryOptions, fn func(api.ProgressResponse)) error {
844
	mp := ParseModelPath(name)
845
846
	fn(api.ProgressResponse{Status: "retrieving manifest"})

847
848
849
850
	if mp.ProtocolScheme == "http" && !regOpts.Insecure {
		return fmt.Errorf("insecure protocol http")
	}

Patrick Devine's avatar
Patrick Devine committed
851
	manifest, _, err := GetManifest(mp)
852
	if err != nil {
853
		fn(api.ProgressResponse{Status: "couldn't retrieve manifest"})
854
855
856
857
		return err
	}

	var layers []*Layer
Jeffrey Morgan's avatar
Jeffrey Morgan committed
858
	layers = append(layers, manifest.Layers...)
Michael Yang's avatar
Michael Yang committed
859
	layers = append(layers, manifest.Config)
860
861

	for _, layer := range layers {
Michael Yang's avatar
Michael Yang committed
862
		if err := uploadBlob(ctx, mp, layer, regOpts, fn); err != nil {
863
			slog.Info(fmt.Sprintf("error uploading blob: %v", err))
864
865
866
			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())
			}
867
868
			return err
		}
869
870
	}

871
	fn(api.ProgressResponse{Status: "pushing manifest"})
Michael Yang's avatar
Michael Yang committed
872
873
	requestURL := mp.BaseURL()
	requestURL = requestURL.JoinPath("v2", mp.GetNamespaceRepository(), "manifests", mp.Tag)
874
875
876
877
878
879

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

Michael Yang's avatar
Michael Yang committed
880
881
	headers := make(http.Header)
	headers.Set("Content-Type", "application/vnd.docker.distribution.manifest.v2+json")
Michael Yang's avatar
Michael Yang committed
882
	resp, err := makeRequestWithRetry(ctx, http.MethodPut, requestURL, headers, bytes.NewReader(manifestJSON), regOpts)
883
884
885
886
887
	if err != nil {
		return err
	}
	defer resp.Body.Close()

888
	fn(api.ProgressResponse{Status: "success"})
889
890
891
892

	return nil
}

Michael Yang's avatar
Michael Yang committed
893
func PullModel(ctx context.Context, name string, regOpts *registryOptions, fn func(api.ProgressResponse)) error {
894
895
	mp := ParseModelPath(name)

896
897
898
899
900
	var manifest *ManifestV2
	var err error
	var noprune string

	// build deleteMap to prune unused layers
Michael Yang's avatar
Michael Yang committed
901
	deleteMap := make(map[string]struct{})
902
903
904
905
906
907
908
909
910

	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
911
				deleteMap[l.Digest] = struct{}{}
912
			}
Michael Yang's avatar
Michael Yang committed
913
			deleteMap[manifest.Config.Digest] = struct{}{}
914
915
916
		}
	}

917
918
	if mp.ProtocolScheme == "http" && !regOpts.Insecure {
		return fmt.Errorf("insecure protocol http")
919
	}
920

921
	fn(api.ProgressResponse{Status: "pulling manifest"})
922

923
	manifest, err = pullModelManifest(ctx, mp, regOpts)
924
	if err != nil {
925
		return fmt.Errorf("pull model manifest: %s", err)
926
927
928
	}

	var layers []*Layer
Bruce MacDonald's avatar
Bruce MacDonald committed
929
	layers = append(layers, manifest.Layers...)
Michael Yang's avatar
Michael Yang committed
930
	layers = append(layers, manifest.Config)
931
932

	for _, layer := range layers {
933
934
935
936
937
938
939
940
		if err := downloadBlob(
			ctx,
			downloadOpts{
				mp:      mp,
				digest:  layer.Digest,
				regOpts: regOpts,
				fn:      fn,
			}); err != nil {
941
942
			return err
		}
943
		delete(deleteMap, layer.Digest)
944
	}
945
	delete(deleteMap, manifest.Config.Digest)
946

Michael Yang's avatar
Michael Yang committed
947
948
949
	fn(api.ProgressResponse{Status: "verifying sha256 digest"})
	for _, layer := range layers {
		if err := verifyBlob(layer.Digest); err != nil {
950
951
952
953
954
955
956
957
			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
958
					slog.Info(fmt.Sprintf("couldn't remove file with digest mismatch '%s': %v", fp, err))
959
960
				}
			}
Michael Yang's avatar
Michael Yang committed
961
962
963
964
			return err
		}
	}

965
	fn(api.ProgressResponse{Status: "writing manifest"})
966

967
	manifestJSON, err := json.Marshal(manifest)
968
969
970
971
	if err != nil {
		return err
	}

972
	fp, err := mp.GetManifestPath()
973
974
975
	if err != nil {
		return err
	}
976
977
978
	if err := os.MkdirAll(filepath.Dir(fp), 0o755); err != nil {
		return err
	}
979

Bruce MacDonald's avatar
Bruce MacDonald committed
980
	err = os.WriteFile(fp, manifestJSON, 0o644)
981
	if err != nil {
982
		slog.Info(fmt.Sprintf("couldn't write to %s", fp))
983
984
985
		return err
	}

986
987
988
989
990
991
992
993
	if noprune == "" {
		fn(api.ProgressResponse{Status: "removing any unused layers"})
		err = deleteUnusedLayers(nil, deleteMap, false)
		if err != nil {
			return err
		}
	}

994
	fn(api.ProgressResponse{Status: "success"})
995
996
997
998

	return nil
}

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

Michael Yang's avatar
Michael Yang committed
1002
1003
	headers := make(http.Header)
	headers.Set("Accept", "application/vnd.docker.distribution.manifest.v2+json")
Michael Yang's avatar
Michael Yang committed
1004
	resp, err := makeRequestWithRetry(ctx, http.MethodGet, requestURL, headers, nil, regOpts)
1005
1006
1007
1008
1009
1010
1011
1012
1013
1014
1015
1016
1017
1018
	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
}

// GetSHA256Digest returns the SHA256 hash of a given buffer and returns it, and the size of buffer
Michael Yang's avatar
Michael Yang committed
1019
func GetSHA256Digest(r io.Reader) (string, int64) {
Michael Yang's avatar
Michael Yang committed
1020
1021
1022
1023
1024
1025
	h := sha256.New()
	n, err := io.Copy(h, r)
	if err != nil {
		log.Fatal(err)
	}

Michael Yang's avatar
Michael Yang committed
1026
	return fmt.Sprintf("sha256:%x", h.Sum(nil)), n
1027
1028
}

1029
1030
var errUnauthorized = fmt.Errorf("unauthorized")

Michael Yang's avatar
Michael Yang committed
1031
func makeRequestWithRetry(ctx context.Context, method string, requestURL *url.URL, headers http.Header, body io.ReadSeeker, regOpts *registryOptions) (*http.Response, error) {
Michael Yang's avatar
Michael Yang committed
1032
	for i := 0; i < 2; i++ {
Michael Yang's avatar
Michael Yang committed
1033
		resp, err := makeRequest(ctx, method, requestURL, headers, body, regOpts)
Michael Yang's avatar
Michael Yang committed
1034
		if err != nil {
Michael Yang's avatar
Michael Yang committed
1035
			if !errors.Is(err, context.Canceled) {
1036
				slog.Info(fmt.Sprintf("request failed: %v", err))
Michael Yang's avatar
Michael Yang committed
1037
1038
			}

Michael Yang's avatar
Michael Yang committed
1039
1040
			return nil, err
		}
Michael Yang's avatar
Michael Yang committed
1041
1042
1043
1044

		switch {
		case resp.StatusCode == http.StatusUnauthorized:
			// Handle authentication error with one retry
Michael Yang's avatar
Michael Yang committed
1045
1046
			challenge := parseRegistryChallenge(resp.Header.Get("www-authenticate"))
			token, err := getAuthorizationToken(ctx, challenge)
Michael Yang's avatar
Michael Yang committed
1047
1048
1049
			if err != nil {
				return nil, err
			}
Michael Yang's avatar
Michael Yang committed
1050
1051
1052
1053
1054
1055
1056
1057
1058
1059
1060
1061
1062
1063
1064
1065
1066
			regOpts.Token = token
			if body != nil {
				_, err = body.Seek(0, io.SeekStart)
				if err != nil {
					return nil, err
				}
			}
		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)
		default:
			return resp, nil
Michael Yang's avatar
Michael Yang committed
1067
1068
1069
		}
	}

Michael Yang's avatar
Michael Yang committed
1070
	return nil, errUnauthorized
Michael Yang's avatar
Michael Yang committed
1071
1072
}

Michael Yang's avatar
Michael Yang committed
1073
1074
1075
1076
1077
1078
1079
1080
1081
1082
1083
1084
1085
1086
1087
1088
1089
1090
1091
1092
1093
1094
1095
1096
1097
1098
1099
1100
1101
1102
1103
1104
1105
1106
1107
1108
1109
1110
1111
1112
1113
1114
1115
1116
1117
1118
1119
1120
1121
1122
1123
1124
func makeRequest(ctx context.Context, method string, requestURL *url.URL, headers http.Header, body io.Reader, regOpts *registryOptions) (*http.Response, error) {
	if requestURL.Scheme != "http" && regOpts != nil && regOpts.Insecure {
		requestURL.Scheme = "http"
	}

	req, err := http.NewRequestWithContext(ctx, method, requestURL.String(), body)
	if err != nil {
		return nil, err
	}

	if headers != nil {
		req.Header = headers
	}

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

	req.Header.Set("User-Agent", fmt.Sprintf("ollama/%s (%s %s) Go/%s", version.Version, runtime.GOARCH, runtime.GOOS, runtime.Version()))

	if s := req.Header.Get("Content-Length"); s != "" {
		contentLength, err := strconv.ParseInt(s, 10, 64)
		if err != nil {
			return nil, err
		}

		req.ContentLength = contentLength
	}

	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)
	if err != nil {
		return nil, err
	}

	return resp, nil
}

Patrick Devine's avatar
Patrick Devine committed
1125
1126
1127
1128
1129
1130
1131
1132
1133
1134
1135
1136
1137
1138
1139
1140
1141
1142
1143
1144
1145
1146
1147
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]
}

Michael Yang's avatar
Michael Yang committed
1148
func parseRegistryChallenge(authStr string) registryChallenge {
Patrick Devine's avatar
Patrick Devine committed
1149
1150
	authStr = strings.TrimPrefix(authStr, "Bearer ")

Michael Yang's avatar
Michael Yang committed
1151
	return registryChallenge{
Patrick Devine's avatar
Patrick Devine committed
1152
1153
1154
1155
1156
1157
		Realm:   getValue(authStr, "realm"),
		Service: getValue(authStr, "service"),
		Scope:   getValue(authStr, "scope"),
	}
}

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

Michael Yang's avatar
Michael Yang committed
1160
1161
1162
1163
1164
1165
1166
1167
1168
1169
1170
1171
1172
1173
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 {
1174
		return fmt.Errorf("%w: want %s, got %s", errDigestMismatch, digest, fileDigest)
Michael Yang's avatar
Michael Yang committed
1175
1176
1177
1178
	}

	return nil
}