Get up and running with Kimi, GLM, MiniMax, DeepSeek, gpt-oss, Qwen, Gemma and other models.
api: return model capabilities from the show endpoint (#10066)
Bruce MacDonalde172f095ba4a
diff --git a/api/types.go b/api/types.goindex a38b335b7..b4a65fe5c 100644--- a/api/types.go+++ b/api/types.go@@ -12,6 +12,7 @@ import ("time""github.com/ollama/ollama/envconfig"+ "github.com/ollama/ollama/types/model")// StatusError is an error with an HTTP status code and message.@@ -340,17 +341,18 @@ type ShowRequest struct {// ShowResponse is the response returned from [Client.Show].type ShowResponse struct {- License string `json:"license,omitempty"`- Modelfile string `json:"modelfile,omitempty"`- Parameters string `json:"parameters,omitempty"`- Template string `json:"template,omitempty"`- System string `json:"system,omitempty"`- Details ModelDetails `json:"details,omitempty"`- Messages []Message `json:"messages,omitempty"`- ModelInfo map[string]any `json:"model_info,omitempty"`- ProjectorInfo map[string]any `json:"projector_info,omitempty"`- Tensors []Tensor `json:"tensors,omitempty"`- ModifiedAt time.Time `json:"modified_at,omitempty"`+ License string `json:"license,omitempty"`+ Modelfile string `json:"modelfile,omitempty"`+ Parameters string `json:"parameters,omitempty"`+ Template string `json:"template,omitempty"`+ System string `json:"system,omitempty"`+ Details ModelDetails `json:"details,omitempty"`+ Messages []Message `json:"messages,omitempty"`+ ModelInfo map[string]any `json:"model_info,omitempty"`+ ProjectorInfo map[string]any `json:"projector_info,omitempty"`+ Tensors []Tensor `json:"tensors,omitempty"`+ Capabilities []model.Capability `json:"capabilities,omitempty"`+ ModifiedAt time.Time `json:"modified_at,omitempty"`}// CopyRequest is the request passed to [Client.Copy].diff --git a/cmd/cmd.go b/cmd/cmd.goindex abb4806b5..36d7e6cfc 100644--- a/cmd/cmd.go+++ b/cmd/cmd.go@@ -18,6 +18,7 @@ import ("os/signal""path/filepath""runtime"+ "slices""sort""strconv""strings"@@ -339,6 +340,11 @@ func RunHandler(cmd *cobra.Command, args []string) error {return err}+ opts.MultiModal = slices.Contains(info.Capabilities, model.CapabilityVision)++ // TODO: remove the projector info and vision info checks below,+ // these are left in for backwards compatibility with older servers+ // that don't have the capabilities field in the model infoif len(info.ProjectorInfo) != 0 {opts.MultiModal = true}@@ -669,6 +675,15 @@ func showInfo(resp *api.ShowResponse, verbose bool, w io.Writer) error {return})+ if len(resp.Capabilities) > 0 {+ tableRender("Capabilities", func() (rows [][]string) {+ for _, capability := range resp.Capabilities {+ rows = append(rows, []string{"", capability.String()})+ }+ return+ })+ }+if resp.ProjectorInfo != nil {tableRender("Projector", func() (rows [][]string) {arch := resp.ProjectorInfo["general.architecture"].(string)diff --git a/cmd/cmd_test.go b/cmd/cmd_test.goindex ea3bdffe8..e6a542d09 100644--- a/cmd/cmd_test.go+++ b/cmd/cmd_test.go@@ -16,6 +16,7 @@ import ("github.com/spf13/cobra""github.com/ollama/ollama/api"+ "github.com/ollama/ollama/types/model")func TestShowInfo(t *testing.T) {@@ -260,6 +261,34 @@ Weigh anchor!t.Errorf("unexpected output (-want +got):\n%s", diff)}})++ t.Run("capabilities", func(t *testing.T) {+ var b bytes.Buffer+ if err := showInfo(&api.ShowResponse{+ Details: api.ModelDetails{+ Family: "test",+ ParameterSize: "7B",+ QuantizationLevel: "FP16",+ },+ Capabilities: []model.Capability{model.CapabilityVision, model.CapabilityTools},+ }, false, &b); err != nil {+ t.Fatal(err)+ }++ expect := " Model\n" ++ " architecture test \n" ++ " parameters 7B \n" ++ " quantization FP16 \n" ++ "\n" ++ " Capabilities\n" ++ " vision \n" ++ " tools \n" ++ "\n"++ if diff := cmp.Diff(expect, b.String()); diff != "" {+ t.Errorf("unexpected output (-want +got):\n%s", diff)+ }+ })}func TestDeleteHandler(t *testing.T) {diff --git a/docs/api.md b/docs/api.mdindex fe044d794..04ee299d2 100644--- a/docs/api.md+++ b/docs/api.md@@ -1217,7 +1217,7 @@ Show information about a model including details, modelfile, template, parameter```shellcurl http://localhost:11434/api/show -d '{- "model": "llama3.2"+ "model": "llava"}'```@@ -1260,7 +1260,11 @@ curl http://localhost:11434/api/show -d '{"tokenizer.ggml.pre": "llama-bpe","tokenizer.ggml.token_type": [], // populates if `verbose=true`"tokenizer.ggml.tokens": [] // populates if `verbose=true`- }+ },+ "capabilities": [+ "completion",+ "vision"+ ],}```diff --git a/server/images.go b/server/images.goindex 290e68ba9..2ef9e5d02 100644--- a/server/images.go+++ b/server/images.go@@ -35,17 +35,11 @@ var (errCapabilityCompletion = errors.New("completion")errCapabilityTools = errors.New("tools")errCapabilityInsert = errors.New("insert")+ errCapabilityVision = errors.New("vision")+ errCapabilityEmbedding = errors.New("embedding")errInsecureProtocol = errors.New("insecure protocol http"))-type Capability string--const (- CapabilityCompletion = Capability("completion")- CapabilityTools = Capability("tools")- CapabilityInsert = Capability("insert")-)-type registryOptions struct {Insecure boolUsername string@@ -72,46 +66,77 @@ type Model struct {Template *template.Template}-// CheckCapabilities checks if the model has the specified capabilities returning an error describing-// any missing or unknown capabilities-func (m *Model) CheckCapabilities(caps ...Capability) error {- var errs []error- for _, cap := range caps {- switch cap {- case CapabilityCompletion:- r, err := os.Open(m.ModelPath)- if err != nil {- slog.Error("couldn't open model file", "error", err)- continue- }- defer r.Close()+// Capabilities returns the capabilities that the model supports+func (m *Model) Capabilities() []model.Capability {+ capabilities := []model.Capability{}- // TODO(mxyng): decode the GGML into model to avoid doing this multiple times- f, _, err := ggml.Decode(r, 0)- if err != nil {- slog.Error("couldn't decode ggml", "error", err)- continue- }+ // Check for completion capability+ r, err := os.Open(m.ModelPath)+ if err == nil {+ defer r.Close()+ f, _, err := ggml.Decode(r, 0)+ if err == nil {if _, ok := f.KV()[fmt.Sprintf("%s.pooling_type", f.KV().Architecture())]; ok {- errs = append(errs, errCapabilityCompletion)- }- case CapabilityTools:- if !slices.Contains(m.Template.Vars(), "tools") {- errs = append(errs, errCapabilityTools)+ capabilities = append(capabilities, model.CapabilityEmbedding)+ } else {+ capabilities = append(capabilities, model.CapabilityCompletion)}- case CapabilityInsert:- vars := m.Template.Vars()- if !slices.Contains(vars, "suffix") {- errs = append(errs, errCapabilityInsert)+ if _, ok := f.KV()[fmt.Sprintf("%s.vision.block_count", f.KV().Architecture())]; ok {+ capabilities = append(capabilities, model.CapabilityVision)}- default:+ } else {+ slog.Error("couldn't decode ggml", "error", err)+ }+ } else {+ slog.Error("couldn't open model file", "error", err)+ }++ if m.Template == nil {+ return capabilities+ }++ // Check for tools capability+ if slices.Contains(m.Template.Vars(), "tools") {+ capabilities = append(capabilities, model.CapabilityTools)+ }++ // Check for insert capability+ if slices.Contains(m.Template.Vars(), "suffix") {+ capabilities = append(capabilities, model.CapabilityInsert)+ }++ return capabilities+}++// CheckCapabilities checks if the model has the specified capabilities returning an error describing+// any missing or unknown capabilities+func (m *Model) CheckCapabilities(want ...model.Capability) error {+ available := m.Capabilities()+ var errs []error++ // Map capabilities to their corresponding error+ capToErr := map[model.Capability]error{+ model.CapabilityCompletion: errCapabilityCompletion,+ model.CapabilityTools: errCapabilityTools,+ model.CapabilityInsert: errCapabilityInsert,+ model.CapabilityVision: errCapabilityVision,+ model.CapabilityEmbedding: errCapabilityEmbedding,+ }++ for _, cap := range want {+ err, ok := capToErr[cap]+ if !ok {slog.Error("unknown capability", "capability", cap)return fmt.Errorf("unknown capability: %s", cap)}++ if !slices.Contains(available, cap) {+ errs = append(errs, err)+ }}- if err := errors.Join(errs...); err != nil {+ if len(errs) > 0 {return fmt.Errorf("%w %w", errCapabilities, errors.Join(errs...))}diff --git a/server/images_test.go b/server/images_test.gonew file mode 100644index 000000000..22e5b7e6a--- /dev/null+++ b/server/images_test.go@@ -0,0 +1,360 @@+package server++import (+ "bytes"+ "encoding/binary"+ "os"+ "path/filepath"+ "strings"+ "testing"++ "github.com/ollama/ollama/template"+ "github.com/ollama/ollama/types/model"+)++// Constants for GGUF magic bytes and version+var (+ ggufMagic = []byte{0x47, 0x47, 0x55, 0x46} // "GGUF"+ ggufVer = uint32(3) // Version 3+)++// Helper function to create mock GGUF data+func createMockGGUFData(architecture string, vision bool) []byte {+ var buf bytes.Buffer++ // Write GGUF header+ buf.Write(ggufMagic)+ binary.Write(&buf, binary.LittleEndian, ggufVer)++ // Write tensor count (0 for our test)+ var numTensors uint64 = 0+ binary.Write(&buf, binary.LittleEndian, numTensors)++ // Calculate number of metadata entries+ numMetaEntries := uint64(1) // architecture entry+ if vision {+ numMetaEntries+++ }+ // Add embedding entry if architecture is "bert"+ if architecture == "bert" {+ numMetaEntries+++ }+ binary.Write(&buf, binary.LittleEndian, numMetaEntries)++ // Write architecture metadata+ archKey := "general.architecture"+ keyLen := uint64(len(archKey))+ binary.Write(&buf, binary.LittleEndian, keyLen)+ buf.WriteString(archKey)++ // String type (8)+ var strType uint32 = 8+ binary.Write(&buf, binary.LittleEndian, strType)++ // String length+ strLen := uint64(len(architecture))+ binary.Write(&buf, binary.LittleEndian, strLen)+ buf.WriteString(architecture)++ if vision {+ visionKey := architecture + ".vision.block_count"+ keyLen = uint64(len(visionKey))+ binary.Write(&buf, binary.LittleEndian, keyLen)+ buf.WriteString(visionKey)++ // uint32 type (4)+ var uint32Type uint32 = 4+ binary.Write(&buf, binary.LittleEndian, uint32Type)++ // uint32 value (1)+ var countVal uint32 = 1+ binary.Write(&buf, binary.LittleEndian, countVal)+ }+ // Write embedding metadata if architecture is "bert"+ if architecture == "bert" {+ poolKey := architecture + ".pooling_type"+ keyLen = uint64(len(poolKey))+ binary.Write(&buf, binary.LittleEndian, keyLen)+ buf.WriteString(poolKey)++ // uint32 type (4)+ var uint32Type uint32 = 4+ binary.Write(&buf, binary.LittleEndian, uint32Type)++ // uint32 value (1)+ var poolingVal uint32 = 1+ binary.Write(&buf, binary.LittleEndian, poolingVal)+ }++ return buf.Bytes()+}++func TestModelCapabilities(t *testing.T) {+ // Create a temporary directory for test files+ tempDir, err := os.MkdirTemp("", "model_capabilities_test")+ if err != nil {+ t.Fatalf("Failed to create temp directory: %v", err)+ }+ defer os.RemoveAll(tempDir)++ // Create different types of mock model files+ completionModelPath := filepath.Join(tempDir, "model.bin")+ visionModelPath := filepath.Join(tempDir, "vision_model.bin")+ embeddingModelPath := filepath.Join(tempDir, "embedding_model.bin")+ // Create a simple model file for tests that don't depend on GGUF content+ simpleModelPath := filepath.Join(tempDir, "simple_model.bin")++ err = os.WriteFile(completionModelPath, createMockGGUFData("llama", false), 0o644)+ if err != nil {+ t.Fatalf("Failed to create completion model file: %v", err)+ }+ err = os.WriteFile(visionModelPath, createMockGGUFData("llama", true), 0o644)+ if err != nil {+ t.Fatalf("Failed to create completion model file: %v", err)+ }+ err = os.WriteFile(embeddingModelPath, createMockGGUFData("bert", false), 0o644)+ if err != nil {+ t.Fatalf("Failed to create embedding model file: %v", err)+ }+ err = os.WriteFile(simpleModelPath, []byte("dummy model data"), 0o644)+ if err != nil {+ t.Fatalf("Failed to create simple model file: %v", err)+ }++ toolsInsertTemplate, err := template.Parse("{{ .prompt }}{{ if .tools }}{{ .tools }}{{ end }}{{ if .suffix }}{{ .suffix }}{{ end }}")+ if err != nil {+ t.Fatalf("Failed to parse template: %v", err)+ }+ chatTemplate, err := template.Parse("{{ .prompt }}")+ if err != nil {+ t.Fatalf("Failed to parse template: %v", err)+ }+ toolsTemplate, err := template.Parse("{{ .prompt }}{{ if .tools }}{{ .tools }}{{ end }}")+ if err != nil {+ t.Fatalf("Failed to parse template: %v", err)+ }++ testModels := []struct {+ name string+ model Model+ expectedCaps []model.Capability+ }{+ {+ name: "model with completion capability",+ model: Model{+ ModelPath: completionModelPath,+ Template: chatTemplate,+ },+ expectedCaps: []model.Capability{model.CapabilityCompletion},+ },++ {+ name: "model with completion, tools, and insert capability",+ model: Model{+ ModelPath: completionModelPath,+ Template: toolsInsertTemplate,+ },+ expectedCaps: []model.Capability{model.CapabilityCompletion, model.CapabilityTools, model.CapabilityInsert},+ },+ {+ name: "model with tools and insert capability",+ model: Model{+ ModelPath: simpleModelPath,+ Template: toolsInsertTemplate,+ },+ expectedCaps: []model.Capability{model.CapabilityTools, model.CapabilityInsert},+ },+ {+ name: "model with tools capability",+ model: Model{+ ModelPath: simpleModelPath,+ Template: toolsTemplate,+ },+ expectedCaps: []model.Capability{model.CapabilityTools},+ },+ {+ name: "model with vision capability",+ model: Model{+ ModelPath: visionModelPath,+ Template: chatTemplate,+ },+ expectedCaps: []model.Capability{model.CapabilityCompletion, model.CapabilityVision},+ },+ {+ name: "model with vision, tools, and insert capability",+ model: Model{+ ModelPath: visionModelPath,+ Template: toolsInsertTemplate,+ },+ expectedCaps: []model.Capability{model.CapabilityCompletion, model.CapabilityVision, model.CapabilityTools, model.CapabilityInsert},+ },+ {+ name: "model with embedding capability",+ model: Model{+ ModelPath: embeddingModelPath,+ Template: chatTemplate,+ },+ expectedCaps: []model.Capability{model.CapabilityEmbedding},+ },+ }++ // compare two slices of model.Capability regardless of order+ compareCapabilities := func(a, b []model.Capability) bool {+ if len(a) != len(b) {+ return false+ }++ aCount := make(map[model.Capability]int)+ for _, cap := range a {+ aCount[cap]+++ }++ bCount := make(map[model.Capability]int)+ for _, cap := range b {+ bCount[cap]+++ }++ for cap, count := range aCount {+ if bCount[cap] != count {+ return false+ }+ }++ return true+ }++ for _, tt := range testModels {+ t.Run(tt.name, func(t *testing.T) {+ // Test Capabilities method+ caps := tt.model.Capabilities()+ if !compareCapabilities(caps, tt.expectedCaps) {+ t.Errorf("Expected capabilities %v, got %v", tt.expectedCaps, caps)+ }+ })+ }+}++func TestModelCheckCapabilities(t *testing.T) {+ // Create a temporary directory for test files+ tempDir, err := os.MkdirTemp("", "model_check_capabilities_test")+ if err != nil {+ t.Fatalf("Failed to create temp directory: %v", err)+ }+ defer os.RemoveAll(tempDir)++ visionModelPath := filepath.Join(tempDir, "vision_model.bin")+ simpleModelPath := filepath.Join(tempDir, "model.bin")+ embeddingModelPath := filepath.Join(tempDir, "embedding_model.bin")++ err = os.WriteFile(simpleModelPath, []byte("dummy model data"), 0o644)+ if err != nil {+ t.Fatalf("Failed to create simple model file: %v", err)+ }+ err = os.WriteFile(visionModelPath, createMockGGUFData("llama", true), 0o644)+ if err != nil {+ t.Fatalf("Failed to create vision model file: %v", err)+ }+ err = os.WriteFile(embeddingModelPath, createMockGGUFData("bert", false), 0o644)+ if err != nil {+ t.Fatalf("Failed to create embedding model file: %v", err)+ }++ toolsInsertTemplate, err := template.Parse("{{ .prompt }}{{ if .tools }}{{ .tools }}{{ end }}{{ if .suffix }}{{ .suffix }}{{ end }}")+ if err != nil {+ t.Fatalf("Failed to parse template: %v", err)+ }+ chatTemplate, err := template.Parse("{{ .prompt }}")+ if err != nil {+ t.Fatalf("Failed to parse template: %v", err)+ }+ toolsTemplate, err := template.Parse("{{ .prompt }}{{ if .tools }}{{ .tools }}{{ end }}")+ if err != nil {+ t.Fatalf("Failed to parse template: %v", err)+ }++ tests := []struct {+ name string+ model Model+ checkCaps []model.Capability+ expectedErrMsg string+ }{+ {+ name: "completion model without tools capability",+ model: Model{+ ModelPath: simpleModelPath,+ Template: chatTemplate,+ },+ checkCaps: []model.Capability{model.CapabilityTools},+ expectedErrMsg: "does not support tools",+ },+ {+ name: "model with all needed capabilities",+ model: Model{+ ModelPath: simpleModelPath,+ Template: toolsInsertTemplate,+ },+ checkCaps: []model.Capability{model.CapabilityTools, model.CapabilityInsert},+ },+ {+ name: "model missing insert capability",+ model: Model{+ ModelPath: simpleModelPath,+ Template: toolsTemplate,+ },+ checkCaps: []model.Capability{model.CapabilityInsert},+ expectedErrMsg: "does not support insert",+ },+ {+ name: "model missing vision capability",+ model: Model{+ ModelPath: simpleModelPath,+ Template: toolsTemplate,+ },+ checkCaps: []model.Capability{model.CapabilityVision},+ expectedErrMsg: "does not support vision",+ },+ {+ name: "model with vision capability",+ model: Model{+ ModelPath: visionModelPath,+ Template: chatTemplate,+ },+ checkCaps: []model.Capability{model.CapabilityVision},+ },+ {+ name: "model with embedding capability",+ model: Model{+ ModelPath: embeddingModelPath,+ Template: chatTemplate,+ },+ checkCaps: []model.Capability{model.CapabilityEmbedding},+ },+ {+ name: "unknown capability",+ model: Model{+ ModelPath: simpleModelPath,+ Template: chatTemplate,+ },+ checkCaps: []model.Capability{"unknown"},+ expectedErrMsg: "unknown capability",+ },+ }++ for _, tt := range tests {+ t.Run(tt.name, func(t *testing.T) {+ // Test CheckCapabilities method+ err := tt.model.CheckCapabilities(tt.checkCaps...)+ if tt.expectedErrMsg == "" {+ if err != nil {+ t.Errorf("Expected no error, got: %v", err)+ }+ } else {+ if err == nil {+ t.Errorf("Expected error containing %q, got nil", tt.expectedErrMsg)+ } else if !strings.Contains(err.Error(), tt.expectedErrMsg) {+ t.Errorf("Expected error containing %q, got: %v", tt.expectedErrMsg, err)+ }+ }+ })+ }+}diff --git a/server/routes.go b/server/routes.goindex 92336af00..95e498202 100644--- a/server/routes.go+++ b/server/routes.go@@ -87,7 +87,7 @@ func modelOptions(model *Model, requestOpts map[string]interface{}) (api.Options// scheduleRunner schedules a runner after validating inputs such as capabilities and model options.// It returns the allocated runner, model instance, and consolidated options if successful and error otherwise.-func (s *Server) scheduleRunner(ctx context.Context, name string, caps []Capability, requestOpts map[string]any, keepAlive *api.Duration) (llm.LlamaServer, *Model, *api.Options, error) {+func (s *Server) scheduleRunner(ctx context.Context, name string, caps []model.Capability, requestOpts map[string]any, keepAlive *api.Duration) (llm.LlamaServer, *Model, *api.Options, error) {if name == "" {return nil, nil, nil, fmt.Errorf("model %w", errRequired)}@@ -144,7 +144,7 @@ func (s *Server) GenerateHandler(c *gin.Context) {return}- model, err := GetModel(name.String())+ m, err := GetModel(name.String())if err != nil {switch {case errors.Is(err, fs.ErrNotExist):@@ -159,7 +159,7 @@ func (s *Server) GenerateHandler(c *gin.Context) {// expire the runnerif req.Prompt == "" && req.KeepAlive != nil && int(req.KeepAlive.Seconds()) == 0 {- s.sched.expireRunner(model)+ s.sched.expireRunner(m)c.JSON(http.StatusOK, api.GenerateResponse{Model: req.Model,@@ -176,9 +176,9 @@ func (s *Server) GenerateHandler(c *gin.Context) {return}- caps := []Capability{CapabilityCompletion}+ caps := []model.Capability{model.CapabilityCompletion}if req.Suffix != "" {- caps = append(caps, CapabilityInsert)+ caps = append(caps, model.CapabilityInsert)}r, m, opts, err := s.scheduleRunner(c.Request.Context(), name.String(), caps, req.Options, req.KeepAlive)@@ -203,7 +203,7 @@ func (s *Server) GenerateHandler(c *gin.Context) {return}- isMllama := checkMllamaModelFamily(model)+ isMllama := checkMllamaModelFamily(m)if isMllama && len(req.Images) > 1 {c.AbortWithStatusJSON(http.StatusBadRequest, gin.H{"error": "this model only supports one image: more than one image sent"})return@@ -211,7 +211,7 @@ func (s *Server) GenerateHandler(c *gin.Context) {images := make([]llm.ImageData, len(req.Images))for i := range req.Images {- if isMllama && len(model.ProjectorPaths) > 0 {+ if isMllama && len(m.ProjectorPaths) > 0 {data, opts, err := mllama.Preprocess(bytes.NewReader(req.Images[i]))if err != nil {c.AbortWithStatusJSON(http.StatusInternalServerError, gin.H{"error": "error processing image"})@@ -422,7 +422,7 @@ func (s *Server) EmbedHandler(c *gin.Context) {return}- r, m, opts, err := s.scheduleRunner(c.Request.Context(), name.String(), []Capability{}, req.Options, req.KeepAlive)+ r, m, opts, err := s.scheduleRunner(c.Request.Context(), name.String(), []model.Capability{}, req.Options, req.KeepAlive)if err != nil {handleScheduleError(c, req.Model, err)return@@ -530,7 +530,7 @@ func (s *Server) EmbeddingsHandler(c *gin.Context) {return}- r, _, _, err := s.scheduleRunner(c.Request.Context(), name.String(), []Capability{}, req.Options, req.KeepAlive)+ r, _, _, err := s.scheduleRunner(c.Request.Context(), name.String(), []model.Capability{}, req.Options, req.KeepAlive)if err != nil {handleScheduleError(c, req.Model, err)return@@ -813,12 +813,13 @@ func GetModelInfo(req api.ShowRequest) (*api.ShowResponse, error) {}resp := &api.ShowResponse{- License: strings.Join(m.License, "\n"),- System: m.System,- Template: m.Template.String(),- Details: modelDetails,- Messages: msgs,- ModifiedAt: manifest.fi.ModTime(),+ License: strings.Join(m.License, "\n"),+ System: m.System,+ Template: m.Template.String(),+ Details: modelDetails,+ Messages: msgs,+ Capabilities: m.Capabilities(),+ ModifiedAt: manifest.fi.ModTime(),}var params []string@@ -1468,9 +1469,9 @@ func (s *Server) ChatHandler(c *gin.Context) {return}- caps := []Capability{CapabilityCompletion}+ caps := []model.Capability{model.CapabilityCompletion}if len(req.Tools) > 0 {- caps = append(caps, CapabilityTools)+ caps = append(caps, model.CapabilityTools)}name := model.ParseName(req.Model)diff --git a/server/sched.go b/server/sched.goindex 9126c2969..e6cefa5ac 100644--- a/server/sched.go+++ b/server/sched.go@@ -20,6 +20,7 @@ import ("github.com/ollama/ollama/format""github.com/ollama/ollama/fs/ggml""github.com/ollama/ollama/llm"+ "github.com/ollama/ollama/types/model")type LlmRequest struct {@@ -195,7 +196,7 @@ func (s *Scheduler) processPending(ctx context.Context) {}// Embedding models should always be loaded with parallel=1- if pending.model.CheckCapabilities(CapabilityCompletion) != nil {+ if pending.model.CheckCapabilities(model.CapabilityCompletion) != nil {numParallel = 1}diff --git a/types/model/capability.go b/types/model/capability.gonew file mode 100644index 000000000..fb8689403--- /dev/null+++ b/types/model/capability.go@@ -0,0 +1,15 @@+package model++type Capability string++const (+ CapabilityCompletion = Capability("completion")+ CapabilityTools = Capability("tools")+ CapabilityInsert = Capability("insert")+ CapabilityVision = Capability("vision")+ CapabilityEmbedding = Capability("embedding")+)++func (c Capability) String() string {+ return string(c)+}