Get up and running with Kimi, GLM, MiniMax, DeepSeek, gpt-oss, Qwen, Gemma and other models.
embeddings: base64 encoding fix (#12715)
nicole pardale0ead1adee0a
diff --git a/middleware/openai.go b/middleware/openai.goindex 826a2111b..b2e43f165 100644--- a/middleware/openai.go+++ b/middleware/openai.go@@ -7,6 +7,7 @@ import ("io""math/rand""net/http"+ "strings""github.com/gin-gonic/gin"@@ -44,7 +45,8 @@ type RetrieveWriter struct {type EmbedWriter struct {BaseWriter- model string+ model string+ encodingFormat string}func (w *BaseWriter) writeError(data []byte) (int, error) {@@ -254,7 +256,7 @@ func (w *EmbedWriter) writeResponse(data []byte) (int, error) {}w.ResponseWriter.Header().Set("Content-Type", "application/json")- err = json.NewEncoder(w.ResponseWriter).Encode(openai.ToEmbeddingList(w.model, embedResponse))+ err = json.NewEncoder(w.ResponseWriter).Encode(openai.ToEmbeddingList(w.model, embedResponse, w.encodingFormat))if err != nil {return 0, err}@@ -348,6 +350,14 @@ func EmbeddingsMiddleware() gin.HandlerFunc {return}+ // Validate encoding_format parameter+ if req.EncodingFormat != "" {+ if !strings.EqualFold(req.EncodingFormat, "float") && !strings.EqualFold(req.EncodingFormat, "base64") {+ c.AbortWithStatusJSON(http.StatusBadRequest, openai.NewError(http.StatusBadRequest, fmt.Sprintf("Invalid value for 'encoding_format' = %s. Supported values: ['float', 'base64'].", req.EncodingFormat)))+ return+ }+ }+if req.Input == "" {req.Input = []string{""}}@@ -371,8 +381,9 @@ func EmbeddingsMiddleware() gin.HandlerFunc {c.Request.Body = io.NopCloser(&b)w := &EmbedWriter{- BaseWriter: BaseWriter{ResponseWriter: c.Writer},- model: req.Model,+ BaseWriter: BaseWriter{ResponseWriter: c.Writer},+ model: req.Model,+ encodingFormat: req.EncodingFormat,}c.Writer = wdiff --git a/middleware/openai_encoding_format_test.go b/middleware/openai_encoding_format_test.gonew file mode 100644index 000000000..52107d6ef--- /dev/null+++ b/middleware/openai_encoding_format_test.go@@ -0,0 +1,220 @@+package middleware++import (+ "encoding/base64"+ "encoding/json"+ "net/http"+ "net/http/httptest"+ "strings"+ "testing"++ "github.com/gin-gonic/gin"+ "github.com/ollama/ollama/api"+ "github.com/ollama/ollama/openai"+)++func TestEmbeddingsMiddleware_EncodingFormats(t *testing.T) {+ testCases := []struct {+ name string+ encodingFormat string+ expectType string // "array" or "string"+ verifyBase64 bool+ }{+ {"float format", "float", "array", false},+ {"base64 format", "base64", "string", true},+ {"default format", "", "array", false},+ }++ gin.SetMode(gin.TestMode)++ endpoint := func(c *gin.Context) {+ resp := api.EmbedResponse{+ Embeddings: [][]float32{{0.1, -0.2, 0.3}},+ PromptEvalCount: 5,+ }+ c.JSON(http.StatusOK, resp)+ }++ router := gin.New()+ router.Use(EmbeddingsMiddleware())+ router.Handle(http.MethodPost, "/api/embed", endpoint)++ for _, tc := range testCases {+ t.Run(tc.name, func(t *testing.T) {+ body := `{"input": "test", "model": "test-model"`+ if tc.encodingFormat != "" {+ body += `, "encoding_format": "` + tc.encodingFormat + `"`+ }+ body += `}`++ req, _ := http.NewRequest(http.MethodPost, "/api/embed", strings.NewReader(body))+ req.Header.Set("Content-Type", "application/json")++ resp := httptest.NewRecorder()+ router.ServeHTTP(resp, req)++ if resp.Code != http.StatusOK {+ t.Fatalf("expected status 200, got %d", resp.Code)+ }++ var result openai.EmbeddingList+ if err := json.Unmarshal(resp.Body.Bytes(), &result); err != nil {+ t.Fatalf("failed to unmarshal response: %v", err)+ }++ if len(result.Data) != 1 {+ t.Fatalf("expected 1 embedding, got %d", len(result.Data))+ }++ switch tc.expectType {+ case "array":+ if _, ok := result.Data[0].Embedding.([]interface{}); !ok {+ t.Errorf("expected array, got %T", result.Data[0].Embedding)+ }+ case "string":+ embStr, ok := result.Data[0].Embedding.(string)+ if !ok {+ t.Errorf("expected string, got %T", result.Data[0].Embedding)+ } else if tc.verifyBase64 {+ decoded, err := base64.StdEncoding.DecodeString(embStr)+ if err != nil {+ t.Errorf("invalid base64: %v", err)+ } else if len(decoded) != 12 {+ t.Errorf("expected 12 bytes, got %d", len(decoded))+ }+ }+ }+ })+ }+}++func TestEmbeddingsMiddleware_BatchWithBase64(t *testing.T) {+ gin.SetMode(gin.TestMode)++ endpoint := func(c *gin.Context) {+ resp := api.EmbedResponse{+ Embeddings: [][]float32{+ {0.1, 0.2},+ {0.3, 0.4},+ {0.5, 0.6},+ },+ PromptEvalCount: 10,+ }+ c.JSON(http.StatusOK, resp)+ }++ router := gin.New()+ router.Use(EmbeddingsMiddleware())+ router.Handle(http.MethodPost, "/api/embed", endpoint)++ body := `{+ "input": ["hello", "world", "test"],+ "model": "test-model",+ "encoding_format": "base64"+ }`++ req, _ := http.NewRequest(http.MethodPost, "/api/embed", strings.NewReader(body))+ req.Header.Set("Content-Type", "application/json")++ resp := httptest.NewRecorder()+ router.ServeHTTP(resp, req)++ if resp.Code != http.StatusOK {+ t.Fatalf("expected status 200, got %d", resp.Code)+ }++ var result openai.EmbeddingList+ if err := json.Unmarshal(resp.Body.Bytes(), &result); err != nil {+ t.Fatalf("failed to unmarshal response: %v", err)+ }++ if len(result.Data) != 3 {+ t.Fatalf("expected 3 embeddings, got %d", len(result.Data))+ }++ // All should be base64 strings+ for i := range 3 {+ embeddingStr, ok := result.Data[i].Embedding.(string)+ if !ok {+ t.Errorf("embedding %d: expected string, got %T", i, result.Data[i].Embedding)+ continue+ }++ // Verify it's valid base64+ if _, err := base64.StdEncoding.DecodeString(embeddingStr); err != nil {+ t.Errorf("embedding %d: invalid base64: %v", i, err)+ }++ // Check index+ if result.Data[i].Index != i {+ t.Errorf("embedding %d: expected index %d, got %d", i, i, result.Data[i].Index)+ }+ }+}++func TestEmbeddingsMiddleware_InvalidEncodingFormat(t *testing.T) {+ gin.SetMode(gin.TestMode)++ endpoint := func(c *gin.Context) {+ c.Status(http.StatusOK)+ }++ router := gin.New()+ router.Use(EmbeddingsMiddleware())+ router.Handle(http.MethodPost, "/api/embed", endpoint)++ testCases := []struct {+ name string+ encodingFormat string+ shouldFail bool+ }{+ {"valid: float", "float", false},+ {"valid: base64", "base64", false},+ {"valid: FLOAT (uppercase)", "FLOAT", false},+ {"valid: BASE64 (uppercase)", "BASE64", false},+ {"valid: Float (mixed)", "Float", false},+ {"valid: Base64 (mixed)", "Base64", false},+ {"invalid: json", "json", true},+ {"invalid: hex", "hex", true},+ {"invalid: invalid_format", "invalid_format", true},+ }++ for _, tc := range testCases {+ t.Run(tc.name, func(t *testing.T) {+ body := `{+ "input": "test",+ "model": "test-model",+ "encoding_format": "` + tc.encodingFormat + `"+ }`++ req, _ := http.NewRequest(http.MethodPost, "/api/embed", strings.NewReader(body))+ req.Header.Set("Content-Type", "application/json")++ resp := httptest.NewRecorder()+ router.ServeHTTP(resp, req)++ if tc.shouldFail {+ if resp.Code != http.StatusBadRequest {+ t.Errorf("expected status 400, got %d", resp.Code)+ }++ var errResp openai.ErrorResponse+ if err := json.Unmarshal(resp.Body.Bytes(), &errResp); err != nil {+ t.Fatalf("failed to unmarshal error response: %v", err)+ }++ if errResp.Error.Type != "invalid_request_error" {+ t.Errorf("expected error type 'invalid_request_error', got %q", errResp.Error.Type)+ }++ if !strings.Contains(errResp.Error.Message, "encoding_format") {+ t.Errorf("expected error message to mention encoding_format, got %q", errResp.Error.Message)+ }+ } else {+ if resp.Code != http.StatusOK {+ t.Errorf("expected status 200, got %d: %s", resp.Code, resp.Body.String())+ }+ }+ })+ }+}diff --git a/openai/openai.go b/openai/openai.goindex 23e9522f0..650514cf1 100644--- a/openai/openai.go+++ b/openai/openai.go@@ -2,7 +2,9 @@package openaiimport (+ "bytes""encoding/base64"+ "encoding/binary""encoding/json""errors""fmt"@@ -73,9 +75,10 @@ type JsonSchema struct {}type EmbedRequest struct {- Input any `json:"input"`- Model string `json:"model"`- Dimensions int `json:"dimensions,omitempty"`+ Input any `json:"input"`+ Model string `json:"model"`+ Dimensions int `json:"dimensions,omitempty"`+ EncodingFormat string `json:"encoding_format,omitempty"` // "float" or "base64"}type StreamOptions struct {@@ -181,9 +184,9 @@ type Model struct {}type Embedding struct {- Object string `json:"object"`- Embedding []float32 `json:"embedding"`- Index int `json:"index"`+ Object string `json:"object"`+ Embedding any `json:"embedding"` // Can be []float32 (float format) or string (base64 format)+ Index int `json:"index"`}type ListCompletion struct {@@ -377,13 +380,21 @@ func ToListCompletion(r api.ListResponse) ListCompletion {}// ToEmbeddingList converts an api.EmbedResponse to EmbeddingList-func ToEmbeddingList(model string, r api.EmbedResponse) EmbeddingList {+// encodingFormat can be "float", "base64", or empty (defaults to "float")+func ToEmbeddingList(model string, r api.EmbedResponse, encodingFormat string) EmbeddingList {if r.Embeddings != nil {var data []Embeddingfor i, e := range r.Embeddings {+ var embedding any+ if strings.EqualFold(encodingFormat, "base64") {+ embedding = floatsToBase64(e)+ } else {+ embedding = e+ }+data = append(data, Embedding{Object: "embedding",- Embedding: e,+ Embedding: embedding,Index: i,})}@@ -402,6 +413,13 @@ func ToEmbeddingList(model string, r api.EmbedResponse) EmbeddingList {return EmbeddingList{}}+// floatsToBase64 encodes a []float32 to a base64 string+func floatsToBase64(floats []float32) string {+ var buf bytes.Buffer+ binary.Write(&buf, binary.LittleEndian, floats)+ return base64.StdEncoding.EncodeToString(buf.Bytes())+}+// ToModel converts an api.ShowResponse to Modelfunc ToModel(r api.ShowResponse, m string) Model {return Model{diff --git a/openai/openai_encoding_format_test.go b/openai/openai_encoding_format_test.gonew file mode 100644index 000000000..d8ccb1f8a--- /dev/null+++ b/openai/openai_encoding_format_test.go@@ -0,0 +1,125 @@+package openai++import (+ "encoding/base64"+ "math"+ "testing"++ "github.com/ollama/ollama/api"+)++func TestToEmbeddingList(t *testing.T) {+ testCases := []struct {+ name string+ embeddings [][]float32+ format string+ expectType string // "float" or "base64"+ expectCount int+ promptEval int+ }{+ {"float format", [][]float32{{0.1, -0.2, 0.3}}, "float", "float", 1, 10},+ {"base64 format", [][]float32{{0.1, -0.2, 0.3}}, "base64", "base64", 1, 5},+ {"default to float", [][]float32{{0.1, -0.2, 0.3}}, "", "float", 1, 0},+ {"invalid defaults to float", [][]float32{{0.1, -0.2, 0.3}}, "invalid", "float", 1, 0},+ {"multiple embeddings", [][]float32{{0.1, 0.2}, {0.3, 0.4}, {0.5, 0.6}}, "base64", "base64", 3, 0},+ {"empty embeddings", nil, "float", "", 0, 0},+ }++ for _, tc := range testCases {+ t.Run(tc.name, func(t *testing.T) {+ resp := api.EmbedResponse{+ Embeddings: tc.embeddings,+ PromptEvalCount: tc.promptEval,+ }++ result := ToEmbeddingList("test-model", resp, tc.format)++ if tc.expectCount == 0 {+ if len(result.Data) != 0 {+ t.Errorf("expected 0 embeddings, got %d", len(result.Data))+ }+ return+ }++ if len(result.Data) != tc.expectCount {+ t.Fatalf("expected %d embeddings, got %d", tc.expectCount, len(result.Data))+ }++ if result.Model != "test-model" {+ t.Errorf("expected model 'test-model', got %q", result.Model)+ }++ // Check type of first embedding+ switch tc.expectType {+ case "float":+ if _, ok := result.Data[0].Embedding.([]float32); !ok {+ t.Errorf("expected []float32, got %T", result.Data[0].Embedding)+ }+ case "base64":+ embStr, ok := result.Data[0].Embedding.(string)+ if !ok {+ t.Errorf("expected string, got %T", result.Data[0].Embedding)+ } else if _, err := base64.StdEncoding.DecodeString(embStr); err != nil {+ t.Errorf("invalid base64: %v", err)+ }+ }++ // Check indices+ for i := range result.Data {+ if result.Data[i].Index != i {+ t.Errorf("embedding %d: expected index %d, got %d", i, i, result.Data[i].Index)+ }+ }++ if tc.promptEval > 0 && result.Usage.PromptTokens != tc.promptEval {+ t.Errorf("expected %d prompt tokens, got %d", tc.promptEval, result.Usage.PromptTokens)+ }+ })+ }+}++func TestFloatsToBase64(t *testing.T) {+ floats := []float32{0.1, -0.2, 0.3, -0.4, 0.5}++ result := floatsToBase64(floats)++ // Verify it's valid base64+ decoded, err := base64.StdEncoding.DecodeString(result)+ if err != nil {+ t.Fatalf("failed to decode base64: %v", err)+ }++ // Check length+ expectedBytes := len(floats) * 4+ if len(decoded) != expectedBytes {+ t.Errorf("expected %d bytes, got %d", expectedBytes, len(decoded))+ }++ // Decode and verify values+ for i, expected := range floats {+ offset := i * 4+ bits := uint32(decoded[offset]) |+ uint32(decoded[offset+1])<<8 |+ uint32(decoded[offset+2])<<16 |+ uint32(decoded[offset+3])<<24+ decodedFloat := math.Float32frombits(bits)++ if math.Abs(float64(decodedFloat-expected)) > 1e-6 {+ t.Errorf("float[%d]: expected %f, got %f", i, expected, decodedFloat)+ }+ }+}++func TestFloatsToBase64_EmptySlice(t *testing.T) {+ result := floatsToBase64([]float32{})++ // Should return valid base64 for empty slice+ decoded, err := base64.StdEncoding.DecodeString(result)+ if err != nil {+ t.Fatalf("failed to decode base64: %v", err)+ }++ if len(decoded) != 0 {+ t.Errorf("expected 0 bytes, got %d", len(decoded))+ }+}