parse []interface{} as multi vector for target vector: %s, u

Error message

parse []interface{} as multi vector for target vector: %s, unrecognized type: %T

What it means

While flattening a [][]interface{} multi-vector into [][]float32, an inner element was neither json.Number, float64, nor float32 — e.g. a string, bool, null, or an extra level of nesting. The error reports the type of vec[i] (the offending inner value) and the targetVector name.

Source

Thrown at entities/dto/dto.go:140

					multiVectors = make(map[string][][]float32)
				}
				asMultiVectorArray := make([][]float32, len(vec))
				for i := range vec {
					asMultiVectorArray[i] = make([]float32, len(vec[i]))
					for j := range vec[i] {
						switch v := vec[i][j].(type) {
						case json.Number:
							asFloat, err := v.Float64()
							if err != nil {
								return nil, nil, fmt.Errorf("parse []interface{} as multi vector for target vector: %s: %w", targetVector, err)
							}
							asMultiVectorArray[i][j] = float32(asFloat)
						case float64:
							asMultiVectorArray[i][j] = float32(v)
						case float32:
							asMultiVectorArray[i][j] = v
						default:
							return nil, nil, fmt.Errorf("parse []interface{} as multi vector for target vector: %s, unrecognized type: %T", targetVector, vec[i])
						}
					}
				}
				multiVectors[targetVector] = asMultiVectorArray
			case []float32:
				if vectors == nil {
					vectors = make(map[string][]float32)
				}
				vectors[targetVector] = vec
			case [][]float32:
				if multiVectors == nil {
					multiVectors = make(map[string][][]float32)
				}
				multiVectors[targetVector] = vec
			default:
				return nil, nil, fmt.Errorf("unrecognized vector type: %T for target vector: %s", vector, targetVector)
			}
		}

View on GitHub (pinned to 75aa4b6d11)

Solutions

Ensure the payload is exactly two levels: array of arrays of numbers
Replace strings/bools/nulls with valid numbers in the inner arrays
Verify the collection's vector config matches multi-vector input; flatten to single vector if it is not

Example fix

// before
{"multi_vector": [["0.1", 0.2], [0.3]]}
// after
{"multi_vector": [[0.1, 0.2], [0.3]]}

Defensive patterns

Strategy: validation

Validate before calling

func validMultiVectorShape(vec [][]interface{}) error {
    for i, inner := range vec {
        for j, e := range inner {
            switch e.(type) {
            case json.Number, float64, float32:
            default:
                return fmt.Errorf("[%d][%d] not a number: %T", i, j, e)
            }
        }
    }
    return nil
}

Type guard

func isFlatNumberMatrix(v interface{}) bool {
    m, ok := v.([][]interface{})
    if !ok { return false }
    for _, inner := range m {
        for _, e := range inner {
            switch e.(type) {
            case json.Number, float64, float32:
            default:
                return false
            }
        }
    }
    return true
}

Try / catch

_, _, err := dto.GetVectors(in)
if err != nil {
    if strings.Contains(err.Error(), "as multi vector") && strings.Contains(err.Error(), "unrecognized type") {
        return badRequest("multi-vector inner elements must be numbers")
    }
    return err
}

Prevention

Use exactly two nesting levels for multi-vectors — no deeper
Serialize multi-vectors as [][]float32 client-side to eliminate string/null leaks
Confirm the collection supports multi-vectors before sending nested arrays

When it happens

Trigger: Multi-vector payloads ([][]interface{}) submitted via BatchPutObjects or object create/update where an inner array contains quoted numbers, nulls, or a triple-nested array for a named targetVector.

Common situations: Clients confusing single-vector and multi-vector shapes (adding an extra nesting level); JSON with stringified numbers or missing values inside inner arrays.

Related errors

AI-assisted analysis of weaviate/weaviate@75aa4b6d11 (2026-09-04). Data as JSON: /api/errors/cddc3fecc0899d91. Report an issue: GitHub.